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