Source file src/pkg/syscall/route_bsd.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// +build darwin dragonfly freebsd netbsd openbsd
     6	
     7	package syscall
     8	
     9	import (
    10		"runtime"
    11		"unsafe"
    12	)
    13	
    14	var (
    15		freebsdConfArch       string // "machine $arch" line in kern.conftxt on freebsd
    16		minRoutingSockaddrLen = rsaAlignOf(0)
    17	)
    18	
    19	// Round the length of a raw sockaddr up to align it properly.
    20	func rsaAlignOf(salen int) int {
    21		salign := sizeofPtr
    22		if darwin64Bit {
    23			// Darwin kernels require 32-bit aligned access to
    24			// routing facilities.
    25			salign = 4
    26		} else if netbsd32Bit {
    27			// NetBSD 6 and beyond kernels require 64-bit aligned
    28			// access to routing facilities.
    29			salign = 8
    30		} else if runtime.GOOS == "freebsd" {
    31			// In the case of kern.supported_archs="amd64 i386",
    32			// we need to know the underlying kernel's
    33			// architecture because the alignment for routing
    34			// facilities are set at the build time of the kernel.
    35			if freebsdConfArch == "amd64" {
    36				salign = 8
    37			}
    38		}
    39		if salen == 0 {
    40			return salign
    41		}
    42		return (salen + salign - 1) & ^(salign - 1)
    43	}
    44	
    45	// parseSockaddrLink parses b as a datalink socket address.
    46	func parseSockaddrLink(b []byte) (*SockaddrDatalink, error) {
    47		if len(b) < 8 {
    48			return nil, EINVAL
    49		}
    50		sa, _, err := parseLinkLayerAddr(b[4:])
    51		if err != nil {
    52			return nil, err
    53		}
    54		rsa := (*RawSockaddrDatalink)(unsafe.Pointer(&b[0]))
    55		sa.Len = rsa.Len
    56		sa.Family = rsa.Family
    57		sa.Index = rsa.Index
    58		return sa, nil
    59	}
    60	
    61	// parseLinkLayerAddr parses b as a datalink socket address in
    62	// conventional BSD kernel form.
    63	func parseLinkLayerAddr(b []byte) (*SockaddrDatalink, int, error) {
    64		// The encoding looks like the following:
    65		// +----------------------------+
    66		// | Type             (1 octet) |
    67		// +----------------------------+
    68		// | Name length      (1 octet) |
    69		// +----------------------------+
    70		// | Address length   (1 octet) |
    71		// +----------------------------+
    72		// | Selector length  (1 octet) |
    73		// +----------------------------+
    74		// | Data            (variable) |
    75		// +----------------------------+
    76		type linkLayerAddr struct {
    77			Type byte
    78			Nlen byte
    79			Alen byte
    80			Slen byte
    81		}
    82		lla := (*linkLayerAddr)(unsafe.Pointer(&b[0]))
    83		l := 4 + int(lla.Nlen) + int(lla.Alen) + int(lla.Slen)
    84		if len(b) < l {
    85			return nil, 0, EINVAL
    86		}
    87		b = b[4:]
    88		sa := &SockaddrDatalink{Type: lla.Type, Nlen: lla.Nlen, Alen: lla.Alen, Slen: lla.Slen}
    89		for i := 0; len(sa.Data) > i && i < l-4; i++ {
    90			sa.Data[i] = int8(b[i])
    91		}
    92		return sa, rsaAlignOf(l), nil
    93	}
    94	
    95	// parseSockaddrInet parses b as an internet socket address.
    96	func parseSockaddrInet(b []byte, family byte) (Sockaddr, error) {
    97		switch family {
    98		case AF_INET:
    99			if len(b) < SizeofSockaddrInet4 {
   100				return nil, EINVAL
   101			}
   102			rsa := (*RawSockaddrAny)(unsafe.Pointer(&b[0]))
   103			return anyToSockaddr(rsa)
   104		case AF_INET6:
   105			if len(b) < SizeofSockaddrInet6 {
   106				return nil, EINVAL
   107			}
   108			rsa := (*RawSockaddrAny)(unsafe.Pointer(&b[0]))
   109			return anyToSockaddr(rsa)
   110		default:
   111			return nil, EINVAL
   112		}
   113	}
   114	
   115	const (
   116		offsetofInet4 = int(unsafe.Offsetof(RawSockaddrInet4{}.Addr))
   117		offsetofInet6 = int(unsafe.Offsetof(RawSockaddrInet6{}.Addr))
   118	)
   119	
   120	// parseNetworkLayerAddr parses b as an internet socket address in
   121	// conventional BSD kernel form.
   122	func parseNetworkLayerAddr(b []byte, family byte) (Sockaddr, error) {
   123		// The encoding looks similar to the NLRI encoding.
   124		// +----------------------------+
   125		// | Length           (1 octet) |
   126		// +----------------------------+
   127		// | Address prefix  (variable) |
   128		// +----------------------------+
   129		//
   130		// The differences between the kernel form and the NLRI
   131		// encoding are:
   132		//
   133		// - The length field of the kernel form indicates the prefix
   134		//   length in bytes, not in bits
   135		//
   136		// - In the kernel form, zero value of the length field
   137		//   doesn't mean 0.0.0.0/0 or ::/0
   138		//
   139		// - The kernel form appends leading bytes to the prefix field
   140		//   to make the <length, prefix> tuple to be conformed with
   141		//   the routing message boundary
   142		l := int(rsaAlignOf(int(b[0])))
   143		if len(b) < l {
   144			return nil, EINVAL
   145		}
   146		// Don't reorder case expressions.
   147		// The case expressions for IPv6 must come first.
   148		switch {
   149		case b[0] == SizeofSockaddrInet6:
   150			sa := &SockaddrInet6{}
   151			copy(sa.Addr[:], b[offsetofInet6:])
   152			return sa, nil
   153		case family == AF_INET6:
   154			sa := &SockaddrInet6{}
   155			if l-1 < offsetofInet6 {
   156				copy(sa.Addr[:], b[1:l])
   157			} else {
   158				copy(sa.Addr[:], b[l-offsetofInet6:l])
   159			}
   160			return sa, nil
   161		case b[0] == SizeofSockaddrInet4:
   162			sa := &SockaddrInet4{}
   163			copy(sa.Addr[:], b[offsetofInet4:])
   164			return sa, nil
   165		default: // an old fashion, AF_UNSPEC or unknown means AF_INET
   166			sa := &SockaddrInet4{}
   167			if l-1 < offsetofInet4 {
   168				copy(sa.Addr[:], b[1:l])
   169			} else {
   170				copy(sa.Addr[:], b[l-offsetofInet4:l])
   171			}
   172			return sa, nil
   173		}
   174	}
   175	
   176	// RouteRIB returns routing information base, as known as RIB,
   177	// which consists of network facility information, states and
   178	// parameters.
   179	//
   180	// Deprecated: Use golang.org/x/net/route instead.
   181	func RouteRIB(facility, param int) ([]byte, error) {
   182		mib := []_C_int{CTL_NET, AF_ROUTE, 0, 0, _C_int(facility), _C_int(param)}
   183		// Find size.
   184		n := uintptr(0)
   185		if err := sysctl(mib, nil, &n, nil, 0); err != nil {
   186			return nil, err
   187		}
   188		if n == 0 {
   189			return nil, nil
   190		}
   191		tab := make([]byte, n)
   192		if err := sysctl(mib, &tab[0], &n, nil, 0); err != nil {
   193			return nil, err
   194		}
   195		return tab[:n], nil
   196	}
   197	
   198	// RoutingMessage represents a routing message.
   199	//
   200	// Deprecated: Use golang.org/x/net/route instead.
   201	type RoutingMessage interface {
   202		sockaddr() ([]Sockaddr, error)
   203	}
   204	
   205	const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))
   206	
   207	type anyMessage struct {
   208		Msglen  uint16
   209		Version uint8
   210		Type    uint8
   211	}
   212	
   213	// RouteMessage represents a routing message containing routing
   214	// entries.
   215	//
   216	// Deprecated: Use golang.org/x/net/route instead.
   217	type RouteMessage struct {
   218		Header RtMsghdr
   219		Data   []byte
   220	}
   221	
   222	func (m *RouteMessage) sockaddr() ([]Sockaddr, error) {
   223		var sas [RTAX_MAX]Sockaddr
   224		b := m.Data[:]
   225		family := uint8(AF_UNSPEC)
   226		for i := uint(0); i < RTAX_MAX && len(b) >= minRoutingSockaddrLen; i++ {
   227			if m.Header.Addrs&(1<<i) == 0 {
   228				continue
   229			}
   230			rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
   231			switch rsa.Family {
   232			case AF_LINK:
   233				sa, err := parseSockaddrLink(b)
   234				if err != nil {
   235					return nil, err
   236				}
   237				sas[i] = sa
   238				b = b[rsaAlignOf(int(rsa.Len)):]
   239			case AF_INET, AF_INET6:
   240				sa, err := parseSockaddrInet(b, rsa.Family)
   241				if err != nil {
   242					return nil, err
   243				}
   244				sas[i] = sa
   245				b = b[rsaAlignOf(int(rsa.Len)):]
   246				family = rsa.Family
   247			default:
   248				sa, err := parseNetworkLayerAddr(b, family)
   249				if err != nil {
   250					return nil, err
   251				}
   252				sas[i] = sa
   253				b = b[rsaAlignOf(int(b[0])):]
   254			}
   255		}
   256		return sas[:], nil
   257	}
   258	
   259	// InterfaceMessage represents a routing message containing
   260	// network interface entries.
   261	//
   262	// Deprecated: Use golang.org/x/net/route instead.
   263	type InterfaceMessage struct {
   264		Header IfMsghdr
   265		Data   []byte
   266	}
   267	
   268	func (m *InterfaceMessage) sockaddr() ([]Sockaddr, error) {
   269		var sas [RTAX_MAX]Sockaddr
   270		if m.Header.Addrs&RTA_IFP == 0 {
   271			return nil, nil
   272		}
   273		sa, err := parseSockaddrLink(m.Data[:])
   274		if err != nil {
   275			return nil, err
   276		}
   277		sas[RTAX_IFP] = sa
   278		return sas[:], nil
   279	}
   280	
   281	// InterfaceAddrMessage represents a routing message containing
   282	// network interface address entries.
   283	//
   284	// Deprecated: Use golang.org/x/net/route instead.
   285	type InterfaceAddrMessage struct {
   286		Header IfaMsghdr
   287		Data   []byte
   288	}
   289	
   290	func (m *InterfaceAddrMessage) sockaddr() ([]Sockaddr, error) {
   291		var sas [RTAX_MAX]Sockaddr
   292		b := m.Data[:]
   293		family := uint8(AF_UNSPEC)
   294		for i := uint(0); i < RTAX_MAX && len(b) >= minRoutingSockaddrLen; i++ {
   295			if m.Header.Addrs&(1<<i) == 0 {
   296				continue
   297			}
   298			rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
   299			switch rsa.Family {
   300			case AF_LINK:
   301				sa, err := parseSockaddrLink(b)
   302				if err != nil {
   303					return nil, err
   304				}
   305				sas[i] = sa
   306				b = b[rsaAlignOf(int(rsa.Len)):]
   307			case AF_INET, AF_INET6:
   308				sa, err := parseSockaddrInet(b, rsa.Family)
   309				if err != nil {
   310					return nil, err
   311				}
   312				sas[i] = sa
   313				b = b[rsaAlignOf(int(rsa.Len)):]
   314				family = rsa.Family
   315			default:
   316				sa, err := parseNetworkLayerAddr(b, family)
   317				if err != nil {
   318					return nil, err
   319				}
   320				sas[i] = sa
   321				b = b[rsaAlignOf(int(b[0])):]
   322			}
   323		}
   324		return sas[:], nil
   325	}
   326	
   327	// ParseRoutingMessage parses b as routing messages and returns the
   328	// slice containing the RoutingMessage interfaces.
   329	//
   330	// Deprecated: Use golang.org/x/net/route instead.
   331	func ParseRoutingMessage(b []byte) (msgs []RoutingMessage, err error) {
   332		nmsgs, nskips := 0, 0
   333		for len(b) >= anyMessageLen {
   334			nmsgs++
   335			any := (*anyMessage)(unsafe.Pointer(&b[0]))
   336			if any.Version != RTM_VERSION {
   337				b = b[any.Msglen:]
   338				continue
   339			}
   340			if m := any.toRoutingMessage(b); m == nil {
   341				nskips++
   342			} else {
   343				msgs = append(msgs, m)
   344			}
   345			b = b[any.Msglen:]
   346		}
   347		// We failed to parse any of the messages - version mismatch?
   348		if nmsgs != len(msgs)+nskips {
   349			return nil, EINVAL
   350		}
   351		return msgs, nil
   352	}
   353	
   354	// ParseRoutingSockaddr parses msg's payload as raw sockaddrs and
   355	// returns the slice containing the Sockaddr interfaces.
   356	//
   357	// Deprecated: Use golang.org/x/net/route instead.
   358	func ParseRoutingSockaddr(msg RoutingMessage) ([]Sockaddr, error) {
   359		sas, err := msg.sockaddr()
   360		if err != nil {
   361			return nil, err
   362		}
   363		return sas, nil
   364	}
   365	

View as plain text