Bump all vendoring (#1612)

Update all vendoring to current releases.

Signed-off-by: Ben Kochie <superq@gmail.com>

vendor/github.com/mdlayher/netlink/CHANGELOG.md

@@ -0,0 +1,22 @@
+# CHANGELOG
+
+## Unreleased
+
+- n/a
+
+## v1.1.0
+
+- [New API] [#157](https://github.com/mdlayher/netlink/pull/157): the
+  `netlink.AttributeDecoder.TypeFlags` method enables retrieval of the type bits
+  stored in a netlink attribute's type field, because the existing `Type` method
+  masks away these bits. Thanks @ti-mo!
+- [Performance] [#157](https://github.com/mdlayher/netlink/pull/157): `netlink.AttributeDecoder`
+  now decodes netlink attributes on demand, enabling callers who only need a
+  limited number of attributes to exit early from decoding loops. Thanks @ti-mo!
+- [Improvement] [#161](https://github.com/mdlayher/netlink/pull/161): `netlink.Conn`
+  system calls are now ready for Go 1.14+'s changes to goroutine preemption.
+  See the PR for details.
+
+## v1.0.0
+
+- Initial stable commit.

vendor/github.com/mdlayher/netlink/README.md

@@ -12,16 +12,18 @@ channel!
 
 ## Stability
 
-At this time, package `netlink` is in a pre-v1.0.0 state. Changes are being made
-which may impact the exported API of this package and others in its ecosystem.
-To follow along on the status of a v1.0.0 release, [see the associated issue](https://github.com/mdlayher/netlink/issues/123).
+See the [CHANGELOG](./CHANGELOG.md) file for a description of changes between
+releases.
+
+This package has a stable v1 API and any future breaking changes will prompt
+the release of a new major version. Features and bug fixes will continue to
+occur in the v1.x.x series.
 
 The general policy of this package is to only support the latest, stable version
 of Go. Compatibility shims may be added for prior versions of Go on an as-needed
 basis. If you would like to raise a concern, please [file an issue](https://github.com/mdlayher/netlink/issues/new).
 
-**If you depend on this package in your applications, please vendor it or use Go
-modules when building your application.**
+**If you depend on this package in your applications, please use Go modules.**
 
 ## Design
 

vendor/github.com/mdlayher/netlink/attribute.go

@@ -17,7 +17,9 @@ type Attribute struct {
 	// Length of an Attribute, including this field and Type.
 	Length uint16
 
-	// The type of this Attribute, typically matched to a constant.
+	// The type of this Attribute, typically matched to a constant. Note that
+	// flags such as Nested and NetByteOrder must be handled manually when
+	// working with Attribute structures directly.
 	Type uint16
 
 	// An arbitrary payload which is specified by Type.
@@ -70,6 +72,9 @@ func (a *Attribute) unmarshal(b []byte) error {
 // MarshalAttributes packs a slice of Attributes into a single byte slice.
 // In most cases, the Length field of each Attribute should be set to 0, so it
 // can be calculated and populated automatically for each Attribute.
+//
+// It is recommend to use the AttributeEncoder type where possible instead of
+// calling MarshalAttributes and using package nlenc functions directly.
 func MarshalAttributes(attrs []Attribute) ([]byte, error) {
 	// Count how many bytes we should allocate to store each attribute's contents.
 	var c int
@@ -102,26 +107,26 @@ func MarshalAttributes(attrs []Attribute) ([]byte, error) {
 // It is recommend to use the AttributeDecoder type where possible instead of calling
 // UnmarshalAttributes and using package nlenc functions directly.
 func UnmarshalAttributes(b []byte) ([]Attribute, error) {
-	var attrs []Attribute
-	var i int
-	for {
-		if i > len(b) || len(b[i:]) == 0 {
-			break
+	ad, err := NewAttributeDecoder(b)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return a nil slice when there are no attributes to decode.
+	if ad.Len() == 0 {
+		return nil, nil
+	}
+
+	attrs := make([]Attribute, 0, ad.Len())
+
+	for ad.Next() {
+		if ad.attr().Length != 0 {
+			attrs = append(attrs, ad.attr())
 		}
+	}
 
-		var a Attribute
-		if err := (&a).unmarshal(b[i:]); err != nil {
-			return nil, err
-		}
-
-		if a.Length == 0 {
-			i += nlaHeaderLen
-			continue
-		}
-
-		i += nlaAlign(int(a.Length))
-
-		attrs = append(attrs, a)
+	if err := ad.Err(); err != nil {
+		return nil, err
 	}
 
 	return attrs, nil
@@ -143,10 +148,14 @@ type AttributeDecoder struct {
 	// If not set, the native byte order will be used.
 	ByteOrder binary.ByteOrder
 
-	// The attributes being worked on, and the iterator index into the slice of
-	// attributes.
-	attrs []Attribute
-	i     int
+	// The current attribute being worked on.
+	a Attribute
+
+	// The slice of input bytes and its iterator index.
+	b []byte
+	i int
+
+	length int
 
 	// Any error encountered while decoding attributes.
 	err error
@@ -155,17 +164,20 @@ type AttributeDecoder struct {
 // NewAttributeDecoder creates an AttributeDecoder that unpacks Attributes
 // from b and prepares the decoder for iteration.
 func NewAttributeDecoder(b []byte) (*AttributeDecoder, error) {
-	attrs, err := UnmarshalAttributes(b)
+	ad := &AttributeDecoder{
+		// By default, use native byte order.
+		ByteOrder: nlenc.NativeEndian(),
+
+		b: b,
+	}
+
+	var err error
+	ad.length, err = ad.available()
 	if err != nil {
 		return nil, err
 	}
 
-	return &AttributeDecoder{
-		// By default, use native byte order.
-		ByteOrder: nlenc.NativeEndian(),
-
-		attrs: attrs,
-	}, nil
+	return ad, nil
 }
 
 // Next advances the decoder to the next netlink attribute.  It returns false
@@ -176,26 +188,92 @@ func (ad *AttributeDecoder) Next() bool {
 		return false
 	}
 
-	ad.i++
+	// Exit if array pointer is at or beyond the end of the slice.
+	if ad.i >= len(ad.b) {
+		return false
+	}
 
-	// More attributes?
-	return len(ad.attrs) >= ad.i
+	if err := ad.a.unmarshal(ad.b[ad.i:]); err != nil {
+		ad.err = err
+		return false
+	}
+
+	// Advance the pointer by at least one header's length.
+	if int(ad.a.Length) < nlaHeaderLen {
+		ad.i += nlaHeaderLen
+	} else {
+		ad.i += nlaAlign(int(ad.a.Length))
+	}
+
+	return true
 }
 
 // Type returns the Attribute.Type field of the current netlink attribute
 // pointed to by the decoder.
+//
+// Type masks off the high bits of the netlink attribute type which may contain
+// the Nested and NetByteOrder flags. These can be obtained by calling TypeFlags.
 func (ad *AttributeDecoder) Type() uint16 {
-	return ad.attr().Type
+	// Mask off any flags stored in the high bits.
+	return ad.a.Type & attrTypeMask
+}
+
+// TypeFlags returns the two high bits of the Attribute.Type field of the current
+// netlink attribute pointed to by the decoder.
+//
+// These bits of the netlink attribute type are used for the Nested and NetByteOrder
+// flags, available as the Nested and NetByteOrder constants in this package.
+func (ad *AttributeDecoder) TypeFlags() uint16 {
+	return ad.a.Type & ^attrTypeMask
+}
+
+// Len returns the number of netlink attributes pointed to by the decoder.
+func (ad *AttributeDecoder) Len() int { return ad.length }
+
+// count scans the input slice to count the number of netlink attributes
+// that could be decoded by Next().
+func (ad *AttributeDecoder) available() (int, error) {
+	var i, count int
+	for {
+
+		// No more data to read.
+		if i >= len(ad.b) {
+			break
+		}
+
+		// Make sure there's at least a header's worth
+		// of data to read on each iteration.
+		if len(ad.b[i:]) < nlaHeaderLen {
+			return 0, errInvalidAttribute
+		}
+
+		// Extract the length of the attribute.
+		l := int(nlenc.Uint16(ad.b[i : i+2]))
+
+		// Ignore zero-length attributes.
+		if l != 0 {
+			count++
+		}
+
+		// Advance by at least a header's worth of bytes.
+		if l < nlaHeaderLen {
+			l = nlaHeaderLen
+		}
+
+		i += nlaAlign(l)
+	}
+
+	return count, nil
 }
 
 // attr returns the current Attribute pointed to by the decoder.
 func (ad *AttributeDecoder) attr() Attribute {
-	return ad.attrs[ad.i-1]
+	return ad.a
 }
 
 // data returns the Data field of the current Attribute pointed to by the decoder.
 func (ad *AttributeDecoder) data() []byte {
-	return ad.attr().Data
+	return ad.a.Data
 }
 
 // Err returns the first error encountered by the decoder.
@@ -280,6 +358,21 @@ func (ad *AttributeDecoder) Uint64() uint64 {
 	return ad.ByteOrder.Uint64(b)
 }
 
+// Flag returns a boolean representing the Attribute.
+func (ad *AttributeDecoder) Flag() bool {
+	if ad.err != nil {
+		return false
+	}
+
+	b := ad.data()
+	if len(b) != 0 {
+		ad.err = fmt.Errorf("netlink: attribute %d is not a flag; length: %d", ad.Type(), len(b))
+		return false
+	}
+
+	return true
+}
+
 // Do is a general purpose function which allows access to the current data
 // pointed to by the AttributeDecoder.
 //
@@ -301,6 +394,29 @@ func (ad *AttributeDecoder) Do(fn func(b []byte) error) {
 	}
 }
 
+// Nested decodes data into a nested AttributeDecoder to handle nested netlink
+// attributes. When calling Nested, the Err method does not need to be called on
+// the nested AttributeDecoder.
+//
+// The nested AttributeDecoder nad inherits the same ByteOrder setting as the
+// top-level AttributeDecoder ad.
+func (ad *AttributeDecoder) Nested(fn func(nad *AttributeDecoder) error) {
+	// Because we are wrapping Do, there is no need to check ad.err immediately.
+	ad.Do(func(b []byte) error {
+		nad, err := NewAttributeDecoder(b)
+		if err != nil {
+			return err
+		}
+		nad.ByteOrder = ad.ByteOrder
+
+		if err := fn(nad); err != nil {
+			return err
+		}
+
+		return nad.Err()
+	})
+}
+
 // An AttributeEncoder provides a safe way to encode attributes.
 //
 // It is recommended to use an AttributeEncoder where possible instead of
@@ -384,6 +500,17 @@ func (ae *AttributeEncoder) Uint64(typ uint16, v uint64) {
 	})
 }
 
+// Flag encodes a flag into an Attribute specidied by typ.
+func (ae *AttributeEncoder) Flag(typ uint16, v bool) {
+	// Only set flag on no previous error or v == true.
+	if ae.err != nil || !v {
+		return
+	}
+
+	// Flags have no length or data fields.
+	ae.attrs = append(ae.attrs, Attribute{Type: typ})
+}
+
 // String encodes string s as a null-terminated string into an Attribute
 // specified by typ.
 func (ae *AttributeEncoder) String(typ uint16, s string) {
@@ -432,6 +559,26 @@ func (ae *AttributeEncoder) Do(typ uint16, fn func() ([]byte, error)) {
 	})
 }
 
+// Nested embeds data produced by a nested AttributeEncoder and flags that data
+// with the Nested flag. When calling Nested, the Encode method should not be
+// called on the nested AttributeEncoder.
+//
+// The nested AttributeEncoder nae inherits the same ByteOrder setting as the
+// top-level AttributeEncoder ae.
+func (ae *AttributeEncoder) Nested(typ uint16, fn func(nae *AttributeEncoder) error) {
+	// Because we are wrapping Do, there is no need to check ae.err immediately.
+	ae.Do(Nested|typ, func() ([]byte, error) {
+		nae := NewAttributeEncoder()
+		nae.ByteOrder = ae.ByteOrder
+
+		if err := fn(nae); err != nil {
+			return nil, err
+		}
+
+		return nae.Encode()
+	})
+}
+
 // Encode returns the encoded bytes representing the attributes.
 func (ae *AttributeEncoder) Encode() ([]byte, error) {
 	if ae.err != nil {

vendor/github.com/mdlayher/netlink/conn.go

@@ -583,4 +583,22 @@ type Config struct {
 	// CAP_SYS_ADMIN are required), and most applications should leave this set
 	// to 0.
 	NetNS int
+
+	// DisableNSLockThread disables package netlink's default goroutine thread
+	// locking behavior.
+	//
+	// By default, the library will lock the processing goroutine to its
+	// corresponding OS thread in order to enable communication over netlink to
+	// a different network namespace.
+	//
+	// If the caller already knows that the netlink socket is in the same
+	// namespace as the calling thread, this can introduce a performance
+	// impact. This option disables the OS thread locking behavior if
+	// performance considerations are of interest.
+	//
+	// If disabled, it is the responsibility of the caller to make sure that all
+	// threads are running in the correct namespace.
+	//
+	// When DisableNSLockThread is set, the caller cannot set the NetNS value.
+	DisableNSLockThread bool
 }

vendor/github.com/mdlayher/netlink/conn_linux.go

@@ -3,6 +3,7 @@
 package netlink
 
 import (
+	"errors"
 	"math"
 	"os"
 	"runtime"
@@ -339,7 +340,7 @@ type sysSocket struct {
 // to a single thread.
 func newSysSocket(config *Config) (*sysSocket, error) {
 	// Determine network namespaces using the threadNetNS function.
-	g, err := newLockedNetNSGoroutine(config.NetNS, threadNetNS)
+	g, err := newLockedNetNSGoroutine(config.NetNS, threadNetNS, !config.DisableNSLockThread)
 	if err != nil {
 		return nil, err
 	}
@@ -542,13 +543,8 @@ func (s *sysSocket) Recvmsg(p, oob []byte, flags int) (int, int, int, unix.Socka
 	doErr := s.read(func(fd int) bool {
 		n, oobn, recvflags, from, err = unix.Recvmsg(fd, p, oob, flags)
 
-		// When the socket is in non-blocking mode, we might see
-		// EAGAIN and end up here. In that case, return false to
-		// let the poller wait for readiness. See the source code
-		// for internal/poll.FD.RawRead for more details.
-		//
-		// If the socket is in blocking mode, EAGAIN should never occur.
-		return err != syscall.EAGAIN
+		// Check for readiness.
+		return ready(err)
 	})
 	if doErr != nil {
 		return 0, 0, 0, nil, doErr
@@ -562,8 +558,8 @@ func (s *sysSocket) Sendmsg(p, oob []byte, to unix.Sockaddr, flags int) error {
 	doErr := s.write(func(fd int) bool {
 		err = unix.Sendmsg(fd, p, oob, to, flags)
 
-		// Analogous to Recvmsg. See the comments there.
-		return err != syscall.EAGAIN
+		// Check for readiness.
+		return ready(err)
 	})
 	if doErr != nil {
 		return doErr
@@ -613,6 +609,28 @@ func (s *sysSocket) SetSockoptSockFprog(level, opt int, fprog *unix.SockFprog) e
 	return err
 }
 
+// ready indicates readiness based on the value of err.
+func ready(err error) bool {
+	// When a socket is in non-blocking mode, we might see
+	// EAGAIN. In that case, return false to let the poller wait for readiness.
+	// See the source code for internal/poll.FD.RawRead for more details.
+	//
+	// Starting in Go 1.14, goroutines are asynchronously preemptible. The 1.14
+	// release notes indicate that applications should expect to see EINTR more
+	// often on slow system calls (like recvmsg while waiting for input), so
+	// we must handle that case as well.
+	//
+	// If the socket is in blocking mode, EAGAIN should never occur.
+	switch err {
+	case syscall.EAGAIN, syscall.EINTR:
+		// Not ready.
+		return false
+	default:
+		// Ready whether there was error or no error.
+		return true
+	}
+}
+
 // lockedNetNSGoroutine is a worker goroutine locked to an operating system
 // thread, optionally configured to run in a non-default network namespace.
 type lockedNetNSGoroutine struct {
@@ -624,10 +642,16 @@ type lockedNetNSGoroutine struct {
 // newLockedNetNSGoroutine creates a lockedNetNSGoroutine that will enter the
 // specified network namespace netNS (by file descriptor), and will use the
 // getNS function to produce netNS handles.
-func newLockedNetNSGoroutine(netNS int, getNS func() (*netNS, error)) (*lockedNetNSGoroutine, error) {
+func newLockedNetNSGoroutine(netNS int, getNS func() (*netNS, error), lockThread bool) (*lockedNetNSGoroutine, error) {
 	// Any bare syscall errors (e.g. setns) should be wrapped with
 	// os.NewSyscallError for the remainder of this function.
 
+	// If the caller has instructed us to not lock OS thread but also attempts
+	// to set a namespace, return an error.
+	if !lockThread && netNS != 0 {
+		return nil, errors.New("netlink Conn attempted to set a namespace with OS thread locking disabled")
+	}
+
 	callerNS, err := getNS()
 	if err != nil {
 		return nil, err
@@ -660,9 +684,16 @@ func newLockedNetNSGoroutine(netNS int, getNS func() (*netNS, error)) (*lockedNe
 		// with the Go runtime for threads which are not unlocked, we have
 		// elected to temporarily unlock the thread when the goroutine terminates:
 		// https://github.com/golang/go/issues/25128#issuecomment-410764489.
+		//
+		// Locking the thread is not implemented if the caller explicitly asks
+		// for an unlocked thread.
+
+		// Only lock the tread, if the lockThread is set.
+		if lockThread {
+			runtime.LockOSThread()
+			defer runtime.UnlockOSThread()
+		}
 
-		runtime.LockOSThread()
-		defer runtime.UnlockOSThread()
 		defer g.wg.Done()
 
 		// Get the current namespace of the thread the goroutine is locked to.

vendor/github.com/mdlayher/netlink/errors.go

@@ -32,6 +32,8 @@ func notSupported(op string) error {
 // Errors types created by this package, such as OpError, can be used with
 // IsNotExist, but this function also defers to the behavior of os.IsNotExist
 // for unrecognized error types.
+//
+// Deprecated: make use of errors.Unwrap and errors.Is in Go 1.13+.
 func IsNotExist(err error) bool {
 	switch err := err.(type) {
 	case *OpError:
@@ -44,8 +46,12 @@ func IsNotExist(err error) bool {
 	}
 }
 
-var _ error = &OpError{}
-var _ net.Error = &OpError{}
+var (
+	_ error     = &OpError{}
+	_ net.Error = &OpError{}
+	// Ensure compatibility with Go 1.13+ errors package.
+	_ interface{ Unwrap() error } = &OpError{}
+)
 
 // An OpError is an error produced as the result of a failed netlink operation.
 type OpError struct {
@@ -84,6 +90,9 @@ func (e *OpError) Error() string {
 	return fmt.Sprintf("netlink %s: %v", e.Op, e.Err)
 }
 
+// Unwrap unwraps the internal Err field for use with errors.Unwrap.
+func (e *OpError) Unwrap() error { return e.Err }
+
 // Portions of this code taken from the Go standard library:
 //
 // Copyright 2009 The Go Authors. All rights reserved.

vendor/github.com/mdlayher/netlink/go.mod

@@ -3,8 +3,8 @@ module github.com/mdlayher/netlink
 go 1.12
 
 require (
-	github.com/google/go-cmp v0.3.1
-	github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a
-	golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297
-	golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456
+	github.com/google/go-cmp v0.4.0
+	github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4
+	golang.org/x/net v0.0.0-20200202094626-16171245cfb2
+	golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5
 )

vendor/github.com/mdlayher/netlink/go.sum

@@ -1,16 +1,29 @@
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a h1:84IpUNXj4mCR9CuCEvSiCArMbzr/TMbuPIadKDwypkI=
 github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
+github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4 h1:nwOc1YaOrYJ37sEBrtWZrdqzK22hiJs3GpDmP3sR2Yw=
+github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ=
 github.com/mdlayher/netlink v0.0.0-20190409211403-11939a169225/go.mod h1:eQB3mZE4aiYnlUsyGGCOpPETfdQq4Jhsgf1fk3cwQaA=
+github.com/mdlayher/netlink v1.0.0/go.mod h1:KxeJAFOFLG6AjpyDkQ/iIhxygIUKD+vcwqcnu43w/+M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297 h1:k7pJ2yAPLPgbskkFdhRCsA77k2fySZ1zf2zCjvQCiIM=
 golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191007182048-72f939374954/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2 h1:CCH4IOTTfewWjGOlSp+zGcjutRKlBEZQ6wTn8ozI/nI=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190411185658-b44545bcd369/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456 h1:ng0gs1AKnRRuEMZoTLLlbOd+C17zUDepwGQBb/n+JVg=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5 h1:LfCXLvNmTYH9kEmVgqbnsWfruoXZIrh4YBgqVHtDvw0=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

vendor/github.com/mdlayher/netlink/message.go

@@ -7,6 +7,16 @@ import (
 	"github.com/mdlayher/netlink/nlenc"
 )
 
+// Flags which may apply to netlink attribute types when communicating with
+// certain netlink families.
+const (
+	Nested       uint16 = 0x8000
+	NetByteOrder uint16 = 0x4000
+
+	// attrTypeMask masks off Type bits used for the above flags.
+	attrTypeMask uint16 = 0x3fff
+)
+
 // Various errors which may occur when attempting to marshal or unmarshal
 // a Message to and from its binary form.
 var (
@@ -174,8 +184,8 @@ type Header struct {
 // A Message is a netlink message.  It contains a Header and an arbitrary
 // byte payload, which may be decoded using information from the Header.
 //
-// Data is encoded in the native endianness of the host system.  For easier
-// of encoding and decoding of integers, use package nlenc.
+// Data is often populated with netlink attributes. For easy encoding and
+// decoding of attributes, see the AttributeDecoder and AttributeEncoder types.
 type Message struct {
 	Header Header
 	Data   []byte