OSDN Git Service

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