golang route_bsd 代码
文件路径：/src/syscall/route_bsd.go
/ Copyright 2011 The Go Authors. All rights reserved.
/ Use of this source code is governed by a BSD-style
/ license that can be found in the LICENSE file.
/go:build darwin || dragonfly || freebsd || netbsd || openbsd
package syscall
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
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
}
return (salen + salign - 1) & ^(salign - 1)
}
/ parseSockaddrLink parses b as a datalink socket address.
func parseSockaddrLink(b []byte) (*SockaddrDatalink, error) {
if len(b) < 8 {
return nil, EINVAL
}
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 := 4 + int(lla.Nlen) + int(lla.Alen) + int(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 < l-4; i++ {
sa.Data[i] = int8(b[i])
}
return sa, rsaAlignOf(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 message 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.
/
/ Deprecated: Use golang.org/x/net/route instead.
func RouteRIB(facility, param int) ([]byte, error) {
mib := []_C_int{CTL_NET, AF_ROUTE, 0, 0, _C_int(facility), _C_int(param)}
/ Find size.
n := uintptr(0)
if err := sysctl(mib, nil, &n, nil, 0); err != nil {
return nil, err
}
if n == 0 {
return nil, nil
}
tab := make([]byte, n)
if err := sysctl(mib, &tab[0], &n, nil, 0); err != nil {
return nil, err
}
return tab[:n], nil
}
/ RoutingMessage represents a routing message.
/
/ Deprecated: Use golang.org/x/net/route instead.
type RoutingMessage interface {
sockaddr() ([]Sockaddr, error)
}
const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))
type anyMessage struct {
Msglen uint16
Version uint8
Type uint8
}
/ RouteMessage represents a routing message containing routing
/ entries.
/
/ Deprecated: Use golang.org/x/net/route instead.
type RouteMessage struct {
Header RtMsghdr
Data []byte
}
func (m *RouteMessage) sockaddr() ([]Sockaddr, error) {
var sas [RTAX_MAX]Sockaddr
b := m.Data[:]
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 rsa.Family {
case AF_LINK:
sa, err := parseSockaddrLink(b)
if err != nil {
return nil, err
}
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])):]
}
}
return sas[:], nil
}
/ InterfaceMessage represents a routing message containing
/ network interface entries.
/
/ Deprecated: Use golang.org/x/net/route instead.
type InterfaceMessage struct {
Header IfMsghdr
Data []byte
}
func (m *InterfaceMessage) sockaddr() ([]Sockaddr, error) {
var sas [RTAX_MAX]Sockaddr
if m.Header.Addrs&RTA_IFP == 0 {
return nil, nil
}
sa, err := parseSockaddrLink(m.Data[:])
if err != nil {
return nil, err
}
sas[RTAX_IFP] = sa
return sas[:], nil
}
/ InterfaceAddrMessage represents a routing message containing
/ network interface address entries.
/
/ Deprecated: Use golang.org/x/net/route instead.
type InterfaceAddrMessage struct {
Header IfaMsghdr
Data []byte
}
func (m *InterfaceAddrMessage) sockaddr() ([]Sockaddr, error) {
var sas [RTAX_MAX]Sockaddr
b := m.Data[:]
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 rsa.Family {
case AF_LINK:
sa, err := parseSockaddrLink(b)
if err != nil {
return nil, err
}
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])):]
}
}
return sas[:], nil
}
/ ParseRoutingMessage parses b as routing messages and returns the
/ slice containing the RoutingMessage interfaces.
/
/ Deprecated: Use golang.org/x/net/route instead.
func ParseRoutingMessage(b []byte) (msgs []RoutingMessage, err error) {
nmsgs, nskips := 0, 0
for len(b) >= anyMessageLen {
nmsgs++
any := (*anyMessage)(unsafe.Pointer(&b[0]))
if any.Version != RTM_VERSION {
b = b[any.Msglen:]
continue
}
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 nmsgs != len(msgs)+nskips {
return nil, EINVAL
}
return msgs, nil
}
/ ParseRoutingSockaddr parses msg's payload as raw sockaddrs and
/ returns the slice containing the Sockaddr interfaces.
/
/ Deprecated: Use golang.org/x/net/route instead.
func ParseRoutingSockaddr(msg RoutingMessage) ([]Sockaddr, error) {
sas, err := msg.sockaddr()
if err != nil {
return nil, err
}
return sas, nil
}