pax_global_header00006660000000000000000000000064146211200450014505gustar00rootroot0000000000000052 comment=3fefb86a9492841c3c32328bc380aa710791b87f golang-github-jsimonetti-rtnetlink-2.0.2/000077500000000000000000000000001462112004500204305ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/.github/000077500000000000000000000000001462112004500217705ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/.github/dependabot.yml000066400000000000000000000003611462112004500246200ustar00rootroot00000000000000--- 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-2.0.2/.github/workflows/000077500000000000000000000000001462112004500240255ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/.github/workflows/go-test.yml000066400000000000000000000035501462112004500261350ustar00rootroot00000000000000on: [push, pull_request] name: Go jobs: macos_test: name: Test MacOS strategy: matrix: go-version: [1.21.x, 1.22.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@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4 - 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.21.x, 1.22.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@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4 - 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.21.x, 1.22.x] platform: [ubuntu-latest] runs-on: ${{ matrix.platform }} steps: - name: Check for vulnerabilities id: govulncheck uses: golang/govulncheck-action@3a32958c2706f7048305d5a2e53633d7e37e97d0 with: cache: false go-version-input: ${{ matrix.go-version }} go-package: ./... golang-github-jsimonetti-rtnetlink-2.0.2/.github/workflows/golangci-lint.yml000066400000000000000000000012411462112004500272750ustar00rootroot00000000000000--- 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@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4 - name: install Go uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5.0.0 with: go-version: 1.21.x - name: Lint uses: golangci/golangci-lint-action@9d1e0624a798bb64f6c3cea93db47765312263dc # v5.1.0 with: version: v1.54.2 golang-github-jsimonetti-rtnetlink-2.0.2/.gitignore000066400000000000000000000000221462112004500224120ustar00rootroot00000000000000rtnetlink-fuzz.zipgolang-github-jsimonetti-rtnetlink-2.0.2/.golangci.yml000066400000000000000000000005701462112004500230160ustar00rootroot00000000000000--- 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-2.0.2/LICENSE.md000066400000000000000000000020751462112004500220400ustar00rootroot00000000000000MIT 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-2.0.2/Makefile.fuzz000066400000000000000000000015411462112004500230660ustar00rootroot00000000000000# 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-2.0.2/README.md000066400000000000000000000035361462112004500217160ustar00rootroot00000000000000rtnetlink ![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-2.0.2/address.go000066400000000000000000000145421462112004500224120ustar00rootroot00000000000000package rtnetlink import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/v2/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 { Preferred 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.Preferred = 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-2.0.2/address_test.go000066400000000000000000000103641462112004500234470ustar00rootroot00000000000000package rtnetlink import ( "encoding/binary" "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/v2/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{ Preferred: 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-2.0.2/conn.go000066400000000000000000000121741462112004500217210ustar00rootroot00000000000000package rtnetlink import ( "encoding" "time" "github.com/jsimonetti/rtnetlink/v2/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-2.0.2/conn_test.go000066400000000000000000000116511462112004500227570ustar00rootroot00000000000000//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-2.0.2/doc.go000066400000000000000000000024121462112004500215230ustar00rootroot00000000000000// 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-2.0.2/driver/000077500000000000000000000000001462112004500217235ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/driver/bond.go000066400000000000000000000602341462112004500232010ustar00rootroot00000000000000package driver import ( "fmt" "net" "github.com/jsimonetti/rtnetlink/v2" "github.com/jsimonetti/rtnetlink/v2/internal/unix" "github.com/mdlayher/netlink" ) // BondMode specifies one of the bonding policies. type BondMode uint8 const ( // Round-robin policy: Transmit packets in sequential order from the first available slave through the last // This is the default value BondModeBalanceRR BondMode = iota // Active-backup policy: Only one slave in the bond is active. A different slave becomes active if, and only if, // the active slave fails. The bond’s MAC address is externally visible on only one port (network adapter) to // avoid confusing the switch. BondModeActiveBackup // XOR policy: Transmit based on the selected transmit hash policy. // The default policy is BOND_XMIT_HASH_POLICY_LAYER2 // Alternate transmit policies may be selected via the XmitHashPolicy option BondModeBalanceXOR // Broadcast policy: transmits everything on all slave interfaces BondModeBroadcast // IEEE 802.3ad Dynamic link aggregation. Creates aggregation groups that share the same speed and duplex settings. // Utilizes all slaves in the active aggregator according to the 802.3ad specification BondMode802_3AD // Adaptive transmit load balancing: channel bonding that does not require any special switch support // Outgoing traffic is configured by TlbDynamicLb field // Incoming traffic is received by the current slave. If the receiving slave fails, // another slave takes over the MAC address of the failed receiving slave. BondModeBalanceTLB // Adaptive load balancing: includes balance-tlb plus receive load balancing (rlb) for IPV4 traffic, // and does not require any special switch support BondModeBalanceALB BondModeUnknown ) func (b BondMode) String() string { switch b { case BondModeBalanceRR: return "balance-rr" case BondModeActiveBackup: return "active-backup" case BondModeBalanceXOR: return "balance-xor" case BondModeBroadcast: return "broadcast" case BondMode802_3AD: return "802.3ad" case BondModeBalanceTLB: return "balance-tld" case BondModeBalanceALB: return "balance-alb" default: return fmt.Sprintf("unknown BondMode value (%d)", b) } } // BondArpValidate specifies whether or not ARP probes and replies should be validated in any mode that // supports arp monitoring, or whether non-ARP traffic should be filtered (disregarded) for link monitoring purposes. type BondArpValidate uint32 const ( // No validation or filtering is performed BondArpValidateNone BondArpValidate = iota // Validation is performed only for the active slave BondArpValidateActive // Validation is performed only for backup slaves BondArpValidateBackup // Validation is performed for all slaves BondArpValidateAll // Filtering is applied to all slaves. No validation is performed BondArpValidateFilter // Filtering is applied to all slaves, validation is performed only for the active slave BondArpValidateFilterActive // Filtering is applied to all slaves, validation is performed only for backup slaves BondArpValidateFilterBackup ) func (b BondArpValidate) String() string { switch b { case BondArpValidateNone: return "none" case BondArpValidateActive: return "active" case BondArpValidateBackup: return "backup" case BondArpValidateAll: return "all" case BondArpValidateFilter: return "filter" case BondArpValidateFilterActive: return "filter_active" case BondArpValidateFilterBackup: return "filter_backup" default: return fmt.Sprintf("unknown BondArpValidate value (%d)", b) } } // BondArpAllTargets specifies the quantity of arp_ip_targets that must be reachable in order for the ARP monitor // to consider a slave as being up. This option affects only active-backup mode for slaves with arp_validation enabled. type BondArpAllTargets uint32 const ( // Consider the slave up only when any of the arp_ip_targets is reachable BondArpAllTargetsAny BondArpAllTargets = iota // Consider the slave up only when all of the arp_ip_targets are reachable BondArpAllTargetsAll ) func (b BondArpAllTargets) String() string { switch b { case BondArpAllTargetsAny: return "any" case BondArpAllTargetsAll: return "all" default: return fmt.Sprintf("unknown BondArpAllTargets value (%d)", b) } } // Specifies the reselection policy for the primary slave. This affects how the primary slave is // chosen to become the active slave when failure of the active slave or recovery of the primary slave occurs. // This option is designed to prevent flip-flopping between the primary slave and other slaves type BondPrimaryReselect uint8 const ( // The primary slave becomes the active slave whenever it comes back up, this is the default value BondPrimaryReselectAlways BondPrimaryReselect = iota // The primary slave becomes the active slave when it comes back up, // if the speed and duplex of the primary slave is better than the speed and duplex of the current active slave BondPrimaryReselectBetter // The primary slave becomes the active slave only if the current active slave fails and the primary slave is up BondPrimaryReselectFailure ) func (b BondPrimaryReselect) String() string { switch b { case BondPrimaryReselectAlways: return "always" case BondPrimaryReselectBetter: return "better" case BondPrimaryReselectFailure: return "failure" default: return fmt.Sprintf("unknown BondPrimaryReselect value (%d)", b) } } // BondFailOverMac specifies whether active-backup mode should set all slaves to the same MAC address at enslavement // (the traditional behavior), or, when enabled, perform special handling of the bond’s MAC address // in accordance with the selected policy. type BondFailOverMac uint8 const ( // This setting disables fail_over_mac, and causes bonding to set all slaves of an active-backup bond // to the same MAC address at enslavement time BondFailOverMacNone BondFailOverMac = iota // The “active” fail_over_mac policy indicates that the MAC address of the bond should always be // the MAC address of the currently active slave. The MAC address of the slaves is not changed; // instead, the MAC address of the bond changes during a failover BondFailOverMacActive // The “follow” fail_over_mac policy causes the MAC address of the bond to be selected normally // (normally the MAC address of the first slave added to the bond) // However, the second and subsequent slaves are not set to this MAC address while they are in a backup role; // a slave is programmed with the bond’s MAC address at failover time // (and the formerly active slave receives the newly active slave’s MAC address) BondFailOverMacFollow ) func (b BondFailOverMac) String() string { switch b { case BondFailOverMacNone: return "none" case BondFailOverMacActive: return "active" case BondFailOverMacFollow: return "follow" default: return fmt.Sprintf("unknown BondPrimaryReselect value (%d)", b) } } // BondXmitHashPolicy specifies the transmit hash policy to use for // slave selection in balance-xor, 802.3ad, and tlb modes. type BondXmitHashPolicy uint8 const ( // Uses XOR of hardware MAC addresses and packet type ID field to generate the hash BondXmitHashPolicyLayer2 BondXmitHashPolicy = iota // This policy uses upper layer protocol information, when available, to generate the hash // This allows for traffic to a particular network peer to span multiple slaves, // although a single connection will not span multiple slaves BondXmitHashPolicyLayer3_4 // This policy uses a combination of layer2 and layer3 protocol information to generate the hash // Uses XOR of hardware MAC addresses and IP addresses to generate the hash BondXmitHashPolicyLayer2_3 // This policy uses the same formula as layer2+3 but it relies on skb_flow_dissect to obtain // the header fields which might result in the use of inner headers if an encapsulation protocol is used BondXmitHashPolicyEncap2_3 // This policy uses the same formula as layer3+4 but it relies on skb_flow_dissect to obtain // the header fields which might result in the use of inner headers if an encapsulation protocol is used BondXmitHashPolicyEncap3_4 // This policy uses a very rudimentary vlan ID and source mac hash to load-balance traffic per-vlan, // with failover should one leg fail BondXmitHashPolicyVlanSrcMAC ) func (b BondXmitHashPolicy) String() string { switch b { case BondXmitHashPolicyLayer2: return "layer2" case BondXmitHashPolicyLayer3_4: return "layer3+4" case BondXmitHashPolicyLayer2_3: return "layer2+3" case BondXmitHashPolicyEncap2_3: return "encap2+3" case BondXmitHashPolicyEncap3_4: return "encap3+4" case BondXmitHashPolicyVlanSrcMAC: return "vlan+srcmac" default: return fmt.Sprintf("unknown BondXmitHashPolicy value (%d)", b) } } // BondAdLacpActive specifies whether to send LACPDU frames periodically. type BondAdLacpActive uint8 const ( // LACPDU frames acts as “speak when spoken to” BondAdLacpActiveOff BondAdLacpActive = iota // LACPDU frames are sent along the configured links periodically with the rate configured with BondLacpRate // This is the default value BondAdLacpActiveOn ) func (b BondAdLacpActive) String() string { switch b { case BondAdLacpActiveOff: return "off" case BondAdLacpActiveOn: return "on" default: return fmt.Sprintf("unknown BondLacpActive value (%d)", b) } } // Option specifying the rate in which we’ll ask our link partner to transmit LACPDU packets in 802.3ad mode. type BondLacpRate uint8 const ( // Request partner to transmit LACPDUs every 30 seconds // This is the default value BondLacpRateSlow BondLacpRate = iota // Request partner to transmit LACPDUs every 1 second BondLacpRateFast ) func (b BondLacpRate) String() string { switch b { case BondLacpRateSlow: return "slow" case BondLacpRateFast: return "fast" default: return fmt.Sprintf("unknown BondLacpRate value (%d)", b) } } // BondAdSelect specifies the 802.3ad aggregation selection logic to use. type BondAdSelect uint8 const ( // The active aggregator is chosen by largest aggregate bandwidth // Reselection of the active aggregator occurs only when all slaves of the active aggregator // are down or the active aggregator has no slaves // This is the default value. BondAdSelectStable BondAdSelect = iota // The active aggregator is chosen by largest aggregate bandwidth. // Reselection occurs if: // - A slave is added to or removed from the bond // - Any slave’s link state changes // - Any slave’s 802.3ad association state changes // - The bond’s administrative state changes to up BondAdSelectBandwidth // The active aggregator is chosen by the largest number of ports (slaves) // Reselection rules are the same with BOND_AD_SELECT_BANDWIDTH BondAdSelectCount ) func (b BondAdSelect) String() string { switch b { case BondAdSelectStable: return "stable" case BondAdSelectBandwidth: return "bandwidth" case BondAdSelectCount: return "count" default: return fmt.Sprintf("unknown BondAdSelect value (%d)", b) } } // BondAdInfo specifies the 802.3ad aggregation information type BondAdInfo struct { AggregatorId uint16 NumPorts uint16 ActorKey uint16 PartnerKey uint16 PartnerMac net.HardwareAddr } const bondMaxTargets = 16 // Bond implements LinkDriver for the bond driver type Bond struct { // For more detailed information see https://www.kernel.org/doc/html/latest/networking/bonding.html // Specifies the bonding policy. The default is balance-rr (round robin) Mode BondMode // Specifies the new active slave for modes that support it (active-backup, balance-alb and balance-tlb) ActiveSlave *uint32 // Specifies the MII link monitoring frequency in milliseconds Miimon *uint32 // Specifies the time, in milliseconds, to wait before enabling a slave after a link recovery has been detected UpDelay *uint32 // Specifies the time, in milliseconds, to wait before disabling a slave after a link failure has been detected DownDelay *uint32 // Specify the delay, in milliseconds, between each peer notification PeerNotifyDelay *uint32 // Specifies whether or not miimon should use MII or ETHTOOL UseCarrier *uint8 // Specifies the ARP link monitoring frequency in milliseconds ArpInterval *uint32 // Specifies the IP addresses to use as ARP monitoring peers when arp_interval is > 0 ArpIpTargets []net.IP // Specifies the IPv6 addresses to use as IPv6 monitoring peers when arp_interval is > 0 NsIP6Targets []net.IP // Specifies whether or not ARP probes and replies should be validated ArpValidate *BondArpValidate // Specifies the quantity of arp_ip_targets that must be reachable in order for the ARP monitor to consider a slave as being up ArpAllTargets *BondArpAllTargets // A device index specifying which slave is the primary device Primary *uint32 // Specifies the reselection policy for the primary slave PrimaryReselect *BondPrimaryReselect // Specifies whether active-backup mode should set all slaves to the same MAC address at enslavement, when enabled, or perform special handling FailOverMac *BondFailOverMac // Selects the transmit hash policy to use for slave selection XmitHashPolicy *BondXmitHashPolicy // Specifies the number of IGMP membership reports to be issued after a failover event ResendIgmp *uint32 // Specify the number of peer notifications (gratuitous ARPs and unsolicited IPv6 Neighbor Advertisements) to be issued after a failover event NumPeerNotif *uint8 // Specifies that duplicate frames (received on inactive ports) should be dropped (0) or delivered (1) AllSlavesActive *uint8 // Specifies the minimum number of links that must be active before asserting carrier MinLinks *uint32 // Specifies the number of seconds between instances where the bonding driver sends learning packets to each slaves peer switch LpInterval *uint32 // Specify the number of packets to transmit through a slave before moving to the next one PacketsPerSlave *uint32 // Option specifying whether to send LACPDU frames periodically AdLacpActive *BondAdLacpActive // Option specifying the rate in which we’ll ask our link partner to transmit LACPDU packets AdLacpRate *BondLacpRate // Specifies the 802.3ad aggregation selection logic to use AdSelect *BondAdSelect // In an AD system, this specifies the system priority AdActorSysPrio *uint16 // Defines the upper 10 bits of the port key AdUserPortKey *uint16 // In an AD system, this specifies the mac-address for the actor in protocol packet exchanges AdActorSystem net.HardwareAddr // Specifies if dynamic shuffling of flows is enabled in tlb or alb mode TlbDynamicLb *uint8 // Specifies the number of arp_interval monitor checks that must fail in order for an interface to be marked down by the ARP monitor MissedMax *uint8 // Specifies the 802.3ad aggregation information, this is read only value AdInfo *BondAdInfo } var _ rtnetlink.LinkDriver = &Bond{} func (b *Bond) New() rtnetlink.LinkDriver { return &Bond{} } func (b *Bond) Encode(ae *netlink.AttributeEncoder) error { if b.Mode < BondModeUnknown { ae.Uint8(unix.IFLA_BOND_MODE, uint8(b.Mode)) } if b.ActiveSlave != nil { ae.Uint32(unix.IFLA_BOND_ACTIVE_SLAVE, *b.ActiveSlave) } if b.Miimon != nil { ae.Uint32(unix.IFLA_BOND_MIIMON, *b.Miimon) } if b.UpDelay != nil { ae.Uint32(unix.IFLA_BOND_UPDELAY, *b.UpDelay) } if b.DownDelay != nil { ae.Uint32(unix.IFLA_BOND_DOWNDELAY, *b.DownDelay) } if b.PeerNotifyDelay != nil { ae.Uint32(unix.IFLA_BOND_PEER_NOTIF_DELAY, *b.PeerNotifyDelay) } if b.UseCarrier != nil { ae.Uint8(unix.IFLA_BOND_USE_CARRIER, *b.UseCarrier) } if b.ArpInterval != nil { ae.Uint32(unix.IFLA_BOND_ARP_INTERVAL, *b.ArpInterval) } if b.ArpIpTargets != nil { if lb := len(b.ArpIpTargets); lb > bondMaxTargets { return fmt.Errorf("exceeded max ArpIpTargets %d, %d", bondMaxTargets, lb) } ae.Nested(unix.IFLA_BOND_ARP_IP_TARGET, func(nae *netlink.AttributeEncoder) error { for i := range b.ArpIpTargets { ip := b.ArpIpTargets[i].To4() if ip == nil { return fmt.Errorf("%s is not an ip4 address", ip) } nae.Bytes(uint16(i), ip) } return nil }) } if b.NsIP6Targets != nil { if lb := len(b.ArpIpTargets); lb > bondMaxTargets { return fmt.Errorf("exceeded max NsIP6Targets %d, %d", bondMaxTargets, lb) } ae.Nested(unix.IFLA_BOND_NS_IP6_TARGET, func(nae *netlink.AttributeEncoder) error { for i := range b.NsIP6Targets { ip := b.NsIP6Targets[i].To16() if ip == nil { return fmt.Errorf("%s is not an ip6 address", ip) } nae.Bytes(uint16(i), ip) } return nil }) } if b.ArpValidate != nil { ae.Uint32(unix.IFLA_BOND_ARP_VALIDATE, uint32(*b.ArpValidate)) } if b.ArpAllTargets != nil { ae.Uint32(unix.IFLA_BOND_ARP_ALL_TARGETS, uint32(*b.ArpAllTargets)) } if b.Primary != nil { ae.Uint32(unix.IFLA_BOND_PRIMARY, *b.Primary) } if b.PrimaryReselect != nil { ae.Uint8(unix.IFLA_BOND_PRIMARY_RESELECT, uint8(*b.PrimaryReselect)) } if b.FailOverMac != nil { ae.Uint8(unix.IFLA_BOND_FAIL_OVER_MAC, uint8(*b.FailOverMac)) } if b.XmitHashPolicy != nil { ae.Uint8(unix.IFLA_BOND_XMIT_HASH_POLICY, uint8(*b.XmitHashPolicy)) } if b.ResendIgmp != nil { ae.Uint32(unix.IFLA_BOND_RESEND_IGMP, *b.ResendIgmp) } if b.NumPeerNotif != nil { ae.Uint8(unix.IFLA_BOND_NUM_PEER_NOTIF, *b.NumPeerNotif) } if b.AllSlavesActive != nil { ae.Uint8(unix.IFLA_BOND_ALL_SLAVES_ACTIVE, *b.AllSlavesActive) } if b.MinLinks != nil { ae.Uint32(unix.IFLA_BOND_MIN_LINKS, *b.MinLinks) } if b.LpInterval != nil { ae.Uint32(unix.IFLA_BOND_LP_INTERVAL, *b.LpInterval) } if b.PacketsPerSlave != nil { ae.Uint32(unix.IFLA_BOND_PACKETS_PER_SLAVE, *b.PacketsPerSlave) } if b.AdLacpActive != nil { ae.Uint8(unix.IFLA_BOND_AD_LACP_ACTIVE, uint8(*b.AdLacpActive)) } if b.AdLacpRate != nil { ae.Uint8(unix.IFLA_BOND_AD_LACP_RATE, uint8(*b.AdLacpRate)) } if b.AdSelect != nil { ae.Uint8(unix.IFLA_BOND_AD_SELECT, uint8(*b.AdSelect)) } if b.AdActorSysPrio != nil { ae.Uint16(unix.IFLA_BOND_AD_ACTOR_SYS_PRIO, *b.AdActorSysPrio) } if b.AdUserPortKey != nil { ae.Uint16(unix.IFLA_BOND_AD_USER_PORT_KEY, *b.AdUserPortKey) } if b.AdActorSystem != nil { ae.Bytes(unix.IFLA_BOND_AD_ACTOR_SYSTEM, []byte(b.AdActorSystem)) } if b.TlbDynamicLb != nil { ae.Uint8(unix.IFLA_BOND_TLB_DYNAMIC_LB, *b.TlbDynamicLb) } if b.MissedMax != nil { ae.Uint8(unix.IFLA_BOND_MISSED_MAX, *b.MissedMax) } return nil } func (b *Bond) Decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFLA_BOND_MODE: b.Mode = BondMode(ad.Uint8()) case unix.IFLA_BOND_ACTIVE_SLAVE: v := ad.Uint32() b.ActiveSlave = &v case unix.IFLA_BOND_MIIMON: v := ad.Uint32() b.Miimon = &v case unix.IFLA_BOND_UPDELAY: v := ad.Uint32() b.UpDelay = &v case unix.IFLA_BOND_DOWNDELAY: v := ad.Uint32() b.DownDelay = &v case unix.IFLA_BOND_PEER_NOTIF_DELAY: v := ad.Uint32() b.PeerNotifyDelay = &v case unix.IFLA_BOND_USE_CARRIER: v := ad.Uint8() b.UseCarrier = &v case unix.IFLA_BOND_ARP_INTERVAL: v := ad.Uint32() b.ArpInterval = &v case unix.IFLA_BOND_ARP_IP_TARGET: ad.Nested(func(nad *netlink.AttributeDecoder) error { for nad.Next() { b.ArpIpTargets = append(b.ArpIpTargets, nad.Bytes()) } return nil }) case unix.IFLA_BOND_NS_IP6_TARGET: ad.Nested(func(nad *netlink.AttributeDecoder) error { for nad.Next() { b.NsIP6Targets = append(b.NsIP6Targets, nad.Bytes()) } return nil }) case unix.IFLA_BOND_ARP_VALIDATE: v := BondArpValidate(ad.Uint32()) b.ArpValidate = &v case unix.IFLA_BOND_ARP_ALL_TARGETS: v := BondArpAllTargets(ad.Uint32()) b.ArpAllTargets = &v case unix.IFLA_BOND_PRIMARY: v := ad.Uint32() b.Primary = &v case unix.IFLA_BOND_PRIMARY_RESELECT: v := BondPrimaryReselect(ad.Uint8()) b.PrimaryReselect = &v case unix.IFLA_BOND_FAIL_OVER_MAC: v := BondFailOverMac(ad.Uint8()) b.FailOverMac = &v case unix.IFLA_BOND_XMIT_HASH_POLICY: v := BondXmitHashPolicy(ad.Uint8()) b.XmitHashPolicy = &v case unix.IFLA_BOND_RESEND_IGMP: v := ad.Uint32() b.ResendIgmp = &v case unix.IFLA_BOND_NUM_PEER_NOTIF: v := ad.Uint8() b.NumPeerNotif = &v case unix.IFLA_BOND_ALL_SLAVES_ACTIVE: v := ad.Uint8() b.AllSlavesActive = &v case unix.IFLA_BOND_MIN_LINKS: v := ad.Uint32() b.MinLinks = &v case unix.IFLA_BOND_LP_INTERVAL: v := ad.Uint32() b.LpInterval = &v case unix.IFLA_BOND_PACKETS_PER_SLAVE: v := ad.Uint32() b.PacketsPerSlave = &v case unix.IFLA_BOND_AD_LACP_ACTIVE: v := BondAdLacpActive(ad.Uint8()) b.AdLacpActive = &v case unix.IFLA_BOND_AD_LACP_RATE: v := BondLacpRate(ad.Uint8()) b.AdLacpRate = &v case unix.IFLA_BOND_AD_SELECT: v := BondAdSelect(ad.Uint8()) b.AdSelect = &v case unix.IFLA_BOND_AD_ACTOR_SYS_PRIO: v := ad.Uint16() b.AdActorSysPrio = &v case unix.IFLA_BOND_AD_USER_PORT_KEY: v := ad.Uint16() b.AdUserPortKey = &v case unix.IFLA_BOND_AD_ACTOR_SYSTEM: b.AdActorSystem = ad.Bytes() case unix.IFLA_BOND_TLB_DYNAMIC_LB: v := ad.Uint8() b.TlbDynamicLb = &v case unix.IFLA_BOND_MISSED_MAX: v := ad.Uint8() b.MissedMax = &v case unix.IFLA_BOND_AD_INFO: ad.Nested(func(nad *netlink.AttributeDecoder) error { b.AdInfo = &BondAdInfo{} for nad.Next() { switch nad.Type() { case unix.IFLA_BOND_AD_INFO_AGGREGATOR: b.AdInfo.AggregatorId = nad.Uint16() case unix.IFLA_BOND_AD_INFO_NUM_PORTS: b.AdInfo.NumPorts = nad.Uint16() case unix.IFLA_BOND_AD_INFO_ACTOR_KEY: b.AdInfo.ActorKey = nad.Uint16() case unix.IFLA_BOND_AD_INFO_PARTNER_KEY: b.AdInfo.PartnerKey = nad.Uint16() case unix.IFLA_BOND_AD_INFO_PARTNER_MAC: b.AdInfo.PartnerMac = nad.Bytes() } } return nil }) } } return nil } func (*Bond) Kind() string { return "bond" } // BondSlaveState specifies bond slave state type BondSlaveState uint8 const ( BondStateActive BondSlaveState = iota BondStateBackup ) func (b BondSlaveState) String() string { switch b { case BondStateActive: return "ACTIVE" case BondStateBackup: return "BACKUP" default: return fmt.Sprintf("unknown BondSlaveState value %d", b) } } // BondSlaveMiiStatus MII link monitoring frequency status type BondSlaveMiiStatus uint8 const ( BondLinkUp BondSlaveMiiStatus = iota BondLinkFail BondLinkDown BondLinkBack ) func (b BondSlaveMiiStatus) String() string { switch b { case BondLinkUp: return "UP" case BondLinkFail: return "GOING_DOWN" case BondLinkDown: return "DOWN" case BondLinkBack: return "GOING_BACK" default: return fmt.Sprintf("unknown BondSlaveMiiStatus value %d", b) } } // BondSlave implements LinkSlaveDriver interface for bond driver type BondSlave struct { State *BondSlaveState MiiStatus *BondSlaveMiiStatus LinkFailureCount *uint32 PermHardwareAddr net.HardwareAddr QueueId *uint16 Priority *int32 AggregatorId *uint16 AdActorOperPortState *uint8 AdPartnerOperPortState *uint16 } var _ rtnetlink.LinkSlaveDriver = &BondSlave{} func (b *BondSlave) New() rtnetlink.LinkDriver { return &BondSlave{} } func (b *BondSlave) Slave() {} func (b *BondSlave) Encode(ae *netlink.AttributeEncoder) error { if b.QueueId != nil { ae.Uint16(unix.IFLA_BOND_SLAVE_QUEUE_ID, *b.QueueId) } if b.Priority != nil { ae.Int32(unix.IFLA_BOND_SLAVE_PRIO, *b.Priority) } return nil } func (b *BondSlave) Decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFLA_BOND_SLAVE_STATE: v := BondSlaveState(ad.Uint8()) b.State = &v case unix.IFLA_BOND_SLAVE_MII_STATUS: v := BondSlaveMiiStatus(ad.Uint8()) b.MiiStatus = &v case unix.IFLA_BOND_SLAVE_LINK_FAILURE_COUNT: v := ad.Uint32() b.LinkFailureCount = &v case unix.IFLA_BOND_SLAVE_PERM_HWADDR: b.PermHardwareAddr = net.HardwareAddr(ad.Bytes()) case unix.IFLA_BOND_SLAVE_QUEUE_ID: v := ad.Uint16() b.QueueId = &v case unix.IFLA_BOND_SLAVE_PRIO: v := ad.Int32() b.Priority = &v case unix.IFLA_BOND_SLAVE_AD_AGGREGATOR_ID: v := ad.Uint16() b.AggregatorId = &v case unix.IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE: v := ad.Uint8() b.AdActorOperPortState = &v case unix.IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE: v := ad.Uint16() b.AdPartnerOperPortState = &v } } return nil } func (*BondSlave) Kind() string { return "bond" } golang-github-jsimonetti-rtnetlink-2.0.2/driver/bond_live_test.go000066400000000000000000000116751462112004500252640ustar00rootroot00000000000000//go:build integration // +build integration package driver import ( "fmt" "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/v2" "github.com/jsimonetti/rtnetlink/v2/internal/testutils" "github.com/mdlayher/netlink" ) func bondT(d rtnetlink.LinkDriver) *Bond { b := d.(*Bond) return &Bond{ Mode: b.Mode, Miimon: b.Miimon, ArpInterval: b.ArpInterval, ArpIpTargets: b.ArpIpTargets, NsIP6Targets: b.NsIP6Targets, } } func bondSlaveT(d rtnetlink.LinkDriver) *BondSlave { b := d.(*BondSlave) return &BondSlave{ State: b.State, MiiStatus: b.MiiStatus, Priority: b.Priority, } } func TestBond(t *testing.T) { conn, err := rtnetlink.Dial(nil) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() connNS, err := rtnetlink.Dial(&netlink.Config{NetNS: testutils.NetNS(t)}) if err != nil { t.Fatalf("failed to establish netlink socket to netns: %v", err) } defer connNS.Close() var ( ssa = BondStateActive ssb = BondStateBackup miiup = BondLinkUp u325 uint32 = 5 u32100 uint32 = 100 u32 uint32 i321 int32 = 1 i32 int32 ) tests := []struct { name string conn *rtnetlink.Conn driver *Bond bond *Bond setSlave bool dummy []BondSlave }{ { name: "with default mode and miion is set", conn: conn, driver: &Bond{ Miimon: &u32100, }, bond: &Bond{ Mode: BondModeBalanceRR, Miimon: &u32100, ArpInterval: &u32, }, dummy: []BondSlave{ { State: &ssa, MiiStatus: &miiup, Priority: &i32, }, { State: &ssa, MiiStatus: &miiup, Priority: &i32, }, }, }, { name: "with active backup, and arp ip targets list", conn: connNS, driver: &Bond{ Mode: BondModeActiveBackup, ArpInterval: &u325, ArpIpTargets: []net.IP{{192, 168, 222, 2}, {192, 168, 222, 3}}, }, bond: &Bond{ Mode: BondModeActiveBackup, Miimon: &u32, ArpInterval: &u325, ArpIpTargets: []net.IP{{192, 168, 222, 2}, {192, 168, 222, 3}}, }, setSlave: true, dummy: []BondSlave{ { State: &ssb, MiiStatus: &miiup, Priority: &i32, }, { State: &ssa, MiiStatus: &miiup, Priority: &i321, }, }, }, { name: "with balanced xor, and arp ns ipv6 list", conn: connNS, driver: &Bond{ Mode: BondModeBalanceXOR, ArpInterval: &u325, NsIP6Targets: []net.IP{ {0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, {0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, }, }, bond: &Bond{ Mode: BondModeBalanceXOR, Miimon: &u32, ArpInterval: &u325, NsIP6Targets: []net.IP{ {0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, {0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, }, }, dummy: []BondSlave{ { State: &ssa, MiiStatus: &miiup, Priority: &i32, }, { State: &ssa, MiiStatus: &miiup, Priority: &i32, }, }, }, } for i, tt := range tests { t.Run(tt.name, func(t *testing.T) { bondID := 1100 + uint32(i*10) if err := setupInterface(tt.conn, fmt.Sprintf("b%d", bondID), bondID, 0, tt.driver); err != nil { t.Fatalf("failed to setup bond interface: %v", err) } defer tt.conn.Link.Delete(bondID) msg, err := getInterface(tt.conn, bondID) if err != nil { t.Fatalf("failed to get primary netkit interface: %v", err) } if diff := cmp.Diff(tt.bond, bondT(msg.Attributes.Info.Data)); diff != "" { t.Error(diff) } slave1ID := 1101 + uint32(i*10) if err := setupInterface(tt.conn, fmt.Sprintf("d%d", slave1ID), slave1ID, bondID, &rtnetlink.LinkData{Name: "dummy"}); err != nil { t.Fatalf("failed to setup d%d interface: %v", slave1ID, err) } defer tt.conn.Link.Delete(slave1ID) slave2ID := 1102 + uint32(i*10) if err := setupInterface(tt.conn, fmt.Sprintf("d%d", slave2ID), slave2ID, bondID, &rtnetlink.LinkData{Name: "dummy"}); err != nil { t.Fatalf("failed to setup d1%d interface: %v", slave2ID, err) } defer tt.conn.Link.Delete(slave2ID) if tt.setSlave { tt.conn.Link.Set(&rtnetlink.LinkMessage{ Index: slave2ID, Attributes: &rtnetlink.LinkAttributes{ Info: &rtnetlink.LinkInfo{ SlaveKind: "bond", SlaveData: &BondSlave{ Priority: &i321, }, }, }, }) } for i, id := range []uint32{slave1ID, slave2ID} { msg, err = getInterface(tt.conn, id) if err != nil { t.Fatalf("failed to get peer netkit interface: %v", err) } if diff := cmp.Diff(&tt.dummy[i], bondSlaveT(msg.Attributes.Info.SlaveData)); diff != "" { t.Errorf("slave %d %s", i, diff) } } }) } } golang-github-jsimonetti-rtnetlink-2.0.2/driver/driver.go000066400000000000000000000010421462112004500235420ustar00rootroot00000000000000package driver import ( "github.com/jsimonetti/rtnetlink/v2" ) // init registers predefined drivers with the rtnetlink package. // // Currently, registering driver implementations that conflict with existing ones isn't supported. // Since most users don't need this feature, we'll keep it as is. // If required, we could consider implementing rtnetlink.UnregisterDriver to address this. func init() { for _, drv := range []rtnetlink.LinkDriver{ &Bond{}, &BondSlave{}, &Netkit{}, &Veth{}, } { _ = rtnetlink.RegisterDriver(drv) } } golang-github-jsimonetti-rtnetlink-2.0.2/driver/driver_test.go000066400000000000000000000017341462112004500246110ustar00rootroot00000000000000//go:build integration // +build integration package driver import ( "github.com/jsimonetti/rtnetlink/v2" "golang.org/x/sys/unix" ) // setupInterface create a interface for testing func setupInterface(conn *rtnetlink.Conn, name string, index, master uint32, driver rtnetlink.LinkDriver) error { attrs := &rtnetlink.LinkAttributes{ Name: name, Info: &rtnetlink.LinkInfo{Kind: driver.Kind(), Data: driver}, } flag := uint32(unix.IFF_UP) if master > 0 { attrs.Master = &master flag = 0 } // construct an interface to test drivers err := conn.Link.New(&rtnetlink.LinkMessage{ Family: unix.AF_UNSPEC, Index: index, Flags: flag, Change: flag, Attributes: attrs, }) if err != nil { conn.Link.Delete(index) } return err } func getInterface(conn *rtnetlink.Conn, index uint32) (*rtnetlink.LinkMessage, error) { interf, err := conn.Link.Get(index) if err != nil { conn.Link.Delete(interf.Index) return nil, err } return &interf, err } golang-github-jsimonetti-rtnetlink-2.0.2/driver/netkit.go000066400000000000000000000055131462112004500235540ustar00rootroot00000000000000package driver import ( "errors" "fmt" "github.com/jsimonetti/rtnetlink/v2" "github.com/jsimonetti/rtnetlink/v2/internal/unix" "github.com/mdlayher/netlink" ) // NetkitMode specifies netkit operation mode type NetkitMode uint32 func (n NetkitMode) String() string { switch n { case NetkitModeL2: return "layer2" case NetkitModeL3: return "layer3" default: return fmt.Sprintf("unknown NetkitMode value (%d)", n) } } const ( // Netkit operates on layer2 NetkitModeL2 NetkitMode = unix.NETKIT_L2 // Netkit operates on layer3, this is the default mode NetkitModeL3 NetkitMode = unix.NETKIT_L3 ) // NetkitPolicy specifies default packet policy when no eBPF program is attached type NetkitPolicy int32 func (n NetkitPolicy) String() string { switch n { case NetkitPolicyPass: return "forward" case NetkitPolicyDrop: return "blackhole" default: return fmt.Sprintf("unknown NetkitPolicy value (%d)", n) } } const ( // Default policy to forwards packets NetkitPolicyPass NetkitPolicy = unix.NETKIT_PASS // Default policy to drops packets NetkitPolicyDrop NetkitPolicy = unix.NETKIT_DROP ) // Netkit implements LinkDriverVerifier for the netkit driver type Netkit struct { Mode *NetkitMode // Specifies driver operation mode Policy *NetkitPolicy // Specifies default policy PeerPolicy *NetkitPolicy // Specifies default peer policy Primary bool // Shows primary link PeerInfo *rtnetlink.LinkMessage // Specifies peer link information } var _ rtnetlink.LinkDriverVerifier = &Netkit{} func (n *Netkit) New() rtnetlink.LinkDriver { return &Netkit{} } func (n *Netkit) Verify(msg *rtnetlink.LinkMessage) error { if msg.Attributes.Address != nil || (n.PeerInfo != nil && n.PeerInfo.Attributes != nil && n.PeerInfo.Attributes.Address != nil) { return errors.New("netkit does not support setting Ethernet address") } return nil } func (n *Netkit) Decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFLA_NETKIT_MODE: v := NetkitMode(ad.Uint32()) n.Mode = &v case unix.IFLA_NETKIT_POLICY: v := NetkitPolicy(ad.Int32()) n.Policy = &v case unix.IFLA_NETKIT_PEER_POLICY: v := NetkitPolicy(ad.Int32()) n.PeerPolicy = &v case unix.IFLA_NETKIT_PRIMARY: n.Primary = ad.Uint8() != 0 } } return nil } func (n *Netkit) Encode(ae *netlink.AttributeEncoder) error { if n.Mode != nil { ae.Uint32(unix.IFLA_NETKIT_MODE, uint32(*n.Mode)) } if n.Policy != nil { ae.Int32(unix.IFLA_NETKIT_POLICY, int32(*n.Policy)) } if n.PeerPolicy != nil { ae.Int32(unix.IFLA_NETKIT_PEER_POLICY, int32(*n.PeerPolicy)) } if n.PeerInfo != nil { b, err := n.PeerInfo.MarshalBinary() if err != nil { return err } ae.Bytes(unix.IFLA_NETKIT_PEER_INFO, b) } return nil } func (n *Netkit) Kind() string { return "netkit" } golang-github-jsimonetti-rtnetlink-2.0.2/driver/netkit_live_test.go000066400000000000000000000062061462112004500256320ustar00rootroot00000000000000//go:build integration // +build integration package driver import ( "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/v2" "github.com/jsimonetti/rtnetlink/v2/internal/testutils" "github.com/mdlayher/netlink" ) func TestNetkit(t *testing.T) { testutils.SkipOnOldKernel(t, "6.7", "netkit support") conn, err := rtnetlink.Dial(nil) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() ns := testutils.NetNS(t) connNS, err := rtnetlink.Dial(&netlink.Config{NetNS: ns}) if err != nil { t.Fatalf("failed to establish netlink socket to netns: %v", err) } defer connNS.Close() const ( ifIndex = 1011 ifPeerIndex = 1012 ) modeL2 := NetkitModeL2 modeL3 := NetkitModeL3 polPass := NetkitPolicyPass polDrop := NetkitPolicyDrop tests := []struct { name string linkName string pconn *rtnetlink.Conn driver *Netkit primary *Netkit peer *Netkit }{ { name: "with empty link names both in default ns", linkName: "", pconn: conn, driver: &Netkit{ PeerInfo: &rtnetlink.LinkMessage{ Index: ifPeerIndex, }, }, primary: &Netkit{ Mode: &modeL3, Policy: &polPass, PeerPolicy: &polPass, Primary: true, }, peer: &Netkit{ Mode: &modeL3, Policy: &polPass, PeerPolicy: &polPass, }, }, { name: "with names both in default ns", linkName: "nkp", pconn: conn, driver: &Netkit{ Mode: &modeL2, PeerInfo: &rtnetlink.LinkMessage{ Index: ifPeerIndex, Attributes: &rtnetlink.LinkAttributes{ Name: "nke", }, }, }, primary: &Netkit{ Mode: &modeL2, Policy: &polPass, PeerPolicy: &polPass, Primary: true, }, peer: &Netkit{ Mode: &modeL2, Policy: &polPass, PeerPolicy: &polPass, }, }, { name: "with one is in other ns", linkName: "nkp", pconn: connNS, driver: &Netkit{ Policy: &polPass, PeerPolicy: &polDrop, PeerInfo: &rtnetlink.LinkMessage{ Index: ifPeerIndex, Attributes: &rtnetlink.LinkAttributes{ Name: "nke", NetNS: rtnetlink.NetNSForFD(uint32(ns)), }, }, }, primary: &Netkit{ Mode: &modeL3, Policy: &polPass, PeerPolicy: &polDrop, Primary: true, }, peer: &Netkit{ Mode: &modeL3, Policy: &polDrop, PeerPolicy: &polPass, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if err := setupInterface(conn, tt.linkName, ifIndex, 0, tt.driver); err != nil { t.Fatalf("failed to setup netkit interface: %v", err) } defer conn.Link.Delete(ifIndex) msg, err := getInterface(conn, ifIndex) if err != nil { t.Fatalf("failed to get primary netkit interface: %v", err) } if diff := cmp.Diff(tt.primary, msg.Attributes.Info.Data); diff != "" { t.Error(diff) } msg, err = getInterface(tt.pconn, ifPeerIndex) if err != nil { t.Fatalf("failed to get peer netkit interface: %v", err) } if diff := cmp.Diff(tt.peer, msg.Attributes.Info.Data); diff != "" { t.Error(diff) } }) } } golang-github-jsimonetti-rtnetlink-2.0.2/driver/veth.go000066400000000000000000000021311462112004500232150ustar00rootroot00000000000000package driver import ( "fmt" "github.com/jsimonetti/rtnetlink/v2" "github.com/mdlayher/netlink" ) const veth_info_peer = 0x1 // Veth implements LinkDriverVerifier for the veth driver type Veth struct { PeerInfo *rtnetlink.LinkMessage // Specifies peer link information } var _ rtnetlink.LinkDriverVerifier = &Veth{} func (v *Veth) New() rtnetlink.LinkDriver { return &Veth{} } func (v *Veth) Encode(ae *netlink.AttributeEncoder) error { b, err := v.PeerInfo.MarshalBinary() if err != nil { return err } ae.Bytes(veth_info_peer, b) return nil } func (v *Veth) Decode(ad *netlink.AttributeDecoder) error { return nil } func (*Veth) Kind() string { return "veth" } const ( eth_min_mtu = 68 // Min IPv4 MTU per RFC791 eth_max_mtu = 65535 // 65535, same as IP_MAX_MTU ) func (v *Veth) Verify(msg *rtnetlink.LinkMessage) error { if msg.Attributes != nil && msg.Attributes.MTU > 0 && (msg.Attributes.MTU < eth_min_mtu || msg.Attributes.MTU > eth_max_mtu) { return fmt.Errorf("invalid MTU value %d, must be between %d %d", msg.Attributes.MTU, eth_min_mtu, eth_max_mtu) } return nil } golang-github-jsimonetti-rtnetlink-2.0.2/driver/veth_live_test.go000066400000000000000000000036761462112004500253120ustar00rootroot00000000000000//go:build integration // +build integration package driver import ( "testing" "github.com/jsimonetti/rtnetlink/v2" "github.com/jsimonetti/rtnetlink/v2/internal/testutils" "github.com/mdlayher/netlink" ) func TestVeth(t *testing.T) { conn, err := rtnetlink.Dial(nil) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() ns := testutils.NetNS(t) connNS, err := rtnetlink.Dial(&netlink.Config{NetNS: ns}) if err != nil { t.Fatalf("failed to establish netlink socket to netns: %v", err) } defer connNS.Close() const ( ifIndex = 1021 ifPeerIndex = 1022 ) tests := []struct { name string linkName string pconn *rtnetlink.Conn driver *Veth }{ { name: "with empty names both in default ns", pconn: conn, driver: &Veth{ PeerInfo: &rtnetlink.LinkMessage{ Index: ifPeerIndex, }, }, }, { name: "with names both in default ns", linkName: "vtp", pconn: conn, driver: &Veth{ PeerInfo: &rtnetlink.LinkMessage{ Index: ifPeerIndex, Attributes: &rtnetlink.LinkAttributes{ Name: "vte", }, }, }, }, { name: "with names one in other ns", linkName: "vtp", pconn: connNS, driver: &Veth{ PeerInfo: &rtnetlink.LinkMessage{ Index: ifPeerIndex, Attributes: &rtnetlink.LinkAttributes{ Name: "vte", NetNS: rtnetlink.NetNSForFD(uint32(ns)), }, }, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if err := setupInterface(conn, tt.linkName, ifIndex, 0, tt.driver); err != nil { t.Fatalf("failed to setup veth interface: %v", err) } defer conn.Link.Delete(ifIndex) _, err = getInterface(conn, ifIndex) if err != nil { t.Fatalf("failed to get primary veth interface: %v", err) } _, err = getInterface(tt.pconn, ifPeerIndex) if err != nil { t.Fatalf("failed to get peer veth interface: %v", err) } }) } } golang-github-jsimonetti-rtnetlink-2.0.2/endian.go000066400000000000000000000002601462112004500222130ustar00rootroot00000000000000package rtnetlink import ( "encoding/binary" "github.com/mdlayher/netlink/nlenc" ) var nativeEndian binary.ByteOrder func init() { nativeEndian = nlenc.NativeEndian() } golang-github-jsimonetti-rtnetlink-2.0.2/example_address_add_test.go000066400000000000000000000025251462112004500257720ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "encoding/binary" "log" "net" "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/example_address_del_test.go000066400000000000000000000024461462112004500260100ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "encoding/binary" "log" "net" "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/example_address_list_test.go000066400000000000000000000017141462112004500262140ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/example_link_list_test.go000066400000000000000000000006141462112004500255220ustar00rootroot00000000000000package rtnetlink_test import ( "log" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/example_link_setdown_test.go000066400000000000000000000015331462112004500262330ustar00rootroot00000000000000package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/example_link_sethwaddr_test.go000066400000000000000000000015501462112004500265340ustar00rootroot00000000000000package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/example_link_setup_test.go000066400000000000000000000017161462112004500257130ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/example_neigh_list_test.go000066400000000000000000000016561462112004500256660ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/example_route_add_test.go000066400000000000000000000016741462112004500255070ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/example_rule_list_test.go000066400000000000000000000006471462112004500255420ustar00rootroot00000000000000package rtnetlink_test import ( "log" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/fuzz-shell.nix000066400000000000000000000010421462112004500232500ustar00rootroot00000000000000with 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-2.0.2/fuzz_test.go000066400000000000000000000017411462112004500230170ustar00rootroot00000000000000//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-2.0.2/go.mod000066400000000000000000000006701462112004500215410ustar00rootroot00000000000000module github.com/jsimonetti/rtnetlink/v2 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.20.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.23.0 // indirect golang.org/x/sync v0.1.0 // indirect ) golang-github-jsimonetti-rtnetlink-2.0.2/go.sum000066400000000000000000000034561462112004500215730ustar00rootroot00000000000000github.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.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= 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.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang-github-jsimonetti-rtnetlink-2.0.2/internal/000077500000000000000000000000001462112004500222445ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/internal/testutils/000077500000000000000000000000001462112004500243045ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/internal/testutils/netns.go000066400000000000000000000025531462112004500257670ustar00rootroot00000000000000package testutils import ( "fmt" "os" "runtime" "testing" "github.com/jsimonetti/rtnetlink/v2/internal/unix" "golang.org/x/sync/errgroup" ) // NetNS returns a file descriptor to a new network namespace. // The netns handle is automatically closed as part of test cleanup. func NetNS(tb testing.TB) int { tb.Helper() var ns *os.File var eg errgroup.Group eg.Go(func() error { // Lock the new goroutine to its OS thread. Never unlock the goroutine so // the thread dies when the goroutine ends to avoid having to restore the // thread's netns. runtime.LockOSThread() // Move the current thread to a new network namespace. if err := unix.Unshare(unix.CLONE_NEWNET); err != nil { return fmt.Errorf("unsharing netns: %w", err) } f, err := os.OpenFile(fmt.Sprintf("/proc/%d/task/%d/ns/net", os.Getpid(), unix.Gettid()), unix.O_RDONLY|unix.O_CLOEXEC, 0) if err != nil { return fmt.Errorf("opening netns handle: %w", err) } // Store a namespace reference in the outer scope. ns = f return nil }) if err := eg.Wait(); err != nil { tb.Fatal(err) } tb.Cleanup(func() { // Maintain a reference to the namespace until the end of the test, where // the handle will close automatically and the namespace potentially // disappears if there are no other references (veth/netkit peers, ..) to it. ns.Close() }) return int(ns.Fd()) } golang-github-jsimonetti-rtnetlink-2.0.2/internal/testutils/version.go000066400000000000000000000020541462112004500263210ustar00rootroot00000000000000package testutils import ( "bytes" "fmt" "testing" "golang.org/x/sys/unix" ) func getKernelVersion(tb testing.TB) (maj, min, patch uint32) { tb.Helper() var uname unix.Utsname if err := unix.Uname(&uname); err != nil { tb.Fatalf("getting uname: %s", err) } end := bytes.IndexByte(uname.Release[:], 0) versionStr := uname.Release[:end] if count, _ := fmt.Sscanf(string(versionStr), "%d.%d.%d", &maj, &min, &patch); count < 2 { tb.Fatalf("failed to parse kernel version from %s", string(versionStr)) } return } // SkipOnOldKernel skips the test if the host's kernel is lower than the given // x.y target version. func SkipOnOldKernel(tb testing.TB, target, reason string) { maj, min, _ := getKernelVersion(tb) var maj_t, min_t, patch_t uint32 if count, _ := fmt.Sscanf(target, "%d.%d.%d", &maj_t, &min_t, &patch_t); count < 2 { tb.Fatalf("failed to parse target version from %s", target) } if maj < maj_t || maj == maj_t && min < min_t { tb.Skipf("host kernel (%d.%d) too old (minimum %d.%d): %s", maj, min, maj_t, min_t, reason) } } golang-github-jsimonetti-rtnetlink-2.0.2/internal/unix/000077500000000000000000000000001462112004500232275ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/internal/unix/types_linux.go000066400000000000000000000334011462112004500261420ustar00rootroot00000000000000//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_BOND_UNSPEC = linux.IFLA_BOND_UNSPEC IFLA_BOND_MODE = linux.IFLA_BOND_MODE IFLA_BOND_ACTIVE_SLAVE = linux.IFLA_BOND_ACTIVE_SLAVE IFLA_BOND_MIIMON = linux.IFLA_BOND_MIIMON IFLA_BOND_UPDELAY = linux.IFLA_BOND_UPDELAY IFLA_BOND_DOWNDELAY = linux.IFLA_BOND_DOWNDELAY IFLA_BOND_USE_CARRIER = linux.IFLA_BOND_USE_CARRIER IFLA_BOND_ARP_INTERVAL = linux.IFLA_BOND_ARP_INTERVAL IFLA_BOND_ARP_IP_TARGET = linux.IFLA_BOND_ARP_IP_TARGET IFLA_BOND_ARP_VALIDATE = linux.IFLA_BOND_ARP_VALIDATE IFLA_BOND_ARP_ALL_TARGETS = linux.IFLA_BOND_ARP_ALL_TARGETS IFLA_BOND_PRIMARY = linux.IFLA_BOND_PRIMARY IFLA_BOND_PRIMARY_RESELECT = linux.IFLA_BOND_PRIMARY_RESELECT IFLA_BOND_FAIL_OVER_MAC = linux.IFLA_BOND_FAIL_OVER_MAC IFLA_BOND_XMIT_HASH_POLICY = linux.IFLA_BOND_XMIT_HASH_POLICY IFLA_BOND_RESEND_IGMP = linux.IFLA_BOND_RESEND_IGMP IFLA_BOND_NUM_PEER_NOTIF = linux.IFLA_BOND_NUM_PEER_NOTIF IFLA_BOND_ALL_SLAVES_ACTIVE = linux.IFLA_BOND_ALL_SLAVES_ACTIVE IFLA_BOND_MIN_LINKS = linux.IFLA_BOND_MIN_LINKS IFLA_BOND_LP_INTERVAL = linux.IFLA_BOND_LP_INTERVAL IFLA_BOND_PACKETS_PER_SLAVE = linux.IFLA_BOND_PACKETS_PER_SLAVE IFLA_BOND_AD_LACP_RATE = linux.IFLA_BOND_AD_LACP_RATE IFLA_BOND_AD_SELECT = linux.IFLA_BOND_AD_SELECT IFLA_BOND_AD_INFO = linux.IFLA_BOND_AD_INFO IFLA_BOND_AD_ACTOR_SYS_PRIO = linux.IFLA_BOND_AD_ACTOR_SYS_PRIO IFLA_BOND_AD_USER_PORT_KEY = linux.IFLA_BOND_AD_USER_PORT_KEY IFLA_BOND_AD_ACTOR_SYSTEM = linux.IFLA_BOND_AD_ACTOR_SYSTEM IFLA_BOND_TLB_DYNAMIC_LB = linux.IFLA_BOND_TLB_DYNAMIC_LB IFLA_BOND_PEER_NOTIF_DELAY = linux.IFLA_BOND_PEER_NOTIF_DELAY IFLA_BOND_AD_LACP_ACTIVE = linux.IFLA_BOND_AD_LACP_ACTIVE IFLA_BOND_MISSED_MAX = linux.IFLA_BOND_MISSED_MAX IFLA_BOND_NS_IP6_TARGET = linux.IFLA_BOND_NS_IP6_TARGET IFLA_BOND_AD_INFO_UNSPEC = linux.IFLA_BOND_AD_INFO_UNSPEC IFLA_BOND_AD_INFO_AGGREGATOR = linux.IFLA_BOND_AD_INFO_AGGREGATOR IFLA_BOND_AD_INFO_NUM_PORTS = linux.IFLA_BOND_AD_INFO_NUM_PORTS IFLA_BOND_AD_INFO_ACTOR_KEY = linux.IFLA_BOND_AD_INFO_ACTOR_KEY IFLA_BOND_AD_INFO_PARTNER_KEY = linux.IFLA_BOND_AD_INFO_PARTNER_KEY IFLA_BOND_AD_INFO_PARTNER_MAC = linux.IFLA_BOND_AD_INFO_PARTNER_MAC IFLA_BOND_SLAVE_UNSPEC = linux.IFLA_BOND_SLAVE_UNSPEC IFLA_BOND_SLAVE_STATE = linux.IFLA_BOND_SLAVE_STATE IFLA_BOND_SLAVE_MII_STATUS = linux.IFLA_BOND_SLAVE_MII_STATUS IFLA_BOND_SLAVE_LINK_FAILURE_COUNT = linux.IFLA_BOND_SLAVE_LINK_FAILURE_COUNT IFLA_BOND_SLAVE_PERM_HWADDR = linux.IFLA_BOND_SLAVE_PERM_HWADDR IFLA_BOND_SLAVE_QUEUE_ID = linux.IFLA_BOND_SLAVE_QUEUE_ID IFLA_BOND_SLAVE_AD_AGGREGATOR_ID = linux.IFLA_BOND_SLAVE_AD_AGGREGATOR_ID IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE = linux.IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE = linux.IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE IFLA_BOND_SLAVE_PRIO = linux.IFLA_BOND_SLAVE_PRIO 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_NET_NS_PID = linux.IFLA_NET_NS_PID IFLA_NET_NS_FD = linux.IFLA_NET_NS_FD IFLA_NETKIT_UNSPEC = linux.IFLA_NETKIT_UNSPEC IFLA_NETKIT_PEER_INFO = linux.IFLA_NETKIT_PEER_INFO IFLA_NETKIT_PRIMARY = linux.IFLA_NETKIT_PRIMARY IFLA_NETKIT_POLICY = linux.IFLA_NETKIT_POLICY IFLA_NETKIT_PEER_POLICY = linux.IFLA_NETKIT_PEER_POLICY IFLA_NETKIT_MODE = linux.IFLA_NETKIT_MODE 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 NETKIT_NEXT = linux.NETKIT_NEXT NETKIT_PASS = linux.NETKIT_PASS NETKIT_DROP = linux.NETKIT_DROP NETKIT_REDIRECT = linux.NETKIT_REDIRECT NETKIT_L2 = linux.NETKIT_L2 NETKIT_L3 = linux.NETKIT_L3 CLONE_NEWNET = linux.CLONE_NEWNET O_RDONLY = linux.O_RDONLY O_CLOEXEC = linux.O_CLOEXEC ) var Gettid = linux.Gettid var Unshare = linux.Unshare golang-github-jsimonetti-rtnetlink-2.0.2/internal/unix/types_other.go000066400000000000000000000242641462112004500261330ustar00rootroot00000000000000//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_BOND_UNSPEC = 0x0 IFLA_BOND_MODE = 0x1 IFLA_BOND_ACTIVE_SLAVE = 0x2 IFLA_BOND_MIIMON = 0x3 IFLA_BOND_UPDELAY = 0x4 IFLA_BOND_DOWNDELAY = 0x5 IFLA_BOND_USE_CARRIER = 0x6 IFLA_BOND_ARP_INTERVAL = 0x7 IFLA_BOND_ARP_IP_TARGET = 0x8 IFLA_BOND_ARP_VALIDATE = 0x9 IFLA_BOND_ARP_ALL_TARGETS = 0xa IFLA_BOND_PRIMARY = 0xb IFLA_BOND_PRIMARY_RESELECT = 0xc IFLA_BOND_FAIL_OVER_MAC = 0xd IFLA_BOND_XMIT_HASH_POLICY = 0xe IFLA_BOND_RESEND_IGMP = 0xf IFLA_BOND_NUM_PEER_NOTIF = 0x10 IFLA_BOND_ALL_SLAVES_ACTIVE = 0x11 IFLA_BOND_MIN_LINKS = 0x12 IFLA_BOND_LP_INTERVAL = 0x13 IFLA_BOND_PACKETS_PER_SLAVE = 0x14 IFLA_BOND_AD_LACP_RATE = 0x15 IFLA_BOND_AD_SELECT = 0x16 IFLA_BOND_AD_INFO = 0x17 IFLA_BOND_AD_ACTOR_SYS_PRIO = 0x18 IFLA_BOND_AD_USER_PORT_KEY = 0x19 IFLA_BOND_AD_ACTOR_SYSTEM = 0x1a IFLA_BOND_TLB_DYNAMIC_LB = 0x1b IFLA_BOND_PEER_NOTIF_DELAY = 0x1c IFLA_BOND_AD_LACP_ACTIVE = 0x1d IFLA_BOND_MISSED_MAX = 0x1e IFLA_BOND_NS_IP6_TARGET = 0x1f IFLA_BOND_AD_INFO_UNSPEC = 0x0 IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 IFLA_BOND_AD_INFO_ACTOR_KEY = 0x3 IFLA_BOND_AD_INFO_PARTNER_KEY = 0x4 IFLA_BOND_AD_INFO_PARTNER_MAC = 0x5 IFLA_BOND_SLAVE_UNSPEC = 0x0 IFLA_BOND_SLAVE_STATE = 0x1 IFLA_BOND_SLAVE_MII_STATUS = 0x2 IFLA_BOND_SLAVE_LINK_FAILURE_COUNT = 0x3 IFLA_BOND_SLAVE_PERM_HWADDR = 0x4 IFLA_BOND_SLAVE_QUEUE_ID = 0x5 IFLA_BOND_SLAVE_AD_AGGREGATOR_ID = 0x6 IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE = 0x7 IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE = 0x8 IFLA_BOND_SLAVE_PRIO = 0x9 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_NET_NS_PID = 0x13 IFLA_NET_NS_FD = 0x1c IFLA_NETKIT_UNSPEC = 0x0 IFLA_NETKIT_PEER_INFO = 0x1 IFLA_NETKIT_PRIMARY = 0x2 IFLA_NETKIT_POLICY = 0x3 IFLA_NETKIT_PEER_POLICY = 0x4 IFLA_NETKIT_MODE = 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 NETKIT_NEXT = -0x1 NETKIT_PASS = 0x0 NETKIT_DROP = 0x2 NETKIT_REDIRECT = 0x7 NETKIT_L2 = 0x0 NETKIT_L3 = 0x1 CLONE_NEWNET = 0x40000000 O_RDONLY = 0x0 O_CLOEXEC = 0x80000 ) func Unshare(_ int) error { return nil } func Gettid() int { return 0 } golang-github-jsimonetti-rtnetlink-2.0.2/link.go000066400000000000000000000535371462112004500217310ustar00rootroot00000000000000package rtnetlink import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/v2/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 { if m.Attributes.Info != nil && m.Attributes.Info.Data != nil { if verifier, ok := m.Attributes.Info.Data.(LinkDriverVerifier); ok { if err := verifier.Verify(m); err != nil { return nil, err } } } 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 NetNS *NetNS // Interface network namespace } // 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 { if a.Name != "" { ae.String(unix.IFLA_IFNAME, a.Name) } if a.Type != 0 { ae.Uint32(unix.IFLA_LINK, a.Type) } if a.QueueDisc != "" { 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) } if a.NetNS != nil { ae.Uint32(a.NetNS.value()) } 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 } var ( // registeredDrivers is the global map of registered drivers registeredDrivers = make(map[string]LinkDriver) // registeredSlaveDrivers is the global map of registered slave drivers registeredSlaveDrivers = make(map[string]LinkDriver) ) // RegisterDriver registers a driver with the link service // This allows the driver to be used to encode/decode the link data // // This function is not threadsafe. This should not be used after Dial func RegisterDriver(d LinkDriver) error { if _, ok := d.(LinkSlaveDriver); ok { if _, ok := registeredSlaveDrivers[d.Kind()]; ok { return fmt.Errorf("driver %s already registered", d.Kind()) } registeredSlaveDrivers[d.Kind()] = d return nil } if _, ok := registeredDrivers[d.Kind()]; ok { return fmt.Errorf("driver %s already registered", d.Kind()) } registeredDrivers[d.Kind()] = d return nil } // getDriver returns the driver instance for the given kind, and true if the driver is registered // it returns the default (LinkData) driver, and false if the driver is not registered func getDriver(kind string, slave bool) (LinkDriver, bool) { if slave { if t, ok := registeredSlaveDrivers[kind]; ok { return t.New(), true } return &LinkData{Name: kind, Slave: true}, false } if t, ok := registeredDrivers[kind]; ok { return t.New(), true } return &LinkData{Name: kind}, false } // LinkDriver is the interface that wraps link-specific Encode, Decode, and Kind methods type LinkDriver interface { // New returns a new instance of the LinkDriver New() LinkDriver // Encode the driver data into the netlink message attribute Encode(*netlink.AttributeEncoder) error // Decode the driver data from the netlink message attribute Decode(*netlink.AttributeDecoder) error // Return the driver kind as string, this will be matched with the LinkInfo.Kind to find a driver to decode the data Kind() string } // LinkSlaveDriver defines a LinkDriver with Slave method type LinkSlaveDriver interface { LinkDriver // Slave method specifies driver is a slave link info Slave() } // LinkDriverVerifier defines a LinkDriver with Verify method type LinkDriverVerifier interface { LinkDriver // Verify function run before Encode function to check for correctness and // pass related values that otherwise unavailable to the driver Verify(*LinkMessage) error } // LinkData implements the default LinkDriver interface for not registered drivers type LinkData struct { Name string Data []byte Slave bool } var _ LinkDriver = &LinkData{} func (d *LinkData) New() LinkDriver { return &LinkData{} } func (d *LinkData) Decode(ad *netlink.AttributeDecoder) error { d.Data = ad.Bytes() return nil } func (d *LinkData) Encode(ae *netlink.AttributeEncoder) error { if len(d.Data) == 0 { return nil } if d.Slave { ae.Bytes(unix.IFLA_INFO_SLAVE_DATA, d.Data) } else { ae.Bytes(unix.IFLA_INFO_DATA, d.Data) } return nil } func (d *LinkData) Kind() string { return d.Name } // LinkInfo contains data for specific network types type LinkInfo struct { Kind string // Driver name Data LinkDriver // Driver specific configuration stored as nested Netlink messages SlaveKind string // Slave driver name SlaveData LinkDriver // 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: driver, found := getDriver(i.Kind, false) i.Data = driver if found { ad.Nested(i.Data.Decode) continue } _ = i.Data.Decode(ad) case unix.IFLA_INFO_SLAVE_DATA: driver, found := getDriver(i.SlaveKind, true) i.SlaveData = driver if found { ad.Nested(i.SlaveData.Decode) continue } _ = i.SlaveData.Decode(ad) } } return nil } func (i *LinkInfo) encode(ae *netlink.AttributeEncoder) error { ae.String(unix.IFLA_INFO_KIND, i.Kind) if i.Data != nil { if i.Kind != i.Data.Kind() { return fmt.Errorf("driver kind %s is not equal to info kind %s", i.Data.Kind(), i.Kind) } if _, ok := i.Data.(*LinkData); ok { _ = i.Data.Encode(ae) } else { ae.Nested(unix.IFLA_INFO_DATA, i.Data.Encode) } } if i.SlaveData != nil { if i.SlaveKind != i.SlaveData.Kind() { return fmt.Errorf("slave driver kind %s is not equal to slave info kind %s", i.SlaveData.Kind(), i.SlaveKind) } ae.String(unix.IFLA_INFO_SLAVE_KIND, i.SlaveKind) if _, ok := i.SlaveData.(*LinkData); ok { _ = i.SlaveData.Encode(ae) } else { ae.Nested(unix.IFLA_INFO_SLAVE_DATA, i.SlaveData.Encode) } } 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 can only be returned by the // kernel, 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-2.0.2/link_live_test.go000066400000000000000000000131241462112004500237730ustar00rootroot00000000000000//go:build integration // +build integration package rtnetlink import ( "testing" "github.com/cilium/ebpf" "github.com/cilium/ebpf/asm" "github.com/cilium/ebpf/rlimit" "github.com/jsimonetti/rtnetlink/v2/internal/testutils" "github.com/mdlayher/netlink" "golang.org/x/sys/unix" ) // lo accesses the loopback interface present in every network namespace. var lo uint32 = 1 func xdpPrograms(tb testing.TB) (int32, int32) { tb.Helper() // Load 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 { tb.Fatal(err) } prog2, err := ebpf.NewProgram(bpfProgram) if err != nil { tb.Fatal(err) } tb.Cleanup(func() { prog1.Close() prog2.Close() }) // Use the file descriptor of the programs return int32(prog1.FD()), int32(prog2.FD()) } func attachXDP(tb testing.TB, conn *Conn, ifIndex uint32, xdp *LinkXDP) { tb.Helper() message := LinkMessage{ Family: unix.AF_UNSPEC, Index: ifIndex, Attributes: &LinkAttributes{ XDP: xdp, }, } if err := conn.Link.Set(&message); err != nil { tb.Fatalf("attaching program with fd %d to link at ifindex %d: %s", xdp.FD, ifIndex, err) } } // getXDP returns the XDP attach, XDP prog ID and errors when the // interface could not be fetched func getXDP(tb testing.TB, conn *Conn, ifIndex uint32) (uint8, uint32) { tb.Helper() interf, err := conn.Link.Get(ifIndex) if err != nil { tb.Fatalf("getting link xdp properties: %s", err) } return interf.Attributes.XDP.Attached, interf.Attributes.XDP.ProgID } func TestLinkXDPAttach(t *testing.T) { if err := rlimit.RemoveMemlock(); err != nil { t.Fatal(err) } conn, err := Dial(&netlink.Config{NetNS: testutils.NetNS(t)}) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() progFD1, progFD2 := xdpPrograms(t) 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) { attachXDP(t, conn, lo, tt.xdp) attached, progID := getXDP(t, conn, lo) 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) { if err := rlimit.RemoveMemlock(); err != nil { t.Fatal(err) } conn, err := Dial(&netlink.Config{NetNS: testutils.NetNS(t)}) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() progFD1, _ := xdpPrograms(t) attachXDP(t, conn, lo, &LinkXDP{ FD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE, }) // clear the BPF program from the link attachXDP(t, conn, lo, &LinkXDP{ FD: -1, Flags: unix.XDP_FLAGS_SKB_MODE, }) attached, progID := getXDP(t, conn, lo) 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 testutils.SkipOnOldKernel(t, "5.7", "XDP_FLAGS_REPLACE") if err := rlimit.RemoveMemlock(); err != nil { t.Fatal(err) } conn, err := Dial(&netlink.Config{NetNS: testutils.NetNS(t)}) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() progFD1, progFD2 := xdpPrograms(t) attachXDP(t, conn, lo, &LinkXDP{ FD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE, }) _, progID1 := getXDP(t, conn, lo) if err := conn.Link.Set(&LinkMessage{ Family: unix.AF_UNSPEC, Index: lo, Attributes: &LinkAttributes{ XDP: &LinkXDP{ FD: progFD2, ExpectedFD: progFD2, Flags: unix.XDP_FLAGS_SKB_MODE | unix.XDP_FLAGS_REPLACE, }, }, }); err == nil { t.Fatalf("replaced XDP program while expected FD did not match: %v", err) } _, progID2 := getXDP(t, conn, lo) if progID2 != progID1 { t.Fatal("XDP prog ID does not match previous program ID, which it should") } attachXDP(t, conn, lo, &LinkXDP{ FD: progFD2, ExpectedFD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE | unix.XDP_FLAGS_REPLACE, }) _, progID2 = getXDP(t, conn, lo) if progID2 == progID1 { t.Fatal("XDP prog ID does match previous program ID, which it shouldn't") } } golang-github-jsimonetti-rtnetlink-2.0.2/link_test.go000066400000000000000000000550501462112004500227600ustar00rootroot00000000000000package 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, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 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, 0x09, 0x00, 0x03, 0x00, 0x69, 0x70, 0x69, 0x70, 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: &LinkData{Name: "data", Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}}, SlaveKind: "foo", SlaveData: &LinkData{Name: "foo", Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}, Slave: true}, }, }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 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, 0x09, 0x00, 0x03, 0x00, 0x69, 0x70, 0x69, 0x70, 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: &LinkData{Name: "data", Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}}, SlaveKind: "foo", SlaveData: &LinkData{Name: "foo", Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}, Slave: true}, }, }, }, }, } 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-2.0.2/neigh.go000066400000000000000000000114271462112004500220560ustar00rootroot00000000000000package rtnetlink import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/v2/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-2.0.2/neigh_test.go000066400000000000000000000107661462112004500231220ustar00rootroot00000000000000package rtnetlink import ( "bytes" "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/v2/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-2.0.2/netns.go000066400000000000000000000026011462112004500221050ustar00rootroot00000000000000package rtnetlink import ( "github.com/jsimonetti/rtnetlink/v2/internal/unix" ) // NetNS represents a Linux network namespace handle to specify in // [LinkAttributes]. // // Use [NetNSForPID] to create a handle to the network namespace of an existing // PID, or [NetNSForFD] for a handle to an existing network namespace created by // another library. type NetNS struct { fd *uint32 pid *uint32 } // NetNSForPID returns a handle to the network namespace of an existing process // given its pid. The process must be alive when the NetNS is used in any API // calls. // // The resulting NetNS doesn't hold a hard reference to the netns (it doesn't // increase its refcount) and becomes invalid when the process it points to // dies. func NetNSForPID(pid uint32) *NetNS { return &NetNS{pid: &pid} } // NetNSForFD returns a handle to an existing network namespace created by // another library. It does not clone fd or manage its lifecycle in any way. // The caller is responsible for making sure the underlying fd stays alive // for the duration of any API calls using the NetNS. func NetNSForFD(fd uint32) *NetNS { return &NetNS{fd: &fd} } // value returns the type and value of the NetNS for use in netlink attributes. func (ns *NetNS) value() (uint16, uint32) { if ns.fd != nil { return unix.IFLA_NET_NS_FD, *ns.fd } if ns.pid != nil { return unix.IFLA_NET_NS_PID, *ns.pid } return 0, 0 } golang-github-jsimonetti-rtnetlink-2.0.2/route.go000066400000000000000000000357071462112004500221310ustar00rootroot00000000000000package rtnetlink import ( "encoding/binary" "errors" "fmt" "net" "unsafe" "github.com/jsimonetti/rtnetlink/v2/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-2.0.2/route_test.go000066400000000000000000000233651462112004500231650ustar00rootroot00000000000000package rtnetlink import ( "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/v2/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-2.0.2/rtnl/000077500000000000000000000000001462112004500214075ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/rtnl/addr.go000066400000000000000000000112641462112004500226540ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink/v2/internal/unix" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/rtnl/addr_live_test.go000066400000000000000000000045031462112004500247300ustar00rootroot00000000000000//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-2.0.2/rtnl/addr_test.go000066400000000000000000000027531462112004500237160ustar00rootroot00000000000000package 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-2.0.2/rtnl/conn.go000066400000000000000000000014261462112004500226760ustar00rootroot00000000000000// Package rtnl provides a convenient API on top of the rtnetlink library. package rtnl import ( "github.com/jsimonetti/rtnetlink/v2" "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-2.0.2/rtnl/link.go000066400000000000000000000054731462112004500227040ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink/v2/internal/unix" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/rtnl/links_live_test.go000066400000000000000000000040141462112004500251330ustar00rootroot00000000000000//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-2.0.2/rtnl/neigh.go000066400000000000000000000027271462112004500230400ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink/v2" ) // 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 // Bitfield representing the state of the neighbor entry, // corresponding to the NUD_ constants. State uint16 } // 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 { // Received a neigh entry for a link that no longer exists, so we cannot // populate the Interface field. Skip the entry. continue } ifcache[ifindex] = iface } p := &Neigh{ HwAddr: m.Attributes.LLAddress, IP: m.Attributes.Address, Interface: iface, State: m.State, } r = append(r, p) } return r, nil } golang-github-jsimonetti-rtnetlink-2.0.2/rtnl/neigh_live_test.go000066400000000000000000000026211462112004500251070ustar00rootroot00000000000000//go:build integration // +build integration package rtnl import ( "net" "testing" "golang.org/x/sys/unix" ) 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) // Ignore neighbor entries in internal/pseudo state. if e.State == unix.NUD_NONE { continue } // Loopback and p2p interfaces can have neigh entries with a zero IP address. if e.IP.IsUnspecified() { continue } if e.Interface == nil { t.Error("nil e.Interface, expected non-nil") } if len(e.Interface.Name) == 0 { t.Error("zero-length e.Interface.Name") } // Don't (always) expect hardware address info on entries marked noarp, // as they include link-local multicast and loopback addresses that are // valid for all interfaces on the host. if e.State == unix.NUD_NOARP { continue } if hardwareAddrIsUnspecified(e.HwAddr) { 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-2.0.2/rtnl/route.go000066400000000000000000000072371462112004500231050ustar00rootroot00000000000000package rtnl import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/v2/internal/unix" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/rtnl/route_live_test.go000066400000000000000000000014271462112004500251560ustar00rootroot00000000000000//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-2.0.2/rtnl/route_options.go000066400000000000000000000016441462112004500246540ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink/v2" ) // 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-2.0.2/rule.go000066400000000000000000000213771462112004500217400ustar00rootroot00000000000000package rtnetlink import ( "bytes" "encoding/binary" "errors" "net" "github.com/jsimonetti/rtnetlink/v2/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-2.0.2/rule_test.go000066400000000000000000000131061462112004500227660ustar00rootroot00000000000000package 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-2.0.2/testdata/000077500000000000000000000000001462112004500222415ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/000077500000000000000000000000001462112004500232375ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessage/000077500000000000000000000000001462112004500270105ustar00rootroot0000000000000003197537f1d80d5ea34e9b96031694042cf03ea0-16000066400000000000000000000005011462112004500342250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000003701462112004500341650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000005311462112004500345730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000003051462112004500347460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001061462112004500350620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x14\x01\x00\x01p\x13a\x14\x02\x00\bc\xa1K߫")106930161272d1a659e4bfed0ba011dc1880d96d-15000066400000000000000000000003411462112004500343520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002001462112004500345550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002601462112004500344620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002021462112004500340750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001251462112004500344470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x04i\x00")18898d583b9037246600e4a5199febbc97ca9140-5000066400000000000000000000001251462112004500341760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ingX\x95\x00\x00\x04i\x00\x00\x10\x00\x00\x00\x04\x00")199c834a15965ba27bbe7b0aa0f57f185ab6d532-17000066400000000000000000000001771462112004500345420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001501462112004500345120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000003551462112004500344070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002121462112004500351070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001251462112004500340320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04\x00\x00\x00\u007f\x04\x00\x04\x00d")210a5ce32eb32f1d719f51a6f78ce15f8976e575-4000066400000000000000000000001661462112004500344150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001161462112004500343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("q\xf9rs\x95\x00\x80i\x00\x00\x00\x80\x00\x00\x02\x00")293caf4336ebf745aef235fc01a965a1cfcf80c1-4000066400000000000000000000000731462112004500346660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x05\x00")296b5ba71cf743803e5563189812b89f7f2f7452-14000066400000000000000000000002261462112004500342070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001331462112004500344070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x00\x00\x00\x00\x00\x80\x00\x00\x02\x00")2d9da857031d9bb79ba5732d53ed8bbc983d6d03-16000066400000000000000000000003621462112004500346320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001651462112004500345420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000661462112004500344650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st�\b@\x95\x00\x00\x06\x00")369c2bb765753d7ecc40da8382acbe04f624f6d9-12000066400000000000000000000005241462112004500346260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002101462112004500346500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001311462112004500347730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00d�")39da7860aa52bb0886e507bb9017380673ac55c2-3000066400000000000000000000001131462112004500342230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x03\x00\x01\x00\x02\xef")3a9e964d1a74ae15985b1eb93450e9caebd4fa4f-8000066400000000000000000000003141462112004500347070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000003001462112004500343040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001051462112004500343650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x00\x00\x04i\x00\x00\x10\x00\x00\x00\a\x00")3f2da580433bae37e15f9f38c6235fed72fd83b2-11000066400000000000000000000001301462112004500346140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x04\x80")3f5962d8f537c531b6c84d9a82b13f517757e1b1-1000066400000000000000000000000561462112004500342520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10�\x1f\xef\xbd")408a00980e100b54f789fe692ed9a6bc3f0bb313-6000066400000000000000000000001721462112004500343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001721462112004500346700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001621462112004500344500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001641462112004500343270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002031462112004500345770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002021462112004500346450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002741462112004500343030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000001751462112004500345540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002621462112004500344610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002351462112004500344750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000001601462112004500351270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001541462112004500340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002311462112004500344010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001061462112004500343220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x04\x84i&�\x01\x00ng\x00\x00\x04\x00\x04")4fc9ce6d1d0f22976ec833d59f6cfe62c16e1752-13000066400000000000000000000002121462112004500346340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002061462112004500335310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001511462112004500342370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000711462112004500345300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("stz\x00tln\x00\x00\x00\xe9trinJ")54749e1cacebfce8b22ff4e83b2ba0a8ed33f544-11000066400000000000000000000002021462112004500351030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002021462112004500351040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001261462112004500345650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00")58253ecb6927e96cc3a26cff858bc88485ae2760-20000066400000000000000000000001751462112004500345130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000001021462112004500341500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x14\x01\x00\x01p\x13a\x14\x01\x00\x01\a")58d90b43ebec2dc1bcb5cff722703d8941c9be88-15000066400000000000000000000002651462112004500347720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002471462112004500346570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001301462112004500342270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04\x00\x00\x00\x00\u007f\x04\x00\x04\x00")6064a9c9c050c456f4b743d67c2876d4fafc4706-12000066400000000000000000000001501462112004500344050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002611462112004500344040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001641462112004500343210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002351462112004500344360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000651462112004500345300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("str&�\x01\x00\x00\x01\x00")66eb63b0d261b8272cda52764e92513763be5897-4000066400000000000000000000001351462112004500341700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003371462112004500346460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003561462112004500340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002161462112004500340370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002321462112004500343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000000461462112004500347560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("strings\x95J")69cf73c46886c75b52c8260b1fa1d2eeaa2e082e-1000066400000000000000000000000511462112004500345300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("strings\x95Join")6e635917981e43ca2b91eb094200e13b7afeadfb-9000066400000000000000000000002661462112004500345400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002301462112004500344260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000003151462112004500346030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001701462112004500342560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001631462112004500343250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001351462112004500344650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x02\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")7599dd7e66269c08b8abce2977751628e97f956d-8000066400000000000000000000001711462112004500343270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001471462112004500343150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000007571462112004500342520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001261462112004500343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\b\x00\x00\x00\x00\u007f\x04\x00\x04\x00")79fa28ed23e1e1bd6dcf10fc9e44a2a458be655b-9000066400000000000000000000003261462112004500347640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001571462112004500344270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000001651462112004500343210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001411462112004500345120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001131462112004500344210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x04\x00\x04\xff\xf4\x04")8ded6a0cd324784a117fac305c72fca1b716c531-11000066400000000000000000000001511462112004500345650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001471462112004500345300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001271462112004500345070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00")9414975d2cec04e3e670248c84961a2fe107f271-16000066400000000000000000000003041462112004500342450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000011151462112004500344720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002531462112004500346160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000001751462112004500350260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001561462112004500352110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000006051462112004500344160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003471462112004500343400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000731462112004500347750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x04\x00")ac1ba525cc316db3b13951bdef31efab1106de05-10000066400000000000000000000003031462112004500347600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000701462112004500346720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("i\xf9ring@\x95\x00\x00\x02\x00")afd5a9ac7ec4df101699242a93ccc74ce1c74e22-14000066400000000000000000000002721462112004500347540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000005071462112004500344620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001631462112004500350650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001471462112004500346140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001741462112004500347060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002121462112004500342610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002401462112004500351450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002361462112004500347620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001051462112004500351520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x14\x01\x00\x01p\x80\x00\x00\x00\x00\b\x00")c0e4d6ec235635a92ceeaa82e7e0820ea6c63ce0-9000066400000000000000000000001331462112004500346640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\a\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")c38fccf97e8155d328da7216d41d699473c2818c-2000066400000000000000000000000651462112004500343450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("string@\x95\x00\x00\x04\x00")c5471b56b05e8cf8306af45e61c2c309786bcdc7-12000066400000000000000000000002241462112004500345400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001341462112004500350540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02�\x19\xbd")cc1d7e42dd85a7da33ae2c9cda8bada68688ecfc-14000066400000000000000000000002301462112004500353360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001641462112004500345440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001101462112004500347770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00\x00\x00\x00\u007f")cf4dbe6a7810e20d76eccb50a3538a5c12734537-12000066400000000000000000000001441462112004500345200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002201462112004500343550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000005061462112004500347660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321462112004500343740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("")de6ae9714625105f8323efd037a92833b4c92efe-10000066400000000000000000000001351462112004500344620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x05\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")de865354115e718b92af38ad958e111d2ee0c87f-5000066400000000000000000000001251462112004500344110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00")e356e0ea3b5d0d5288b27738723f7b41bfa1ec49-11000066400000000000000000000004701462112004500345360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001371462112004500346560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001471462112004500352710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001321462112004500342420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x00\x01\x00\x02\x00\a\x00\x03\x00\x01\x00\x02�\x19\xbd")ea220edfb68c47a225afc173c1bb4c19b7c3ddea-7000066400000000000000000000001511462112004500350700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003101462112004500343340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001631462112004500346420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000003001462112004500346160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002021462112004500343220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002051462112004500344650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001351462112004500353310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x04\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")f8a7aa66b4ce5729bde72f3b9230527253512edb-9000066400000000000000000000002331462112004500344600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001431462112004500345260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002021462112004500350230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2.0.2/testdata/fuzz/FuzzLinkMessage/000077500000000000000000000000001462112004500263205ustar00rootroot000000000000000219bdb2b09a3f9faa91596ebc864d8dd38ca961-8000066400000000000000000000002141462112004500341360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000004121462112004500341400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001451462112004500340450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002211462112004500340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001131462112004500335610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviPn\x01\x00a\x1c\x01\x00din\x01\x00a")0759c6b3164af44b76405abfae4091fc3a07fae4-3000066400000000000000000000001231462112004500340250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviPn\x01\x00a\x1c\x01\x00d\x00\x00\x00\u007fa")07ce7c2b77ac83fc8a6f8837c8b46039d39ec911-6000066400000000000000000000001751462112004500340210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000005441462112004500337150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000004701462112004500337550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002061462112004500337650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002171462112004500336530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002141462112004500337220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002611462112004500340000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000004021462112004500337240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001251462112004500341330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\x03\x00")0e4a40bfdaae116f201053d089af46b94e71bdb2-21000066400000000000000000000003711462112004500341520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-23000066400000000000000000000004121462112004500340050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002141462112004500342210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001611462112004500334620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002031462112004500334250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000004531462112004500343770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001371462112004500337610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsock\u007fotuLOCA\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")17201668622c629bf04df7e190c1566c9c3ce915-6000066400000000000000000000002301462112004500334700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001751462112004500337740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000001611462112004500333520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-23000066400000000000000000000010551462112004500337540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000001651462112004500341150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002061462112004500340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000003461462112004500342620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001631462112004500342060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000002721462112004500340730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-23000066400000000000000000000004111462112004500340600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000003461462112004500341430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002021462112004500340010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000003611462112004500335070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000761462112004500340560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\x10\x00AINe")316ab7d81c3813171dbb479563402863e4c75423-24000066400000000000000000000007631462112004500334120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001611462112004500337310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002331462112004500342700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000731462112004500337070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviP\x1c\x01\x00ding a")3437072a583d2a28e1f9634f9b04bdac9fcab11e-19000066400000000000000000000003141462112004500341210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002501462112004500337370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002141462112004500335070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001741462112004500342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001031462112004500340330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv")425c0a087cf2b3ddf56ecdb4b0990783a5a6552d-4000066400000000000000000000002001462112004500340300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001061462112004500340370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psets\x00\x00\x03\xe8ptuLOCA\x00\x00\x02\x00")452b49a350544c3fbdbce68364aa78a5684f9ba2-8000066400000000000000000000001601462112004500337710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001641462112004500340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002151462112004500340560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-24000066400000000000000000000007501462112004500341150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001621462112004500340000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002421462112004500342100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002061462112004500333650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000005031462112004500343570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000001631462112004500342150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002611462112004500341510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003211462112004500336650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001411462112004500337040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv\x00\x00\xef\xbf\x00\x00onsinn")4ff2a45908db4e2d97b7d4441417a6bb684e2af1-11000066400000000000000000000003261462112004500340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001261462112004500333670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\x04\x00+\x00\x04\x00+\x00")5306ee75438633ee7ca20168fdd42070dfd0b141-22000066400000000000000000000003731462112004500336750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002361462112004500337620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002451462112004500336300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001661462112004500337620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002511462112004500341470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001771462112004500335610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002471462112004500340400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002121462112004500341650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000001741462112004500336540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000007401462112004500341240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002061462112004500337320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000006621462112004500346710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001431462112004500341460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00onside")63d1acf1505de8f0e3553575c7e11c24f6c62c76-11000066400000000000000000000002141462112004500337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002511462112004500337330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000721462112004500333040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsocjoptuLO0A\x00\x00\x12\x00")6776f5d9cdc53e6296e2744780d5e847fedd5197-19000066400000000000000000000005071462112004500337730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001401462112004500336230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001031462112004500340060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x04\x00")6991c6033fb228a00f86b7a1e3c3a0b360f53b42-5000066400000000000000000000001661462112004500336040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000005071462112004500343730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002131462112004500336260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000005071462112004500341500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001721462112004500336450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000005241462112004500342640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001001462112004500343370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x05@")7247b935debe7850c2d2622eb00e73641aa1fd5f-15000066400000000000000000000001631462112004500340370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000003161462112004500337740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000006011462112004500343410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000002731462112004500334550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001501462112004500334410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder*\x00roviP\x1c\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne\x00\x02\x00\x01")77ebc6dfe60a8afbf375bd51b6704345c1554ae8-7000066400000000000000000000001531462112004500341330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002201462112004500337460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002161462112004500335170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002201462112004500337530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001711462112004500343530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001751462112004500343070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000003321462112004500341200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002011462112004500340450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000004161462112004500335030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000005621462112004500335750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001251462112004500337050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder\x04\x00roviP\x1c\x04\x00ro\x04\x00dr\x04\x00rviINe")8305b64af2834c1b7c4051ec45ac7c2d1217f5d5-8000066400000000000000000000002121462112004500336650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002061462112004500334740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003261462112004500340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001001462112004500336230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x06@")86cc29afd692641aa72f396c58f4b9aec024dda8-16000066400000000000000000000003151462112004500342240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000004521462112004500342760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002561462112004500350010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000003111462112004500334770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002721462112004500337630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000004331462112004500335750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001771462112004500337670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002121462112004500344100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002611462112004500335740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001711462112004500340140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002061462112004500336340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002041462112004500336420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000003001462112004500341560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002721462112004500341700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000002551462112004500343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002561462112004500342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000000761462112004500343760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\a@")98dad742ea4c50812abf718229f7872c72bfaab7-14000066400000000000000000000002771462112004500341420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001771462112004500342340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000000551462112004500342740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("�����\xef")a033affdb373b9ab3d82f1096d3f20af2bbe6b5a-10000066400000000000000000000002671462112004500344010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-25000066400000000000000000000004141462112004500344330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002641462112004500341450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001771462112004500337570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000761462112004500334610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00A")a33e1e6e6c09ac729b1e3b28f7ca0482f973d7dc-11000066400000000000000000000002141462112004500342050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002071462112004500334640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001711462112004500342130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002711462112004500336470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000004161462112004500340020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001231462112004500341260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i��\uf83d�\xef\xbf\x00\x00\x00\x06\x00\x00\x00\x06@")ab34d1d80a9aa624eea04c6195cd74014dded7b2-13000066400000000000000000000001571462112004500342440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001131462112004500341030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider\x04\x00roviP\x1c\x01\x00dr\x04\x00rvinng")ae0e5309602c0edee9bb0e634c56cb3fb79de8a9-12000066400000000000000000000002521462112004500343440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001621462112004500337660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000000751462112004500346260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psets\xea@koptuLOCA\x00\x00\x17\x00")b21c12a59c0bb040d6a2ab6ef844cf0516ec948b-12000066400000000000000000000001751462112004500341600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001511462112004500340600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001401462112004500340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x05\x00\x03\x00\x01")b610ef56bd1e506c017cd3c819a75b37c2592379-12000066400000000000000000000001321462112004500337000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00rovi\x9c\x1c\x04\x00dr\x04\x00rv\x04\x00+\x00\x04\x00\n\x00")ba55bdd23c5adb52a8239b8700023c232f15f543-2000066400000000000000000000000721462112004500336500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\x12\x00")baeb8a6d92561f4ef53c0061d2f537f8ee15248f-3000066400000000000000000000001451462112004500340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv\x00\x00\xef\xbf\x00\x00onsinn")bb1fe7f04a744798a57d6a3875a6ae58b3243aa2-10000066400000000000000000000001611462112004500340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000003031462112004500341130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000001561462112004500342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003071462112004500343150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-26000066400000000000000000000004101462112004500341300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001001462112004500337650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x01@")be152934e82d85f71034c7c352f9942aa2bb1de3-1000066400000000000000000000000531462112004500336750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("stackCalAlrgsSize")be39e0bfbd0fb27740f4fbf3e865b0605c76f938-6000066400000000000000000000002061462112004500341400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001041462112004500337700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("����\xbd\xef\xbf\x00\x00\x00��")c0636f5f20d990c0e8402bd2b8592083d0b90f6e-9000066400000000000000000000002341462112004500336260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000005031462112004500341610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001731462112004500337220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002231462112004500342670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-27000066400000000000000000000004211462112004500345240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002021462112004500340010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000004371462112004500336160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000001621462112004500341220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000002471462112004500337760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-25000066400000000000000000000004101462112004500341520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000006041462112004500340610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001641462112004500336510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001741462112004500337630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000003721462112004500341730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000004411462112004500340710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002211462112004500340000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000003031462112004500341300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003661462112004500337750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000004371462112004500335310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003341462112004500346560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-24000066400000000000000000000004101462112004500343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001121462112004500341710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\x00\x00\x00\x00\x00\x00")da3215ffdb175978f8fdb4c847d8bf3bf1aaff40-7000066400000000000000000000001601462112004500343610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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@")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321462112004500337040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("")da98eb8ea0786a1fe2a3bf2bcb452050ba30d3c4-9000066400000000000000000000001741462112004500342430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001551462112004500336720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000641462112004500337500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("������\xef\xbf")dea9aa47d14c15d4170619a67a2dc29b31477fb5-16000066400000000000000000000002111462112004500340330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001301462112004500337440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder*\x00roviP\x1c\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")e0bb6419c95c74972e3f9ff71092b2f4e0861c11-4000066400000000000000000000001221462112004500336320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00A")e1df9169d06a4d3c627bc973d40c4d8561a31734-24000066400000000000000000000004111462112004500337050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001611462112004500340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002061462112004500344610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002411462112004500342050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001541462112004500340410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002521462112004500341730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002201462112004500334270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001741462112004500335540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001131462112004500337520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider\x04\x00roviP\x1c\x04\x00dr\x04\x00rviINe")ec7661f3c4f791e5001f147deca8ebd5075e2e1c-25000066400000000000000000000004231462112004500342070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001511462112004500342720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002041462112004500344250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001031462112004500340150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1cU\x00dr\x04\x00+\x00")f041df0fecb3960fb66df204131b4a4b61bff653-1000066400000000000000000000001031462112004500340730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x01\x03")f117c5cd27dcd9566d86d274e3e04357a0a37442-12000066400000000000000000000001661462112004500337130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001341462112004500337620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x86\x00\x01\x00\x02si \x06A\x00\x00\x12\x00\x05\x00\x03\x00\x00")f1e6d5ecbcd0ddf1f9b089882a8fff811b92de80-18000066400000000000000000000003461462112004500344560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000000701462112004500337700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\n\x00")f2735f718d81afa836a0209e8e898debcd27fbdd-20000066400000000000000000000003541462112004500343110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000001241462112004500344650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider prr\x04\x00rv\x14\x00+\x00\b\x00\x04\x00\x04\x00\xc6r")f43afd8e9ab998563347365720c0326585f8b733-15000066400000000000000000000004551462112004500335250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000004301462112004500343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002141462112004500340610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001531462112004500335400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001541462112004500341620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-24000066400000000000000000000007171462112004500342140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002201462112004500345230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000003261462112004500341270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000000761462112004500341700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviZ\x1c\x00\x00\x00@ng a")fd1e3cf101ab3cb4b776d21fd197a50a6aba823c-10000066400000000000000000000002741462112004500343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001651462112004500336440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001661462112004500343510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003151462112004500337240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2.0.2/testdata/fuzz/FuzzNeighMessage/000077500000000000000000000000001462112004500264555ustar00rootroot0000000000000001a78ee57b268fa9b97b6dc1a5fdfaca2557a16d-5000066400000000000000000000002321462112004500344240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001521462112004500340360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001401462112004500340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f\xbf\xbd\u2ffdH\x00\x02\x00\x00\xef\x00\x00\x00d\xbf")1a812995716a31b14ab967c690456c87fbdc68b2-4000066400000000000000000000002211462112004500337070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002241462112004500341300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000751462112004500342450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f\xefjgt\xef3\x03|")24e0485bfa0f89fc0142e2ba2c17becc3c75a515-6000066400000000000000000000002271462112004500342420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001141462112004500345570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("answerscii:]\n\x00\x02\x00\x00\x00\x03\x00\x01\x00")2f7b9224da4bcdd2a26ce5207ff5e480bcbfab40-2000066400000000000000000000001561462112004500344600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001371462112004500337210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd96H@\xa9i\xae\xef\x00\x00\xef\xbf\x00\x00\xff\xec\x00\x00\x00expec")42e474056ab4b03af2d5200be9dc3dc4513008f3-7000066400000000000000000000003101462112004500340020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001641462112004500342540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001731462112004500342630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000002121462112004500346060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001501462112004500336120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001141462112004500340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd9\x1eH��H\xef\x00\x01\x00\x00\xbf?\x97\x94`")52347ae850afae853d5b4d72e5da7040b7f50181-5000066400000000000000000000001701462112004500340310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001721462112004500337570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002441462112004500342020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002651462112004500342200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001371462112004500341270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��\xbf\xbd�H\xef\x00\x00\x00d")64da8c7da7aec5d4a4b03547898f79baa5edf893-1000066400000000000000000000000661462112004500343700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd9\x1eH��H�/\xef\xbf")66687e03c6ec2b531ad64624844b04d61de7412a-8000066400000000000000000000003561462112004500337040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000471462112004500340600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("SOAResource.N")6bb2583db7f524df91f331bd63b62740109b272d-3000066400000000000000000000001521462112004500337500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001621462112004500343550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001621462112004500345530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002071462112004500335420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001321462112004500342640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00")88a063c42663cf9c45a934d2ea1ecf5390dfd84f-6000066400000000000000000000001441462112004500342170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002121462112004500335130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001521462112004500337630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000003321462112004500337510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001721462112004500336360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002251462112004500340130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000003061462112004500335110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001271462112004500337560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd9\x1eH��H\xef\x00\x01\x009\t\x01\x00\x01\x00?\x97\x94`")a717c3df94896d0a034cb1f3b20f41d9720e162e-7000066400000000000000000000002471462112004500340360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001301462112004500342220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\b\x00")aaeb533b0644c19230ffa9b731755b5dc2ce971c-4000066400000000000000000000002141462112004500341640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000003231462112004500340370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002101462112004500340330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001441462112004500341660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000003361462112004500343550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001701462112004500340270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001641462112004500345030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002071462112004500336710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321462112004500340410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("")db7f12473f720e27f02ceeda83a2fda358c48707-3000066400000000000000000000001321462112004500341750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00\x00\x00\x01\x00")dcf4f2a666e8a75e4325cc3b88367ec37b97df57-6000066400000000000000000000001441462112004500342400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001511462112004500342440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001601462112004500335720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001521462112004500340550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002101462112004500343250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000003161462112004500343530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002501462112004500337500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000003611462112004500341260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001721462112004500342760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003321462112004500337350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000005101462112004500337710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001501462112004500341310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��6��w\x1b�\x04\x00\xbd�\xbf\xbd")fdd884cbbcebe95c699c81fa8ddb609cf810a6be-2000066400000000000000000000001151462112004500346610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f\xbf\xbd�H\xef\x00\x00\x00d\xbf")fe97cac1cacfc563b58423f0e06ee4ee46ed1338-1000066400000000000000000000001321462112004500344160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2.0.2/testdata/fuzz/FuzzRouteMessage/000077500000000000000000000000001462112004500265215ustar00rootroot0000000000000003d7df28102a6fe318669d3f6d04bad62eb97b83-7000066400000000000000000000003441462112004500341770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003231462112004500344650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003171462112004500337230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001611462112004500347570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002721462112004500344070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002161462112004500342270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001701462112004500340100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000003131462112004500337570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002341462112004500344710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001241462112004500341050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01N\x00\x00\x01\x00\x02\xe2\x01\x01\x00\x00\x0f\x00")0a734b09bdba7d2bd50ece42bbeb72c51bc4a7d6-16000066400000000000000000000003201462112004500346510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002321462112004500340140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000010641462112004500343300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003251462112004500345630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000003361462112004500345360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000005361462112004500336060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000003561462112004500340550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001571462112004500344610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000004461462112004500341130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000551462112004500342420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("Q��Ӯ��\xef")1406e50fddac3f912bf88bf66527e9d93dcd2813-15000066400000000000000000000002761462112004500343510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001641462112004500337230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000001011462112004500341070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x16\x02\xf7\x91Iw\xd5B\x9c\x97\xad\xec")16fe11a68ae650350409ddf6a6f7ba3d0175f646-3000066400000000000000000000001671462112004500341060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000004521462112004500342510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002051462112004500345330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002061462112004500335700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000010501462112004500345150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002561462112004500344000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002731462112004500341600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000003551462112004500343140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003221462112004500342670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002541462112004500334450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002021462112004500342440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000002311462112004500344440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002611462112004500340710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002251462112004500337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000002571462112004500336250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001021462112004500341570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("QQ\xef\xbf��\x00\x01\x00\x00\xbd\xef")247381ad62228d98975f619602d70df7a7ac8221-6000066400000000000000000000002321462112004500336230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001451462112004500337750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000004661462112004500340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001501462112004500340310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002301462112004500342470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000004561462112004500341430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001441462112004500341100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000004241462112004500342440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001571462112004500340700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002741462112004500341710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000003421462112004500342220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000004101462112004500333360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001301462112004500336450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x14\x00")31ec62b95c0502267680be0699244088ffcba8da-15000066400000000000000000000001561462112004500341140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002531462112004500340460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002241462112004500342500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003201462112004500340100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002021462112004500344050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001431462112004500344660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000010441462112004500345470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001661462112004500340400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000001561462112004500340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000004051462112004500334720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002171462112004500343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002371462112004500345440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002121462112004500345320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002701462112004500342760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000003341462112004500340030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002021462112004500341150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002021462112004500343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002241462112004500343360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-23000066400000000000000000000003511462112004500344270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002271462112004500341750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003251462112004500342130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001651462112004500343200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000004531462112004500342040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000000471462112004500343060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte(".in-addr.arpa")4e3424e8ef7167660ae3637af831646ded7a5c41-16000066400000000000000000000011221462112004500341210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000003641462112004500343010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000010461462112004500341100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000003131462112004500341350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-24000066400000000000000000000005761462112004500340730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001771462112004500332560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001411462112004500340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000004041462112004500336760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002561462112004500344200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001301462112004500340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x10\x00")55fbbc10b9a6d51ad9c3b3998a0e8f183f27a611-11000066400000000000000000000001671462112004500343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002161462112004500342000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001741462112004500342720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001511462112004500343270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000001551462112004500340100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002521462112004500343660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003551462112004500342130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001441462112004500345020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000003371462112004500343020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000003261462112004500343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002441462112004500341010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002301462112004500340220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002241462112004500340550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002441462112004500343430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001451462112004500345450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000003001462112004500344560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002641462112004500342620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000004571462112004500344310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003221462112004500344630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002301462112004500343550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001521462112004500340270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000010641462112004500340450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002221462112004500336070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003561462112004500341230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000002101462112004500333770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002501462112004500343340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000003061462112004500341130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000003561462112004500345650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001741462112004500340510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002361462112004500344210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000005341462112004500337060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001721462112004500342160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000011541462112004500344160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001301462112004500343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\x00")730909f7faabc356fef9a6e1fbc6d097ebb72866-10000066400000000000000000000001621462112004500345070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002451462112004500335100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001061462112004500343010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("QQ\xef\xbf��\x00\x01\x00\x00\xbd\xef\xbf")7624d5644f8d598be71db90da98f9b1aec334017-16000066400000000000000000000002371462112004500342150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002361462112004500335370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000005701462112004500340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003251462112004500342500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000003041462112004500343240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002321462112004500343210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000003251462112004500347640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000002351462112004500335570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000002101462112004500344310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001431462112004500337650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002761462112004500337310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000004061462112004500344130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002171462112004500344310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000003761462112004500342720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000007231462112004500342570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002321462112004500336230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001261462112004500340060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x16\x02\xb7pM\xf7\x91Iw\xd5B\x9c\x00\x00\x04\x00\n\x83\xecr")88c21b92716b23c468e6525f1cd674066ab45b8e-11000066400000000000000000000005071462112004500340370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003301462112004500341360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001641462112004500340640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000003531462112004500344210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001601462112004500342220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001571462112004500343170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000005651462112004500345420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002141462112004500337340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000007361462112004500342670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002451462112004500346430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002561462112004500341650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002351462112004500343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001411462112004500337630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002111462112004500335450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002741462112004500337770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002771462112004500337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002201462112004500344100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001651462112004500346450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001421462112004500340070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001671462112004500343440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001621462112004500341610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001271462112004500341740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x01\x00")a214492685193abeb385ca08853a0f9d33c0f7da-11000066400000000000000000000002001462112004500341470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-23000066400000000000000000000006361462112004500335770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000005121462112004500344170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002401462112004500344030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000004111462112004500343240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001411462112004500340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000003141462112004500342540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003601462112004500345160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000003471462112004500342630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000001541462112004500343610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000004021462112004500346350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001571462112004500345340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001421462112004500340340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002261462112004500337370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001301462112004500337630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x01\x00\x00\a\x00")b6ae5354dbce8d6786865557e35d119b1c178f45-13000066400000000000000000000005121462112004500341340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003221462112004500346220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-1000066400000000000000000000001301462112004500343310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00")ba7ab05882998ae0b3126207e40ee9112d823894-14000066400000000000000000000003131462112004500337440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000003041462112004500337440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001321462112004500345040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002351462112004500341750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001271462112004500345650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\xf5\x00\x00\x00\x00\x06\x00")c188e7f2ac1e4f6e4f94a9447ac4bc88a6971b75-14000066400000000000000000000007661462112004500343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001451462112004500340600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-20000066400000000000000000000004051462112004500337470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-22000066400000000000000000000005531462112004500343410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002131462112004500341260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002231462112004500343540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000002211462112004500345260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-21000066400000000000000000000004071462112004500340740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002221462112004500342450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001651462112004500344650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000005771462112004500342420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000002271462112004500340440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000003041462112004500342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002151462112004500345140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001511462112004500340310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002511462112004500340210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002731462112004500343700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001631462112004500342610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001431462112004500340330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002531462112004500340320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001451462112004500345310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321462112004500341050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("")dacf068bc8da64ef8dbe293b3c7c3b78de9bde9b-19000066400000000000000000000003111462112004500350700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002071462112004500341210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001741462112004500340720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000005461462112004500337450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001321462112004500340730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\xe9\x00\x03\xff\u007f\x00\x00\x00\x05\x00")e1e646858e9c91689c67bed1821e3c97a3c69e34-16000066400000000000000000000006201462112004500341540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000001571462112004500342370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000002441462112004500340510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000003121462112004500341460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002101462112004500343450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000002341462112004500340540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000004711462112004500345260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-18000066400000000000000000000002301462112004500342760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002551462112004500345060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001131462112004500342060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x16\x02\xb7pM\xf7\x91Iw\xd5B\x9c\x00\x00\x17\x00")ea3ca7a64e9606f7837564fcc8dc3a5ed0f8ad58-19000066400000000000000000000005051462112004500345170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000004701462112004500344430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000003471462112004500340270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-23000066400000000000000000000005761462112004500343670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000001551462112004500344720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001261462112004500341540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\b\x00")f198116049b36107436b1a1ebdf3b47a14f08a33-14000066400000000000000000000002401462112004500340000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001621462112004500343160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001701462112004500340120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000001611462112004500345100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001431462112004500337220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-17000066400000000000000000000003561462112004500341000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002411462112004500341000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001441462112004500343300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000002241462112004500342640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002261462112004500344300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001341462112004500341620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000002301462112004500342670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2.0.2/testdata/fuzz/FuzzRuleMessage/000077500000000000000000000000001462112004500263325ustar00rootroot000000000000000000425fd0ae670913e4b35005b123eff1cd12de-12000066400000000000000000000003261462112004500337300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003021462112004500335140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003501462112004500336500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-16000066400000000000000000000005761462112004500341020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000001511462112004500335260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-15000066400000000000000000000005741462112004500334730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001211462112004500341550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdN@\x14n\x00\x00\x01\x10\b\x00\v\x00\x00\x00lo")090afa4e752a08a629b85ea7a7cb5397812f2c7e-10000066400000000000000000000004621462112004500340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000003041462112004500340710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002141462112004500342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-10000066400000000000000000000002141462112004500344230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001651462112004500342010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-5000066400000000000000000000001441462112004500341000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002501462112004500337010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000003521462112004500344320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000002451462112004500344460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001271462112004500334120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80siNy \u007f\xff\x00\x01\x00\a\x00\x03\x80\x00\x00\x00")13c7ab77dac6860b7f8c9933e4ce9cecd005ea03-7000066400000000000000000000002421462112004500342230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003261462112004500336140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003351462112004500341760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001411462112004500342220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000001651462112004500342030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000000551462112004500333110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("m\x00\x80sing closi")1ad939af11cdccc2605f57d7a7bc3f6f0191e825-4000066400000000000000000000001041462112004500341300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9\xc8�\b&\x9a\xf3\xb9\x04\x00\v\x00")1b23bc33ed5907dc9d4a0102a2176f0c7bf7f2c3-14000066400000000000000000000004671462112004500341210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000004201462112004500342550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000002551462112004500343150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000005421462112004500342350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000005011462112004500342000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001711462112004500340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-13000066400000000000000000000011131462112004500345360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001121462112004500341140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80siNg n\x00\x00\x01\x00\x00\x00\t\x00Eg H")217df99e149bee7c1f99daf08ba961d4230bc726-10000066400000000000000000000003121462112004500341460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-12000066400000000000000000000003671462112004500340560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001661462112004500337660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000001621462112004500340670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000002171462112004500341020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-4000066400000000000000000000002011462112004500336460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-19000066400000000000000000000006771462112004500337010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002031462112004500335770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000001341462112004500335520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\x0f\x00\x00\x00vo")26e5ec2bdfa23b5802a3b0a72185863aa40440ad-12000066400000000000000000000003621462112004500340170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002201462112004500341070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002031462112004500335620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000001421462112004500334770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002601462112004500337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-11000066400000000000000000000002241462112004500342020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-7000066400000000000000000000002311462112004500343730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-14000066400000000000000000000002171462112004500333360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-6000066400000000000000000000002261462112004500336320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-3000066400000000000000000000001141462112004500336560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdNg n\x00\x00\x01\x00\x00\x00\x05\x00 Hlo")31837001a46016647184b6700562a269c7d874be-7000066400000000000000000000001141462112004500331720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("N\x80sd\x00@\x14n \x01\xf5\a\x00\x18\x00\x00\x00d")32f6c5e2b7d7a336e1f7c9e5bd88fc93b10b3eee-5000066400000000000000000000001741462112004500343150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-8000066400000000000000000000001721462112004500332420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-9000066400000000000000000000001641462112004500342070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/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-2000066400000000000000000000001221462112004500336730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-2.0.2/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\xef\x9e\x00-�dnsm\x00\x10\x00\x01