summaryrefslogtreecommitdiffstats
path: root/llgo/third_party/gofrontend/libgo/go/syscall/route_bsd.go
diff options
context:
space:
mode:
Diffstat (limited to 'llgo/third_party/gofrontend/libgo/go/syscall/route_bsd.go')
-rw-r--r--llgo/third_party/gofrontend/libgo/go/syscall/route_bsd.go313
1 files changed, 218 insertions, 95 deletions
diff --git a/llgo/third_party/gofrontend/libgo/go/syscall/route_bsd.go b/llgo/third_party/gofrontend/libgo/go/syscall/route_bsd.go
index 1dabe42531b..c62fdc3c81d 100644
--- a/llgo/third_party/gofrontend/libgo/go/syscall/route_bsd.go
+++ b/llgo/third_party/gofrontend/libgo/go/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,134 @@ func rsaAlignOf(salen int) int {
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 following:
+ // +----------------------------+
+ // | 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
+ }
+ // Don't reorder case expressions.
+ // The case expressions for IPv6 must come first.
+ switch {
+ case b[0] == SizeofSockaddrInet6:
+ sa := &SockaddrInet6{}
+ copy(sa.Addr[:], b[offsetofInet6:])
+ return sa, nil
+ case family == 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
+ case b[0] == SizeofSockaddrInet4:
+ sa := &SockaddrInet4{}
+ copy(sa.Addr[:], b[offsetofInet4:])
+ 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 +192,7 @@ func RouteRIB(facility, param int) ([]byte, error) {
// RoutingMessage represents a routing message.
type RoutingMessage interface {
- sockaddr() []Sockaddr
+ sockaddr() ([]Sockaddr, error)
}
const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))
@@ -68,50 +210,41 @@ type RouteMessage struct {
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
+ return nil, err
}
- if i == RTAX_DST {
- af = int(rsa.Family)
+ 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
- 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)):]
+ 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 +254,17 @@ type InterfaceMessage struct {
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 +274,63 @@ type InterfaceAddrMessage struct {
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
+ 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
}
- sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
+ sas[i] = sa
+ b = b[rsaAlignOf(int(rsa.Len)):]
+ family = rsa.Family
+ default:
+ sa, err := parseNetworkLayerAddr(b, 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(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 +338,10 @@ func ParseRoutingMessage(b []byte) (msgs []RoutingMessage, err error) {
// 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
}
OpenPOWER on IntegriCloud