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                 ifat []Addr
 110                 msgs []syscall.NetlinkMessage
 111         )
 112
 113         tab, e = syscall.NetlinkRIB(syscall.RTM_GETADDR, syscall.AF_UNSPEC)
 114         if e != 0 {
 115                 return nil, os.NewSyscallError("netlink rib", e)
 116         }
 117
 118         msgs, e = syscall.ParseNetlinkMessage(tab)
 119         if e != 0 {
 120                 return nil, os.NewSyscallError("netlink message", e)
 121         }
 122
 123         ifat, err = addrTable(msgs, ifindex)
 124         if err != nil {
 125                 return nil, err
 126         }
 127
 128         return ifat, nil
 129 }
 130
 131 func addrTable(msgs []syscall.NetlinkMessage, ifindex int) ([]Addr, os.Error) {
 132         var ifat []Addr
 133
 134         for _, m := range msgs {
 135                 switch m.Header.Type {
 136                 case syscall.NLMSG_DONE:
 137                         goto done
 138                 case syscall.RTM_NEWADDR:
 139                         ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
 140                         if ifindex == 0 || ifindex == int(ifam.Index) {
 141                                 attrs, e := syscall.ParseNetlinkRouteAttr(&m)
 142                                 if e != 0 {
 143                                         return nil, os.NewSyscallError("netlink routeattr", e)
 144                                 }
 145                                 ifat = append(ifat, newAddr(attrs, int(ifam.Family))...)
 146                         }
 147                 }
 148         }
 149
 150 done:
 151         return ifat, nil
 152 }
 153
 154 func newAddr(attrs []syscall.NetlinkRouteAttr, family int) []Addr {
 155         var ifat []Addr
 156
 157         for _, a := range attrs {
 158                 switch a.Attr.Type {
 159                 case syscall.IFA_ADDRESS:
 160                         switch family {
 161                         case syscall.AF_INET:
 162                                 ifa := &IPAddr{IP: IPv4(a.Value[0], a.Value[1], a.Value[2], a.Value[3])}
 163                                 ifat = append(ifat, ifa.toAddr())
 164                         case syscall.AF_INET6:
 165                                 ifa := &IPAddr{IP: make(IP, IPv6len)}
 166                                 copy(ifa.IP, a.Value[:])
 167                                 ifat = append(ifat, ifa.toAddr())
 168                         }
 169                 }
 170         }
 171
 172         return ifat
 173 }
 174
 175 // If the ifindex is zero, interfaceMulticastAddrTable returns
 176 // addresses for all network interfaces.  Otherwise it returns
 177 // addresses for a specific interface.
 178 func interfaceMulticastAddrTable(ifindex int) ([]Addr, os.Error) {
 179         var (
 180                 ifi *Interface
 181                 err os.Error
 182         )
 183
 184         if ifindex > 0 {
 185                 ifi, err = InterfaceByIndex(ifindex)
 186                 if err != nil {
 187                         return nil, err
 188                 }
 189         }
 190
 191         ifmat4 := parseProcNetIGMP(ifi)
 192         ifmat6 := parseProcNetIGMP6(ifi)
 193
 194         return append(ifmat4, ifmat6...), nil
 195 }
 196
 197 func parseProcNetIGMP(ifi *Interface) []Addr {
 198         var (
 199                 ifmat []Addr
 200                 name  string
 201         )
 202
 203         fd, err := open("/proc/net/igmp")
 204         if err != nil {
 205                 return nil
 206         }
 207         defer fd.close()
 208
 209         fd.readLine() // skip first line
 210         b := make([]byte, IPv4len)
 211         for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
 212                 f := getFields(l)
 213                 switch len(f) {
 214                 case 4:
 215                         if ifi == nil || name == ifi.Name {
 216                                 fmt.Sscanf(f[0], "%08x", &b)
 217                                 ifma := IPAddr{IP: IPv4(b[3], b[2], b[1], b[0])}
 218                                 ifmat = append(ifmat, ifma.toAddr())
 219                         }
 220                 case 5:
 221                         name = f[1]
 222                 }
 223         }
 224
 225         return ifmat
 226 }
 227
 228 func parseProcNetIGMP6(ifi *Interface) []Addr {
 229         var ifmat []Addr
 230
 231         fd, err := open("/proc/net/igmp6")
 232         if err != nil {
 233                 return nil
 234         }
 235         defer fd.close()
 236
 237         b := make([]byte, IPv6len)
 238         for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
 239                 f := getFields(l)
 240                 if ifi == nil || f[1] == ifi.Name {
 241                         fmt.Sscanf(f[2], "%32x", &b)
 242                         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]}}
 243                         ifmat = append(ifmat, ifma.toAddr())
 244
 245                 }
 246         }
 247
 248         return ifmat
 249 }