libgo/go/syscall/netlink_linux.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 // Netlink sockets and messages
   6
   7 package syscall
   8
   9 import (
  10         "unsafe"
  11 )
  12
  13 // Round the length of a netlink message up to align it properly.
  14 func nlmAlignOf(msglen int) int {
  15         return (msglen + NLMSG_ALIGNTO - 1) & ^(NLMSG_ALIGNTO - 1)
  16 }
  17
  18 // Round the length of a netlink route attribute up to align it
  19 // properly.
  20 func rtaAlignOf(attrlen int) int {
  21         return (attrlen + RTA_ALIGNTO - 1) & ^(RTA_ALIGNTO - 1)
  22 }
  23
  24 // NetlinkRouteRequest represents the request message to receive
  25 // routing and link states from the kernel.
  26 type NetlinkRouteRequest struct {
  27         Header NlMsghdr
  28         Data   RtGenmsg
  29 }
  30
  31 func (rr *NetlinkRouteRequest) toWireFormat() []byte {
  32         b := make([]byte, rr.Header.Len)
  33         b[0] = byte(rr.Header.Len)
  34         b[1] = byte(rr.Header.Len >> 8)
  35         b[2] = byte(rr.Header.Len >> 16)
  36         b[3] = byte(rr.Header.Len >> 24)
  37         b[4] = byte(rr.Header.Type)
  38         b[5] = byte(rr.Header.Type >> 8)
  39         b[6] = byte(rr.Header.Flags)
  40         b[7] = byte(rr.Header.Flags >> 8)
  41         b[8] = byte(rr.Header.Seq)
  42         b[9] = byte(rr.Header.Seq >> 8)
  43         b[10] = byte(rr.Header.Seq >> 16)
  44         b[11] = byte(rr.Header.Seq >> 24)
  45         b[12] = byte(rr.Header.Pid)
  46         b[13] = byte(rr.Header.Pid >> 8)
  47         b[14] = byte(rr.Header.Pid >> 16)
  48         b[15] = byte(rr.Header.Pid >> 24)
  49         b[16] = byte(rr.Data.Family)
  50         return b
  51 }
  52
  53 func newNetlinkRouteRequest(proto, seq, family int) []byte {
  54         rr := &NetlinkRouteRequest{}
  55         rr.Header.Len = uint32(NLMSG_HDRLEN + SizeofRtGenmsg)
  56         rr.Header.Type = uint16(proto)
  57         rr.Header.Flags = NLM_F_DUMP | NLM_F_REQUEST
  58         rr.Header.Seq = uint32(seq)
  59         rr.Data.Family = uint8(family)
  60         return rr.toWireFormat()
  61 }
  62
  63 // NetlinkRIB returns routing information base, as known as RIB,
  64 // which consists of network facility information, states and
  65 // parameters.
  66 func NetlinkRIB(proto, family int) ([]byte, error) {
  67         var (
  68                 lsanl SockaddrNetlink
  69                 tab   []byte
  70         )
  71
  72         s, e := Socket(AF_NETLINK, SOCK_RAW, 0)
  73         if e != nil {
  74                 return nil, e
  75         }
  76         defer Close(s)
  77
  78         lsanl.Family = AF_NETLINK
  79         e = Bind(s, &lsanl)
  80         if e != nil {
  81                 return nil, e
  82         }
  83
  84         seq := 1
  85         wb := newNetlinkRouteRequest(proto, seq, family)
  86         e = Sendto(s, wb, 0, &lsanl)
  87         if e != nil {
  88                 return nil, e
  89         }
  90
  91         for {
  92                 var (
  93                         rb  []byte
  94                         nr  int
  95                         lsa Sockaddr
  96                 )
  97
  98                 rb = make([]byte, Getpagesize())
  99                 nr, _, e = Recvfrom(s, rb, 0)
 100                 if e != nil {
 101                         return nil, e
 102                 }
 103                 if nr < NLMSG_HDRLEN {
 104                         return nil, EINVAL
 105                 }
 106                 rb = rb[:nr]
 107                 tab = append(tab, rb...)
 108
 109                 msgs, _ := ParseNetlinkMessage(rb)
 110                 for _, m := range msgs {
 111                         if lsa, e = Getsockname(s); e != nil {
 112                                 return nil, e
 113                         }
 114                         switch v := lsa.(type) {
 115                         case *SockaddrNetlink:
 116                                 if m.Header.Seq != uint32(seq) || m.Header.Pid != v.Pid {
 117                                         return nil, EINVAL
 118                                 }
 119                         default:
 120                                 return nil, EINVAL
 121                         }
 122                         if m.Header.Type == NLMSG_DONE {
 123                                 goto done
 124                         }
 125                         if m.Header.Type == NLMSG_ERROR {
 126                                 return nil, EINVAL
 127                         }
 128                 }
 129         }
 130
 131 done:
 132         return tab, nil
 133 }
 134
 135 // NetlinkMessage represents the netlink message.
 136 type NetlinkMessage struct {
 137         Header NlMsghdr
 138         Data   []byte
 139 }
 140
 141 // ParseNetlinkMessage parses buf as netlink messages and returns
 142 // the slice containing the NetlinkMessage structs.
 143 func ParseNetlinkMessage(buf []byte) ([]NetlinkMessage, error) {
 144         var (
 145                 h    *NlMsghdr
 146                 dbuf []byte
 147                 dlen int
 148                 e    error
 149                 msgs []NetlinkMessage
 150         )
 151
 152         for len(buf) >= NLMSG_HDRLEN {
 153                 h, dbuf, dlen, e = netlinkMessageHeaderAndData(buf)
 154                 if e != nil {
 155                         break
 156                 }
 157                 m := NetlinkMessage{}
 158                 m.Header = *h
 159                 m.Data = dbuf[:int(h.Len)-NLMSG_HDRLEN]
 160                 msgs = append(msgs, m)
 161                 buf = buf[dlen:]
 162         }
 163
 164         return msgs, e
 165 }
 166
 167 func netlinkMessageHeaderAndData(buf []byte) (*NlMsghdr, []byte, int, error) {
 168         h := (*NlMsghdr)(unsafe.Pointer(&buf[0]))
 169         if int(h.Len) < NLMSG_HDRLEN || int(h.Len) > len(buf) {
 170                 return nil, nil, 0, EINVAL
 171         }
 172         return h, buf[NLMSG_HDRLEN:], nlmAlignOf(int(h.Len)), nil
 173 }
 174
 175 // NetlinkRouteAttr represents the netlink route attribute.
 176 type NetlinkRouteAttr struct {
 177         Attr  RtAttr
 178         Value []byte
 179 }
 180
 181 // ParseNetlinkRouteAttr parses msg's payload as netlink route
 182 // attributes and returns the slice containing the NetlinkRouteAttr
 183 // structs.
 184 func ParseNetlinkRouteAttr(msg *NetlinkMessage) ([]NetlinkRouteAttr, error) {
 185         var (
 186                 buf   []byte
 187                 a     *RtAttr
 188                 alen  int
 189                 vbuf  []byte
 190                 e     error
 191                 attrs []NetlinkRouteAttr
 192         )
 193
 194         switch msg.Header.Type {
 195         case RTM_NEWLINK, RTM_DELLINK:
 196                 buf = msg.Data[SizeofIfInfomsg:]
 197         case RTM_NEWADDR, RTM_DELADDR:
 198                 buf = msg.Data[SizeofIfAddrmsg:]
 199         case RTM_NEWROUTE, RTM_DELROUTE:
 200                 buf = msg.Data[SizeofRtMsg:]
 201         default:
 202                 return nil, EINVAL
 203         }
 204
 205         for len(buf) >= SizeofRtAttr {
 206                 a, vbuf, alen, e = netlinkRouteAttrAndValue(buf)
 207                 if e != nil {
 208                         break
 209                 }
 210                 ra := NetlinkRouteAttr{}
 211                 ra.Attr = *a
 212                 ra.Value = vbuf[:int(a.Len)-SizeofRtAttr]
 213                 attrs = append(attrs, ra)
 214                 buf = buf[alen:]
 215         }
 216
 217         return attrs, nil
 218 }
 219
 220 func netlinkRouteAttrAndValue(buf []byte) (*RtAttr, []byte, int, error) {
 221         h := (*RtAttr)(unsafe.Pointer(&buf[0]))
 222         if int(h.Len) < SizeofRtAttr || int(h.Len) > len(buf) {
 223                 return nil, nil, 0, EINVAL
 224         }
 225         return h, buf[SizeofRtAttr:], rtaAlignOf(int(h.Len)), nil
 226 }