net, syscall: more accurate parsers for routing messages on BSD variants
This changes fixes two issues with regard to handling routing messages
as follows:
- Misparsing on platforms (such as FreeBSD) supporting multiple
architectures in the same kernel (kern.supported_archs="amd64 i386")
- Misparsing with unimplemented messages such as route, interface
address state notifications
To fix those issues, this change implements all the required socket
address parsers, adds a processor architecture identifying function to
FreeBSD and tests.
Fixes #9707.
Fixes #8203.
Change-Id: I7ed7b4a0b6f10f54b29edc681a2f35603f2d8d45
Reviewed-on: https://go-review.googlesource.com/4330
Reviewed-by: Ian Lance Taylor <iant@golang.org>
diff --git a/src/syscall/route_bsd.go b/src/syscall/route_bsd.go
index 1dabe42..bc5de69 100644
--- a/src/syscall/route_bsd.go
+++ b/src/syscall/route_bsd.go
@@ -4,23 +4,37 @@
// +build darwin dragonfly freebsd netbsd openbsd
-// Routing sockets and messages
-
package syscall
-import "unsafe"
+import (
+ "runtime"
+ "unsafe"
+)
+
+var (
+ freebsdConfArch string // "machine $arch" line in kern.conftxt on freebsd
+ minRoutingSockaddrLen = rsaAlignOf(0)
+)
// Round the length of a raw sockaddr up to align it properly.
func rsaAlignOf(salen int) int {
salign := sizeofPtr
- // NOTE: It seems like 64-bit Darwin kernel still requires
- // 32-bit aligned access to BSD subsystem. Also NetBSD 6
- // kernel and beyond require 64-bit aligned access to routing
- // facilities.
if darwin64Bit {
+ // Darwin kernels require 32-bit aligned access to
+ // routing facilities.
salign = 4
} else if netbsd32Bit {
+ // NetBSD 6 and beyond kernels require 64-bit aligned
+ // access to routing facilities.
salign = 8
+ } else if runtime.GOOS == "freebsd" {
+ // In the case of kern.supported_archs="amd64 i386",
+ // we need to know the underlying kernel's
+ // architecture because the alignment for routing
+ // facilities are set at the build time of the kernel.
+ if freebsdConfArch == "amd64" {
+ salign = 8
+ }
}
if salen == 0 {
return salign
@@ -28,6 +42,124 @@
return (salen + salign - 1) & ^(salign - 1)
}
+// parseSockaddrLink parses b as a datalink socket address.
+func parseSockaddrLink(b []byte) (*SockaddrDatalink, error) {
+ sa, _, err := parseLinkLayerAddr(b[4:])
+ if err != nil {
+ return nil, err
+ }
+ rsa := (*RawSockaddrDatalink)(unsafe.Pointer(&b[0]))
+ sa.Len = rsa.Len
+ sa.Family = rsa.Family
+ sa.Index = rsa.Index
+ return sa, nil
+}
+
+// parseLinkLayerAddr parses b as a datalink socket address in
+// conventional BSD kernel form.
+func parseLinkLayerAddr(b []byte) (*SockaddrDatalink, int, error) {
+ // The encoding looks like the follwoing:
+ // +----------------------------+
+ // | Type (1 octet) |
+ // +----------------------------+
+ // | Name length (1 octet) |
+ // +----------------------------+
+ // | Address length (1 octet) |
+ // +----------------------------+
+ // | Selector length (1 octet) |
+ // +----------------------------+
+ // | Data (variable) |
+ // +----------------------------+
+ type linkLayerAddr struct {
+ Type byte
+ Nlen byte
+ Alen byte
+ Slen byte
+ }
+ lla := (*linkLayerAddr)(unsafe.Pointer(&b[0]))
+ l := rsaAlignOf(int(4 + lla.Nlen + lla.Alen + lla.Slen))
+ if len(b) < l {
+ return nil, 0, EINVAL
+ }
+ b = b[4:]
+ sa := &SockaddrDatalink{Type: lla.Type, Nlen: lla.Nlen, Alen: lla.Alen, Slen: lla.Slen}
+ for i := 0; len(sa.Data) > i && i < int(lla.Nlen+lla.Alen+lla.Slen); i++ {
+ sa.Data[i] = int8(b[i])
+ }
+ return sa, l, nil
+}
+
+// parseSockaddrInet parses b as an internet socket address.
+func parseSockaddrInet(b []byte, family byte) (Sockaddr, error) {
+ switch family {
+ case AF_INET:
+ if len(b) < SizeofSockaddrInet4 {
+ return nil, EINVAL
+ }
+ rsa := (*RawSockaddrAny)(unsafe.Pointer(&b[0]))
+ return anyToSockaddr(rsa)
+ case AF_INET6:
+ if len(b) < SizeofSockaddrInet6 {
+ return nil, EINVAL
+ }
+ rsa := (*RawSockaddrAny)(unsafe.Pointer(&b[0]))
+ return anyToSockaddr(rsa)
+ default:
+ return nil, EINVAL
+ }
+}
+
+const (
+ offsetofInet4 = int(unsafe.Offsetof(RawSockaddrInet4{}.Addr))
+ offsetofInet6 = int(unsafe.Offsetof(RawSockaddrInet6{}.Addr))
+)
+
+// parseNetworkLayerAddr parses b as an internet socket address in
+// conventional BSD kernel form.
+func parseNetworkLayerAddr(b []byte, family byte) (Sockaddr, error) {
+ // The encoding looks similar to the NLRI encoding.
+ // +----------------------------+
+ // | Length (1 octet) |
+ // +----------------------------+
+ // | Address prefix (variable) |
+ // +----------------------------+
+ //
+ // The differences between the kernel form and the NLRI
+ // encoding are:
+ //
+ // - The length field of the kernel form indicates the prefix
+ // length in bytes, not in bits
+ //
+ // - In the kernel form, zero value of the length field
+ // doesn't mean 0.0.0.0/0 or ::/0
+ //
+ // - The kernel form appends leading bytes to the prefix field
+ // to make the <length, prefix> tuple to be conformed with
+ // the routing messeage boundary
+ l := int(rsaAlignOf(int(b[0])))
+ if len(b) < l {
+ return nil, EINVAL
+ }
+ switch family {
+ case AF_INET6:
+ sa := &SockaddrInet6{}
+ if l-1 < offsetofInet6 {
+ copy(sa.Addr[:], b[1:l])
+ } else {
+ copy(sa.Addr[:], b[l-offsetofInet6:l])
+ }
+ return sa, nil
+ default: // an old fashion, AF_UNSPEC or unknown means AF_INET
+ sa := &SockaddrInet4{}
+ if l-1 < offsetofInet4 {
+ copy(sa.Addr[:], b[1:l])
+ } else {
+ copy(sa.Addr[:], b[l-offsetofInet4:l])
+ }
+ return sa, nil
+ }
+}
+
// RouteRIB returns routing information base, as known as RIB,
// which consists of network facility information, states and
// parameters.
@@ -50,7 +182,7 @@
// RoutingMessage represents a routing message.
type RoutingMessage interface {
- sockaddr() []Sockaddr
+ sockaddr() ([]Sockaddr, error)
}
const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))
@@ -68,50 +200,41 @@
Data []byte
}
-const rtaRtMask = RTA_DST | RTA_GATEWAY | RTA_NETMASK | RTA_GENMASK
-
-func (m *RouteMessage) sockaddr() []Sockaddr {
- var (
- af int
- sas [4]Sockaddr
- )
+func (m *RouteMessage) sockaddr() ([]Sockaddr, error) {
+ var sas [RTAX_MAX]Sockaddr
b := m.Data[:]
- for i := uint(0); i < RTAX_MAX; i++ {
- if m.Header.Addrs&rtaRtMask&(1<<i) == 0 {
+ family := uint8(AF_UNSPEC)
+ for i := uint(0); i < RTAX_MAX && len(b) >= minRoutingSockaddrLen; i++ {
+ if m.Header.Addrs&(1<<i) == 0 {
continue
}
rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
- switch i {
- case RTAX_DST, RTAX_GATEWAY:
- sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
+ switch rsa.Family {
+ case AF_LINK:
+ sa, err := parseSockaddrLink(b)
if err != nil {
- return nil
- }
- if i == RTAX_DST {
- af = int(rsa.Family)
+ return nil, err
}
sas[i] = sa
- case RTAX_NETMASK, RTAX_GENMASK:
- switch af {
- case AF_INET:
- rsa4 := (*RawSockaddrInet4)(unsafe.Pointer(&b[0]))
- sa := new(SockaddrInet4)
- for j := 0; rsa4.Len > 0 && j < int(rsa4.Len)-int(unsafe.Offsetof(rsa4.Addr)); j++ {
- sa.Addr[j] = rsa4.Addr[j]
- }
- sas[i] = sa
- case AF_INET6:
- rsa6 := (*RawSockaddrInet6)(unsafe.Pointer(&b[0]))
- sa := new(SockaddrInet6)
- for j := 0; rsa6.Len > 0 && j < int(rsa6.Len)-int(unsafe.Offsetof(rsa6.Addr)); j++ {
- sa.Addr[j] = rsa6.Addr[j]
- }
- sas[i] = sa
+ b = b[rsaAlignOf(int(rsa.Len)):]
+ case AF_INET, AF_INET6:
+ sa, err := parseSockaddrInet(b, rsa.Family)
+ if err != nil {
+ return nil, err
}
+ sas[i] = sa
+ b = b[rsaAlignOf(int(rsa.Len)):]
+ family = rsa.Family
+ default:
+ sa, err := parseNetworkLayerAddr(b, family)
+ if err != nil {
+ return nil, err
+ }
+ sas[i] = sa
+ b = b[rsaAlignOf(int(b[0])):]
}
- b = b[rsaAlignOf(int(rsa.Len)):]
}
- return sas[:]
+ return sas[:], nil
}
// InterfaceMessage represents a routing message containing
@@ -121,15 +244,17 @@
Data []byte
}
-func (m *InterfaceMessage) sockaddr() (sas []Sockaddr) {
+func (m *InterfaceMessage) sockaddr() ([]Sockaddr, error) {
+ var sas [RTAX_MAX]Sockaddr
if m.Header.Addrs&RTA_IFP == 0 {
- return nil
+ return nil, nil
}
- sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(&m.Data[0])))
+ sa, err := parseSockaddrLink(m.Data[:])
if err != nil {
- return nil
+ return nil, err
}
- return append(sas, sa)
+ sas[RTAX_IFP] = sa
+ return sas[:], nil
}
// InterfaceAddrMessage represents a routing message containing
@@ -139,79 +264,63 @@
Data []byte
}
-const rtaIfaMask = RTA_IFA | RTA_NETMASK | RTA_BRD
-
-func (m *InterfaceAddrMessage) sockaddr() (sas []Sockaddr) {
- if m.Header.Addrs&rtaIfaMask == 0 {
- return nil
- }
+func (m *InterfaceAddrMessage) sockaddr() ([]Sockaddr, error) {
+ var sas [RTAX_MAX]Sockaddr
b := m.Data[:]
- // We still see AF_UNSPEC in socket addresses on some
- // platforms. To identify each address family correctly, we
- // will use the address family of RTAX_NETMASK as a preferred
- // one on the 32-bit NetBSD kernel, also use the length of
- // RTAX_NETMASK socket address on the FreeBSD kernel.
- preferredFamily := uint8(AF_UNSPEC)
- for i := uint(0); i < RTAX_MAX; i++ {
+ family := uint8(AF_UNSPEC)
+ for i := uint(0); i < RTAX_MAX && len(b) >= minRoutingSockaddrLen; i++ {
if m.Header.Addrs&(1<<i) == 0 {
continue
}
rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
- switch i {
- case RTAX_IFA:
- if rsa.Family == AF_UNSPEC {
- rsa.Family = preferredFamily
- }
- sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
+ switch rsa.Family {
+ case AF_LINK:
+ sa, err := parseSockaddrLink(b)
if err != nil {
- return nil
+ return nil, err
}
- sas = append(sas, sa)
- case RTAX_NETMASK:
- switch rsa.Family {
- case AF_UNSPEC:
- switch rsa.Len {
- case SizeofSockaddrInet4:
- rsa.Family = AF_INET
- case SizeofSockaddrInet6:
- rsa.Family = AF_INET6
- default:
- rsa.Family = AF_INET // an old fashion, AF_UNSPEC means AF_INET
- }
- case AF_INET, AF_INET6:
- preferredFamily = rsa.Family
- default:
- return nil
- }
- sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
+ sas[i] = sa
+ b = b[rsaAlignOf(int(rsa.Len)):]
+ case AF_INET, AF_INET6:
+ sa, err := parseSockaddrInet(b, rsa.Family)
if err != nil {
- return nil
+ return nil, err
}
- sas = append(sas, sa)
- case RTAX_BRD:
- // nothing to do
+ sas[i] = sa
+ b = b[rsaAlignOf(int(rsa.Len)):]
+ family = rsa.Family
+ default:
+ sa, err := parseNetworkLayerAddr(b, family)
+ if err != nil {
+ return nil, err
+ }
+ sas[i] = sa
+ b = b[rsaAlignOf(int(b[0])):]
}
- b = b[rsaAlignOf(int(rsa.Len)):]
}
- return sas
+ return sas[:], nil
}
// ParseRoutingMessage parses b as routing messages and returns the
// slice containing the RoutingMessage interfaces.
func ParseRoutingMessage(b []byte) (msgs []RoutingMessage, err error) {
- msgCount := 0
+ nmsgs, nskips := 0, 0
for len(b) >= anyMessageLen {
- msgCount++
+ nmsgs++
any := (*anyMessage)(unsafe.Pointer(&b[0]))
if any.Version != RTM_VERSION {
b = b[any.Msglen:]
continue
}
- msgs = append(msgs, any.toRoutingMessage(b))
+ if m := any.toRoutingMessage(b); m == nil {
+ nskips++
+ } else {
+ msgs = append(msgs, m)
+ }
b = b[any.Msglen:]
}
// We failed to parse any of the messages - version mismatch?
- if msgCount > 0 && len(msgs) == 0 {
+ if nmsgs != len(msgs)+nskips {
return nil, EINVAL
}
return msgs, nil
@@ -219,6 +328,10 @@
// ParseRoutingMessage parses msg's payload as raw sockaddrs and
// returns the slice containing the Sockaddr interfaces.
-func ParseRoutingSockaddr(msg RoutingMessage) (sas []Sockaddr, err error) {
- return append(sas, msg.sockaddr()...), nil
+func ParseRoutingSockaddr(msg RoutingMessage) ([]Sockaddr, error) {
+ sas, err := msg.sockaddr()
+ if err != nil {
+ return nil, err
+ }
+ return sas, nil
}
