OSDN Git Service

libgo: Update to weekly.2011-11-18.
[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         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 }