libgo/go/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 freebsd netbsd openbsd
   6
   7 // Routing sockets and messages
   8
   9 package syscall
  10
  11 import "unsafe"
  12
  13 // Round the length of a raw sockaddr up to align it properly.
  14 func rsaAlignOf(salen int) int {
  15         salign := sizeofPtr
  16         // NOTE: It seems like 64-bit Darwin kernel still requires 32-bit
  17         // aligned access to BSD subsystem.
  18         if darwinAMD64 {
  19                 salign = 4
  20         }
  21         if salen == 0 {
  22                 return salign
  23         }
  24         return (salen + salign - 1) & ^(salign - 1)
  25 }
  26
  27 // RouteRIB returns routing information base, as known as RIB,
  28 // which consists of network facility information, states and
  29 // parameters.
  30 func RouteRIB(facility, param int) ([]byte, error) {
  31         mib := []_C_int{CTL_NET, AF_ROUTE, 0, 0, _C_int(facility), _C_int(param)}
  32         // Find size.
  33         n := uintptr(0)
  34         if err := sysctl(mib, nil, &n, nil, 0); err != nil {
  35                 return nil, err
  36         }
  37         if n == 0 {
  38                 return nil, nil
  39         }
  40         tab := make([]byte, n)
  41         if err := sysctl(mib, &tab[0], &n, nil, 0); err != nil {
  42                 return nil, err
  43         }
  44         return tab[:n], nil
  45 }
  46
  47 // RoutingMessage represents a routing message.
  48 type RoutingMessage interface {
  49         sockaddr() []Sockaddr
  50 }
  51
  52 const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))
  53
  54 type anyMessage struct {
  55         Msglen  uint16
  56         Version uint8
  57         Type    uint8
  58 }
  59
  60 // RouteMessage represents a routing message containing routing
  61 // entries.
  62 type RouteMessage struct {
  63         Header RtMsghdr
  64         Data   []byte
  65 }
  66
  67 const rtaRtMask = RTA_DST | RTA_GATEWAY | RTA_NETMASK | RTA_GENMASK
  68
  69 func (m *RouteMessage) sockaddr() []Sockaddr {
  70         var (
  71                 af  int
  72                 sas [4]Sockaddr
  73         )
  74         b := m.Data[:]
  75         for i := uint(0); i < RTAX_MAX; i++ {
  76                 if m.Header.Addrs&rtaRtMask&(1<<i) == 0 {
  77                         continue
  78                 }
  79                 rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
  80                 switch i {
  81                 case RTAX_DST, RTAX_GATEWAY:
  82                         sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
  83                         if err != nil {
  84                                 return nil
  85                         }
  86                         if i == RTAX_DST {
  87                                 af = int(rsa.Family)
  88                         }
  89                         sas[i] = sa
  90                 case RTAX_NETMASK, RTAX_GENMASK:
  91                         switch af {
  92                         case AF_INET:
  93                                 rsa4 := (*RawSockaddrInet4)(unsafe.Pointer(&b[0]))
  94                                 sa := new(SockaddrInet4)
  95                                 for j := 0; rsa4.Len > 0 && j < int(rsa4.Len)-int(unsafe.Offsetof(rsa4.Addr)); j++ {
  96                                         sa.Addr[j] = rsa4.Addr[j]
  97                                 }
  98                                 sas[i] = sa
  99                         case AF_INET6:
 100                                 rsa6 := (*RawSockaddrInet6)(unsafe.Pointer(&b[0]))
 101                                 sa := new(SockaddrInet6)
 102                                 for j := 0; rsa6.Len > 0 && j < int(rsa6.Len)-int(unsafe.Offsetof(rsa6.Addr)); j++ {
 103                                         sa.Addr[j] = rsa6.Addr[j]
 104                                 }
 105                                 sas[i] = sa
 106                         }
 107                 }
 108                 b = b[rsaAlignOf(int(rsa.Len)):]
 109         }
 110         return sas[:]
 111 }
 112
 113 // InterfaceMessage represents a routing message containing
 114 // network interface entries.
 115 type InterfaceMessage struct {
 116         Header IfMsghdr
 117         Data   []byte
 118 }
 119
 120 func (m *InterfaceMessage) sockaddr() (sas []Sockaddr) {
 121         if m.Header.Addrs&RTA_IFP == 0 {
 122                 return nil
 123         }
 124         sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(&m.Data[0])))
 125         if err != nil {
 126                 return nil
 127         }
 128         return append(sas, sa)
 129 }
 130
 131 // InterfaceAddrMessage represents a routing message containing
 132 // network interface address entries.
 133 type InterfaceAddrMessage struct {
 134         Header IfaMsghdr
 135         Data   []byte
 136 }
 137
 138 const rtaIfaMask = RTA_IFA | RTA_NETMASK | RTA_BRD
 139
 140 func (m *InterfaceAddrMessage) sockaddr() (sas []Sockaddr) {
 141         if m.Header.Addrs&rtaIfaMask == 0 {
 142                 return nil
 143         }
 144         b := m.Data[:]
 145         for i := uint(0); i < RTAX_MAX; i++ {
 146                 if m.Header.Addrs&rtaIfaMask&(1<<i) == 0 {
 147                         continue
 148                 }
 149                 rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
 150                 switch i {
 151                 case RTAX_IFA:
 152                         sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
 153                         if err != nil {
 154                                 return nil
 155                         }
 156                         sas = append(sas, sa)
 157                 case RTAX_NETMASK:
 158                         if rsa.Family == AF_UNSPEC {
 159                                 rsa.Family = AF_INET // an old fasion, AF_UNSPEC means AF_INET
 160                         }
 161                         sa, err := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
 162                         if err != nil {
 163                                 return nil
 164                         }
 165                         sas = append(sas, sa)
 166                 case RTAX_BRD:
 167                         // nothing to do
 168                 }
 169                 b = b[rsaAlignOf(int(rsa.Len)):]
 170         }
 171         return sas
 172 }
 173
 174 // ParseRoutingMessage parses b as routing messages and returns the
 175 // slice containing the RoutingMessage interfaces.
 176 func ParseRoutingMessage(b []byte) (msgs []RoutingMessage, err error) {
 177         for len(b) >= anyMessageLen {
 178                 any := (*anyMessage)(unsafe.Pointer(&b[0]))
 179                 if any.Version != RTM_VERSION {
 180                         return nil, EINVAL
 181                 }
 182                 msgs = append(msgs, any.toRoutingMessage(b))
 183                 b = b[any.Msglen:]
 184         }
 185         return msgs, nil
 186 }
 187
 188 // ParseRoutingMessage parses msg's payload as raw sockaddrs and
 189 // returns the slice containing the Sockaddr interfaces.
 190 func ParseRoutingSockaddr(msg RoutingMessage) (sas []Sockaddr, err error) {
 191         return append(sas, msg.sockaddr()...), nil
 192 }