2011-06-03 12:35:42 -06:00
|
|
|
// Copyright 2011 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2011-12-21 03:44:47 -07:00
|
|
|
// +build darwin freebsd netbsd openbsd
|
build: add build comments to core packages
The go/build package already recognizes
system-specific file names like
mycode_darwin.go
mycode_darwin_386.go
mycode_386.s
However, it is also common to write files that
apply to multiple architectures, so a recent CL added
to go/build the ability to process comments
listing a set of conditions for building. For example:
// +build darwin freebsd openbsd/386
says that this file should be compiled only on
OS X, FreeBSD, or 32-bit x86 OpenBSD systems.
These conventions are not yet documented
(hence this long CL description).
This CL adds build comments to the multi-system
files in the core library, a step toward making it
possible to use go/build to build them.
With this change go/build can handle crypto/rand,
exec, net, path/filepath, os/user, and time.
os and syscall need additional adjustments.
R=golang-dev, r, gri, r, gustavo
CC=golang-dev
https://golang.org/cl/5011046
2011-09-15 14:48:57 -06:00
|
|
|
|
2011-06-03 12:35:42 -06:00
|
|
|
// Network interface identification for BSD variants
|
|
|
|
|
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
|
|
|
"os"
|
|
|
|
"syscall"
|
2011-06-07 14:06:36 -06:00
|
|
|
"unsafe"
|
2011-06-03 12:35:42 -06:00
|
|
|
)
|
|
|
|
|
|
|
|
// If the ifindex is zero, interfaceTable returns mappings of all
|
2012-02-01 17:19:36 -07:00
|
|
|
// network interfaces. Otherwise it returns a mapping of a specific
|
2011-06-03 12:35:42 -06:00
|
|
|
// interface.
|
2011-11-01 20:05:34 -06:00
|
|
|
func interfaceTable(ifindex int) ([]Interface, error) {
|
2011-12-21 05:39:00 -07:00
|
|
|
var ift []Interface
|
|
|
|
|
|
|
|
tab, err := syscall.RouteRIB(syscall.NET_RT_IFLIST, ifindex)
|
|
|
|
if err != nil {
|
|
|
|
return nil, os.NewSyscallError("route rib", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
msgs, err := syscall.ParseRoutingMessage(tab)
|
|
|
|
if err != nil {
|
|
|
|
return nil, os.NewSyscallError("route message", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, m := range msgs {
|
|
|
|
switch v := m.(type) {
|
|
|
|
case *syscall.InterfaceMessage:
|
|
|
|
if ifindex == 0 || ifindex == int(v.Header.Index) {
|
|
|
|
ifi, err := newLink(v)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
ift = append(ift, ifi...)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ift, nil
|
|
|
|
}
|
|
|
|
|
2011-11-01 20:05:34 -06:00
|
|
|
func newLink(m *syscall.InterfaceMessage) ([]Interface, error) {
|
2011-06-03 12:35:42 -06:00
|
|
|
var ift []Interface
|
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
sas, err := syscall.ParseRoutingSockaddr(m)
|
|
|
|
if err != nil {
|
|
|
|
return nil, os.NewSyscallError("route sockaddr", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, s := range sas {
|
|
|
|
switch v := s.(type) {
|
|
|
|
case *syscall.SockaddrDatalink:
|
2011-06-07 14:06:36 -06:00
|
|
|
// NOTE: SockaddrDatalink.Data is minimum work area,
|
|
|
|
// can be larger.
|
|
|
|
m.Data = m.Data[unsafe.Offsetof(v.Data):]
|
2011-06-14 11:32:52 -06:00
|
|
|
ifi := Interface{Index: int(m.Header.Index), Flags: linkFlags(m.Header.Flags)}
|
2011-06-03 12:35:42 -06:00
|
|
|
var name [syscall.IFNAMSIZ]byte
|
|
|
|
for i := 0; i < int(v.Nlen); i++ {
|
2011-06-07 14:06:36 -06:00
|
|
|
name[i] = byte(m.Data[i])
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
ifi.Name = string(name[:v.Nlen])
|
|
|
|
ifi.MTU = int(m.Header.Data.Mtu)
|
|
|
|
addr := make([]byte, v.Alen)
|
|
|
|
for i := 0; i < int(v.Alen); i++ {
|
2011-06-07 14:06:36 -06:00
|
|
|
addr[i] = byte(m.Data[int(v.Nlen)+i])
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
ifi.HardwareAddr = addr[:v.Alen]
|
|
|
|
ift = append(ift, ifi)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ift, nil
|
|
|
|
}
|
|
|
|
|
2011-06-14 11:32:52 -06:00
|
|
|
func linkFlags(rawFlags int32) Flags {
|
|
|
|
var f Flags
|
|
|
|
if rawFlags&syscall.IFF_UP != 0 {
|
|
|
|
f |= FlagUp
|
|
|
|
}
|
|
|
|
if rawFlags&syscall.IFF_BROADCAST != 0 {
|
|
|
|
f |= FlagBroadcast
|
|
|
|
}
|
|
|
|
if rawFlags&syscall.IFF_LOOPBACK != 0 {
|
|
|
|
f |= FlagLoopback
|
|
|
|
}
|
|
|
|
if rawFlags&syscall.IFF_POINTOPOINT != 0 {
|
|
|
|
f |= FlagPointToPoint
|
|
|
|
}
|
|
|
|
if rawFlags&syscall.IFF_MULTICAST != 0 {
|
|
|
|
f |= FlagMulticast
|
|
|
|
}
|
|
|
|
return f
|
|
|
|
}
|
|
|
|
|
2011-06-03 12:35:42 -06:00
|
|
|
// If the ifindex is zero, interfaceAddrTable returns addresses
|
|
|
|
// for all network interfaces. Otherwise it returns addresses
|
|
|
|
// for a specific interface.
|
2011-11-01 20:05:34 -06:00
|
|
|
func interfaceAddrTable(ifindex int) ([]Addr, error) {
|
2011-12-21 05:39:00 -07:00
|
|
|
var ifat []Addr
|
|
|
|
|
|
|
|
tab, err := syscall.RouteRIB(syscall.NET_RT_IFLIST, ifindex)
|
|
|
|
if err != nil {
|
|
|
|
return nil, os.NewSyscallError("route rib", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
msgs, err := syscall.ParseRoutingMessage(tab)
|
|
|
|
if err != nil {
|
|
|
|
return nil, os.NewSyscallError("route message", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, m := range msgs {
|
|
|
|
switch v := m.(type) {
|
|
|
|
case *syscall.InterfaceAddrMessage:
|
|
|
|
if ifindex == 0 || ifindex == int(v.Header.Index) {
|
|
|
|
ifa, err := newAddr(v)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2011-12-21 05:39:00 -07:00
|
|
|
ifat = append(ifat, ifa)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ifat, nil
|
|
|
|
}
|
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
func newAddr(m *syscall.InterfaceAddrMessage) (Addr, error) {
|
|
|
|
ifa := &IPNet{}
|
2011-06-03 12:35:42 -06:00
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
sas, err := syscall.ParseRoutingSockaddr(m)
|
|
|
|
if err != nil {
|
|
|
|
return nil, os.NewSyscallError("route sockaddr", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
for i, s := range sas {
|
2011-06-03 12:35:42 -06:00
|
|
|
switch v := s.(type) {
|
|
|
|
case *syscall.SockaddrInet4:
|
2011-12-21 05:39:00 -07:00
|
|
|
switch i {
|
|
|
|
case 0:
|
|
|
|
ifa.Mask = IPv4Mask(v.Addr[0], v.Addr[1], v.Addr[2], v.Addr[3])
|
|
|
|
case 1:
|
|
|
|
ifa.IP = IPv4(v.Addr[0], v.Addr[1], v.Addr[2], v.Addr[3])
|
|
|
|
}
|
2011-06-03 12:35:42 -06:00
|
|
|
case *syscall.SockaddrInet6:
|
2011-12-21 05:39:00 -07:00
|
|
|
switch i {
|
|
|
|
case 0:
|
|
|
|
ifa.Mask = make(IPMask, IPv6len)
|
|
|
|
copy(ifa.Mask, v.Addr[:])
|
|
|
|
case 1:
|
|
|
|
ifa.IP = make(IP, IPv6len)
|
|
|
|
copy(ifa.IP, v.Addr[:])
|
|
|
|
// NOTE: KAME based IPv6 protcol stack usually embeds
|
|
|
|
// the interface index in the interface-local or link-
|
|
|
|
// local address as the kernel-internal form.
|
|
|
|
if ifa.IP.IsLinkLocalUnicast() {
|
|
|
|
// remove embedded scope zone ID
|
|
|
|
ifa.IP[2], ifa.IP[3] = 0, 0
|
|
|
|
}
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
return ifa, nil
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|