OSDN Git Service

Update Go library to r60.
[pf3gnuchains/gcc-fork.git] / libgo / go / net / interface_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 // Network interface identification for Linux
6
7 package net
8
9 import (
10         "fmt"
11         "os"
12         "syscall"
13         "unsafe"
14 )
15
16 // If the ifindex is zero, interfaceTable returns mappings of all
17 // network interfaces.  Otheriwse it returns a mapping of a specific
18 // interface.
19 func interfaceTable(ifindex int) ([]Interface, os.Error) {
20         var (
21                 ift  []Interface
22                 tab  []byte
23                 msgs []syscall.NetlinkMessage
24                 e    int
25         )
26
27         tab, e = syscall.NetlinkRIB(syscall.RTM_GETLINK, syscall.AF_UNSPEC)
28         if e != 0 {
29                 return nil, os.NewSyscallError("netlink rib", e)
30         }
31
32         msgs, e = syscall.ParseNetlinkMessage(tab)
33         if e != 0 {
34                 return nil, os.NewSyscallError("netlink message", e)
35         }
36
37         for _, m := range msgs {
38                 switch m.Header.Type {
39                 case syscall.NLMSG_DONE:
40                         goto done
41                 case syscall.RTM_NEWLINK:
42                         ifim := (*syscall.IfInfomsg)(unsafe.Pointer(&m.Data[0]))
43                         if ifindex == 0 || ifindex == int(ifim.Index) {
44                                 attrs, e := syscall.ParseNetlinkRouteAttr(&m)
45                                 if e != 0 {
46                                         return nil, os.NewSyscallError("netlink routeattr", e)
47                                 }
48                                 ifi := newLink(attrs, ifim)
49                                 ift = append(ift, ifi)
50                         }
51                 }
52         }
53
54 done:
55         return ift, nil
56 }
57
58 func newLink(attrs []syscall.NetlinkRouteAttr, ifim *syscall.IfInfomsg) Interface {
59         ifi := Interface{Index: int(ifim.Index), Flags: linkFlags(ifim.Flags)}
60         for _, a := range attrs {
61                 switch a.Attr.Type {
62                 case syscall.IFLA_ADDRESS:
63                         var nonzero bool
64                         for _, b := range a.Value {
65                                 if b != 0 {
66                                         nonzero = true
67                                 }
68                         }
69                         if nonzero {
70                                 ifi.HardwareAddr = a.Value[:]
71                         }
72                 case syscall.IFLA_IFNAME:
73                         ifi.Name = string(a.Value[:len(a.Value)-1])
74                 case syscall.IFLA_MTU:
75                         ifi.MTU = int(uint32(a.Value[3])<<24 | uint32(a.Value[2])<<16 | uint32(a.Value[1])<<8 | uint32(a.Value[0]))
76                 }
77         }
78         return ifi
79 }
80
81 func linkFlags(rawFlags uint32) Flags {
82         var f Flags
83         if rawFlags&syscall.IFF_UP != 0 {
84                 f |= FlagUp
85         }
86         if rawFlags&syscall.IFF_BROADCAST != 0 {
87                 f |= FlagBroadcast
88         }
89         if rawFlags&syscall.IFF_LOOPBACK != 0 {
90                 f |= FlagLoopback
91         }
92         if rawFlags&syscall.IFF_POINTOPOINT != 0 {
93                 f |= FlagPointToPoint
94         }
95         if rawFlags&syscall.IFF_MULTICAST != 0 {
96                 f |= FlagMulticast
97         }
98         return f
99 }
100
101 // If the ifindex is zero, interfaceAddrTable returns addresses
102 // for all network interfaces.  Otherwise it returns addresses
103 // for a specific interface.
104 func interfaceAddrTable(ifindex int) ([]Addr, os.Error) {
105         var (
106                 tab   []byte
107                 e     int
108                 err   os.Error
109                 ifat4 []Addr
110                 ifat6 []Addr
111                 msgs4 []syscall.NetlinkMessage
112                 msgs6 []syscall.NetlinkMessage
113         )
114
115         tab, e = syscall.NetlinkRIB(syscall.RTM_GETADDR, syscall.AF_INET)
116         if e != 0 {
117                 return nil, os.NewSyscallError("netlink rib", e)
118         }
119         msgs4, e = syscall.ParseNetlinkMessage(tab)
120         if e != 0 {
121                 return nil, os.NewSyscallError("netlink message", e)
122         }
123         ifat4, err = addrTable(msgs4, ifindex)
124         if err != nil {
125                 return nil, err
126         }
127
128         tab, e = syscall.NetlinkRIB(syscall.RTM_GETADDR, syscall.AF_INET6)
129         if e != 0 {
130                 return nil, os.NewSyscallError("netlink rib", e)
131         }
132         msgs6, e = syscall.ParseNetlinkMessage(tab)
133         if e != 0 {
134                 return nil, os.NewSyscallError("netlink message", e)
135         }
136         ifat6, err = addrTable(msgs6, ifindex)
137         if err != nil {
138                 return nil, err
139         }
140
141         return append(ifat4, ifat6...), nil
142 }
143
144 func addrTable(msgs []syscall.NetlinkMessage, ifindex int) ([]Addr, os.Error) {
145         var ifat []Addr
146
147         for _, m := range msgs {
148                 switch m.Header.Type {
149                 case syscall.NLMSG_DONE:
150                         goto done
151                 case syscall.RTM_NEWADDR:
152                         ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
153                         if ifindex == 0 || ifindex == int(ifam.Index) {
154                                 attrs, e := syscall.ParseNetlinkRouteAttr(&m)
155                                 if e != 0 {
156                                         return nil, os.NewSyscallError("netlink routeattr", e)
157                                 }
158                                 ifat = append(ifat, newAddr(attrs, int(ifam.Family))...)
159                         }
160                 }
161         }
162
163 done:
164         return ifat, nil
165 }
166
167 func newAddr(attrs []syscall.NetlinkRouteAttr, family int) []Addr {
168         var ifat []Addr
169
170         for _, a := range attrs {
171                 switch a.Attr.Type {
172                 case syscall.IFA_ADDRESS:
173                         switch family {
174                         case syscall.AF_INET:
175                                 ifa := &IPAddr{IP: IPv4(a.Value[0], a.Value[1], a.Value[2], a.Value[3])}
176                                 ifat = append(ifat, ifa.toAddr())
177                         case syscall.AF_INET6:
178                                 ifa := &IPAddr{IP: make(IP, IPv6len)}
179                                 copy(ifa.IP, a.Value[:])
180                                 ifat = append(ifat, ifa.toAddr())
181                         }
182                 }
183         }
184
185         return ifat
186 }
187
188 // If the ifindex is zero, interfaceMulticastAddrTable returns
189 // addresses for all network interfaces.  Otherwise it returns
190 // addresses for a specific interface.
191 func interfaceMulticastAddrTable(ifindex int) ([]Addr, os.Error) {
192         var (
193                 ifi *Interface
194                 err os.Error
195         )
196
197         if ifindex > 0 {
198                 ifi, err = InterfaceByIndex(ifindex)
199                 if err != nil {
200                         return nil, err
201                 }
202         }
203
204         ifmat4 := parseProcNetIGMP(ifi)
205         ifmat6 := parseProcNetIGMP6(ifi)
206
207         return append(ifmat4, ifmat6...), nil
208 }
209
210 func parseProcNetIGMP(ifi *Interface) []Addr {
211         var (
212                 ifmat []Addr
213                 name  string
214         )
215
216         fd, err := open("/proc/net/igmp")
217         if err != nil {
218                 return nil
219         }
220         defer fd.close()
221
222         fd.readLine() // skip first line
223         b := make([]byte, IPv4len)
224         for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
225                 f := getFields(l)
226                 switch len(f) {
227                 case 4:
228                         if ifi == nil || name == ifi.Name {
229                                 fmt.Sscanf(f[0], "%08x", &b)
230                                 ifma := IPAddr{IP: IPv4(b[3], b[2], b[1], b[0])}
231                                 ifmat = append(ifmat, ifma.toAddr())
232                         }
233                 case 5:
234                         name = f[1]
235                 }
236         }
237
238         return ifmat
239 }
240
241 func parseProcNetIGMP6(ifi *Interface) []Addr {
242         var ifmat []Addr
243
244         fd, err := open("/proc/net/igmp6")
245         if err != nil {
246                 return nil
247         }
248         defer fd.close()
249
250         b := make([]byte, IPv6len)
251         for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
252                 f := getFields(l)
253                 if ifi == nil || f[1] == ifi.Name {
254                         fmt.Sscanf(f[2], "%32x", &b)
255                         ifma := IPAddr{IP: IP{b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15]}}
256                         ifmat = append(ifmat, ifma.toAddr())
257
258                 }
259         }
260
261         return ifmat
262 }