vendor: bump github.com/mdlayher/wifi and dependencies (#1045)

Signed-off-by: Matt Layher <mdlayher@gmail.com>

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

@@ -1,7 +1,9 @@
 package netlink
 
 import (
+	"encoding/binary"
 	"errors"
+	"fmt"
 
 	"github.com/mdlayher/netlink/nlenc"
 )
@@ -9,9 +11,6 @@ import (
 var (
 	// errInvalidAttribute specifies if an Attribute's length is incorrect.
 	errInvalidAttribute = errors.New("invalid attribute; length too short or too large")
-	// errInvalidAttributeFlags specifies if an Attribute's flag configuration is invalid.
-	// From a comment in Linux/include/uapi/linux/netlink.h, Nested and NetByteOrder are mutually exclusive.
-	errInvalidAttributeFlags = errors.New("invalid attribute; type cannot have both nested and net byte order flags")
 )
 
 // An Attribute is a netlink attribute.  Attributes are packed and unpacked
@@ -25,48 +24,18 @@ type Attribute struct {
 
 	// An arbitrary payload which is specified by Type.
 	Data []byte
-
-	// Whether the attribute's data contains nested attributes.  Note that not
-	// all netlink families set this value.  The programmer should consult
-	// documentation and inspect an attribute's data to determine if nested
-	// attributes are present.
-	Nested bool
-
-	// Whether the attribute's data is in network (true) or native (false) byte order.
-	NetByteOrder bool
 }
 
-// #define NLA_F_NESTED
-const nlaNested uint16 = 0x8000
-
-// #define NLA_F_NET_BYTE_ORDER
-const nlaNetByteOrder uint16 = 0x4000
-
-// Masks all bits except for Nested and NetByteOrder.
-const nlaTypeMask = ^(nlaNested | nlaNetByteOrder)
-
 // MarshalBinary marshals an Attribute into a byte slice.
 func (a Attribute) MarshalBinary() ([]byte, error) {
 	if int(a.Length) < nlaHeaderLen {
 		return nil, errInvalidAttribute
 	}
 
-	if a.NetByteOrder && a.Nested {
-		return nil, errInvalidAttributeFlags
-	}
-
 	b := make([]byte, nlaAlign(int(a.Length)))
 
 	nlenc.PutUint16(b[0:2], a.Length)
-
-	switch {
-	case a.Nested:
-		nlenc.PutUint16(b[2:4], a.Type|nlaNested)
-	case a.NetByteOrder:
-		nlenc.PutUint16(b[2:4], a.Type|nlaNetByteOrder)
-	default:
-		nlenc.PutUint16(b[2:4], a.Type)
-	}
+	nlenc.PutUint16(b[2:4], a.Type)
 
 	copy(b[nlaHeaderLen:], a.Data)
 
@@ -80,22 +49,12 @@ func (a *Attribute) UnmarshalBinary(b []byte) error {
 	}
 
 	a.Length = nlenc.Uint16(b[0:2])
-
-	// Only hold the rightmost 14 bits in Type
-	a.Type = nlenc.Uint16(b[2:4]) & nlaTypeMask
-
-	// Boolean flags extracted from the two leftmost bits of Type
-	a.Nested = (nlenc.Uint16(b[2:4]) & nlaNested) > 0
-	a.NetByteOrder = (nlenc.Uint16(b[2:4]) & nlaNetByteOrder) > 0
+	a.Type = nlenc.Uint16(b[2:4])
 
 	if nlaAlign(int(a.Length)) > len(b) {
 		return errInvalidAttribute
 	}
 
-	if a.NetByteOrder && a.Nested {
-		return errInvalidAttributeFlags
-	}
-
 	switch {
 	// No length, no data
 	case a.Length == 0:
@@ -139,6 +98,9 @@ func MarshalAttributes(attrs []Attribute) ([]byte, error) {
 }
 
 // UnmarshalAttributes unpacks a slice of Attributes from a single byte slice.
+//
+// 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
@@ -164,3 +126,173 @@ func UnmarshalAttributes(b []byte) ([]Attribute, error) {
 
 	return attrs, nil
 }
+
+// An AttributeDecoder provides a safe, iterator-like, API around attribute
+// decoding.
+//
+// It is recommend to use an AttributeDecoder where possible instead of calling
+// UnmarshalAttributes and using package nlenc functions directly.
+//
+// The Err method must be called after the Next method returns false to determine
+// if any errors occurred during iteration.
+type AttributeDecoder struct {
+	// ByteOrder defines a specific byte order to use when processing integer
+	// attributes.  ByteOrder should be set immediately after creating the
+	// AttributeDecoder: before any attributes are parsed.
+	//
+	// 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
+
+	// Any error encountered while decoding attributes.
+	err error
+}
+
+// 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)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AttributeDecoder{
+		// By default, use native byte order.
+		ByteOrder: nlenc.NativeEndian(),
+
+		attrs: attrs,
+	}, nil
+}
+
+// Next advances the decoder to the next netlink attribute.  It returns false
+// when no more attributes are present, or an error was encountered.
+func (ad *AttributeDecoder) Next() bool {
+	if ad.err != nil {
+		// Hit an error, stop iteration.
+		return false
+	}
+
+	ad.i++
+
+	if len(ad.attrs) < ad.i {
+		// No more attributes, stop iteration.
+		return false
+	}
+
+	return true
+}
+
+// Type returns the Attribute.Type field of the current netlink attribute
+// pointed to by the decoder.
+func (ad *AttributeDecoder) Type() uint16 {
+	return ad.attr().Type
+}
+
+// attr returns the current Attribute pointed to by the decoder.
+func (ad *AttributeDecoder) attr() Attribute {
+	return ad.attrs[ad.i-1]
+}
+
+// data returns the Data field of the current Attribute pointed to by the decoder.
+func (ad *AttributeDecoder) data() []byte {
+	return ad.attr().Data
+}
+
+// Err returns the first error encountered by the decoder.
+func (ad *AttributeDecoder) Err() error {
+	return ad.err
+}
+
+// String returns the string representation of the current Attribute's data.
+func (ad *AttributeDecoder) String() string {
+	if ad.err != nil {
+		return ""
+	}
+
+	return nlenc.String(ad.data())
+}
+
+// Uint8 returns the uint8 representation of the current Attribute's data.
+func (ad *AttributeDecoder) Uint8() uint8 {
+	if ad.err != nil {
+		return 0
+	}
+
+	b := ad.data()
+	if len(b) != 1 {
+		ad.err = fmt.Errorf("netlink: attribute %d is not a uint8; length: %d", ad.Type(), len(b))
+		return 0
+	}
+
+	return uint8(b[0])
+}
+
+// Uint16 returns the uint16 representation of the current Attribute's data.
+func (ad *AttributeDecoder) Uint16() uint16 {
+	if ad.err != nil {
+		return 0
+	}
+
+	b := ad.data()
+	if len(b) != 2 {
+		ad.err = fmt.Errorf("netlink: attribute %d is not a uint16; length: %d", ad.Type(), len(b))
+		return 0
+	}
+
+	return ad.ByteOrder.Uint16(b)
+}
+
+// Uint32 returns the uint32 representation of the current Attribute's data.
+func (ad *AttributeDecoder) Uint32() uint32 {
+	if ad.err != nil {
+		return 0
+	}
+
+	b := ad.data()
+	if len(b) != 4 {
+		ad.err = fmt.Errorf("netlink: attribute %d is not a uint32; length: %d", ad.Type(), len(b))
+		return 0
+	}
+
+	return ad.ByteOrder.Uint32(b)
+}
+
+// Uint64 returns the uint64 representation of the current Attribute's data.
+func (ad *AttributeDecoder) Uint64() uint64 {
+	if ad.err != nil {
+		return 0
+	}
+
+	b := ad.data()
+	if len(b) != 8 {
+		ad.err = fmt.Errorf("netlink: attribute %d is not a uint64; length: %d", ad.Type(), len(b))
+		return 0
+	}
+
+	return ad.ByteOrder.Uint64(b)
+}
+
+// Do is a general purpose function which allows access to the current data
+// pointed to by the AttributeDecoder.
+//
+// Do can be used to allow parsing arbitrary data within the context of the
+// decoder.  Do is most useful when dealing with nested attributes, attribute
+// arrays, or decoding arbitrary types (such as C structures) which don't fit
+// cleanly into a typical unsigned integer value.
+//
+// The function fn should not retain any reference to the data b outside of the
+// scope of the function.
+func (ad *AttributeDecoder) Do(fn func(b []byte) error) {
+	if ad.err != nil {
+		return
+	}
+
+	b := ad.data()
+	if err := fn(b); err != nil {
+		ad.err = err
+	}
+}