OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [syscall/] [netlink_linux.go] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// 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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.