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 }