OSDN Git Service

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