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.
|
|
|
|
|
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
2013-02-25 07:05:40 -07:00
|
|
|
"reflect"
|
2011-06-03 12:35:42 -06:00
|
|
|
"testing"
|
|
|
|
)
|
|
|
|
|
2013-02-25 07:05:40 -07:00
|
|
|
// loopbackInterface returns an available logical network interface
|
|
|
|
// for loopback tests. It returns nil if no suitable interface is
|
|
|
|
// found.
|
2013-02-21 09:19:04 -07:00
|
|
|
func loopbackInterface() *Interface {
|
|
|
|
ift, err := Interfaces()
|
|
|
|
if err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
for _, ifi := range ift {
|
|
|
|
if ifi.Flags&FlagLoopback != 0 && ifi.Flags&FlagUp != 0 {
|
|
|
|
return &ifi
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
// ipv6LinkLocalUnicastAddr returns an IPv6 link-local unicast address
|
|
|
|
// on the given network interface for tests. It returns "" if no
|
|
|
|
// suitable address is found.
|
|
|
|
func ipv6LinkLocalUnicastAddr(ifi *Interface) string {
|
|
|
|
if ifi == nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
ifat, err := ifi.Addrs()
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
for _, ifa := range ifat {
|
|
|
|
switch ifa := ifa.(type) {
|
|
|
|
case *IPAddr:
|
|
|
|
if ifa.IP.To4() == nil && ifa.IP.IsLinkLocalUnicast() {
|
|
|
|
return ifa.IP.String()
|
|
|
|
}
|
|
|
|
case *IPNet:
|
|
|
|
if ifa.IP.To4() == nil && ifa.IP.IsLinkLocalUnicast() {
|
|
|
|
return ifa.IP.String()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2011-06-03 12:35:42 -06:00
|
|
|
func TestInterfaces(t *testing.T) {
|
|
|
|
ift, err := Interfaces()
|
|
|
|
if err != nil {
|
2011-12-21 05:39:00 -07:00
|
|
|
t.Fatalf("Interfaces failed: %v", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
2012-07-21 10:49:58 -06:00
|
|
|
t.Logf("table: len/cap = %v/%v", len(ift), cap(ift))
|
2011-06-03 12:35:42 -06:00
|
|
|
|
|
|
|
for _, ifi := range ift {
|
|
|
|
ifxi, err := InterfaceByIndex(ifi.Index)
|
|
|
|
if err != nil {
|
2013-02-21 09:19:04 -07:00
|
|
|
t.Fatalf("InterfaceByIndex(%v) failed: %v", ifi.Index, err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
2013-02-25 07:05:40 -07:00
|
|
|
if !reflect.DeepEqual(ifxi, &ifi) {
|
|
|
|
t.Fatalf("InterfaceByIndex(%v) = %v, want %v", ifi.Index, ifxi, ifi)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
ifxn, err := InterfaceByName(ifi.Name)
|
|
|
|
if err != nil {
|
2012-02-22 14:26:31 -07:00
|
|
|
t.Fatalf("InterfaceByName(%q) failed: %v", ifi.Name, err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
2013-02-25 07:05:40 -07:00
|
|
|
if !reflect.DeepEqual(ifxn, &ifi) {
|
|
|
|
t.Fatalf("InterfaceByName(%q) = %v, want %v", ifi.Name, ifxn, ifi)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
2012-07-21 10:49:58 -06:00
|
|
|
t.Logf("%q: flags %q, ifindex %v, mtu %v", ifi.Name, ifi.Flags.String(), ifi.Index, ifi.MTU)
|
2011-06-14 11:32:52 -06:00
|
|
|
t.Logf("\thardware address %q", ifi.HardwareAddr.String())
|
2011-12-21 05:39:00 -07:00
|
|
|
testInterfaceAddrs(t, &ifi)
|
|
|
|
testInterfaceMulticastAddrs(t, &ifi)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestInterfaceAddrs(t *testing.T) {
|
|
|
|
ifat, err := InterfaceAddrs()
|
|
|
|
if err != nil {
|
2011-12-21 05:39:00 -07:00
|
|
|
t.Fatalf("InterfaceAddrs failed: %v", err)
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
2012-07-21 10:49:58 -06:00
|
|
|
t.Logf("table: len/cap = %v/%v", len(ifat), cap(ifat))
|
2011-12-21 05:39:00 -07:00
|
|
|
testAddrs(t, ifat)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testInterfaceAddrs(t *testing.T, ifi *Interface) {
|
|
|
|
ifat, err := ifi.Addrs()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Interface.Addrs failed: %v", err)
|
|
|
|
}
|
|
|
|
testAddrs(t, ifat)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testInterfaceMulticastAddrs(t *testing.T, ifi *Interface) {
|
|
|
|
ifmat, err := ifi.MulticastAddrs()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Interface.MulticastAddrs failed: %v", err)
|
|
|
|
}
|
|
|
|
testMulticastAddrs(t, ifmat)
|
|
|
|
}
|
2011-06-03 12:35:42 -06:00
|
|
|
|
2011-12-21 05:39:00 -07:00
|
|
|
func testAddrs(t *testing.T, ifat []Addr) {
|
2011-06-03 12:35:42 -06:00
|
|
|
for _, ifa := range ifat {
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
switch ifa := ifa.(type) {
|
2013-08-06 09:25:23 -06:00
|
|
|
case *IPAddr:
|
2013-08-24 17:44:31 -06:00
|
|
|
if ifa == nil || ifa.IP == nil {
|
|
|
|
t.Errorf("\tunexpected value: %v, %v", ifa, ifa.IP)
|
2013-01-22 15:11:22 -07:00
|
|
|
} else {
|
|
|
|
t.Logf("\tinterface address %q", ifa.String())
|
|
|
|
}
|
2013-08-06 09:25:23 -06:00
|
|
|
case *IPNet:
|
2013-08-24 17:44:31 -06:00
|
|
|
if ifa == nil || ifa.IP == nil || ifa.Mask == nil {
|
|
|
|
t.Errorf("\tunexpected value: %v, %v, %v", ifa, ifa.IP, ifa.Mask)
|
2013-08-06 09:25:23 -06:00
|
|
|
} else {
|
|
|
|
_, prefixLen := ifa.Mask.Size()
|
|
|
|
if ifa.IP.To4() != nil && prefixLen != 8*IPv4len || ifa.IP.To16() != nil && ifa.IP.To4() == nil && prefixLen != 8*IPv6len {
|
|
|
|
t.Errorf("\tunexpected value: %v, %v, %v, %v", ifa, ifa.IP, ifa.Mask, prefixLen)
|
|
|
|
} else {
|
|
|
|
t.Logf("\tinterface address %q", ifa.String())
|
|
|
|
}
|
|
|
|
}
|
2011-12-21 05:39:00 -07:00
|
|
|
default:
|
|
|
|
t.Errorf("\tunexpected type: %T", ifa)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func testMulticastAddrs(t *testing.T, ifmat []Addr) {
|
|
|
|
for _, ifma := range ifmat {
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
switch ifma := ifma.(type) {
|
2011-12-21 05:39:00 -07:00
|
|
|
case *IPAddr:
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
if ifma == nil {
|
2013-01-22 15:11:22 -07:00
|
|
|
t.Errorf("\tunexpected value: %v", ifma)
|
|
|
|
} else {
|
|
|
|
t.Logf("\tjoined group address %q", ifma.String())
|
|
|
|
}
|
2011-12-21 05:39:00 -07:00
|
|
|
default:
|
|
|
|
t.Errorf("\tunexpected type: %T", ifma)
|
|
|
|
}
|
2011-06-03 12:35:42 -06:00
|
|
|
}
|
|
|
|
}
|
2013-02-21 09:19:04 -07:00
|
|
|
|
|
|
|
func BenchmarkInterfaces(b *testing.B) {
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
if _, err := Interfaces(); err != nil {
|
|
|
|
b.Fatalf("Interfaces failed: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkInterfaceByIndex(b *testing.B) {
|
|
|
|
ifi := loopbackInterface()
|
|
|
|
if ifi == nil {
|
2013-02-25 07:05:40 -07:00
|
|
|
b.Skip("loopback interface not found")
|
2013-02-21 09:19:04 -07:00
|
|
|
}
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
if _, err := InterfaceByIndex(ifi.Index); err != nil {
|
|
|
|
b.Fatalf("InterfaceByIndex failed: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkInterfaceByName(b *testing.B) {
|
|
|
|
ifi := loopbackInterface()
|
|
|
|
if ifi == nil {
|
2013-02-25 07:05:40 -07:00
|
|
|
b.Skip("loopback interface not found")
|
2013-02-21 09:19:04 -07:00
|
|
|
}
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
if _, err := InterfaceByName(ifi.Name); err != nil {
|
|
|
|
b.Fatalf("InterfaceByName failed: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkInterfaceAddrs(b *testing.B) {
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
if _, err := InterfaceAddrs(); err != nil {
|
|
|
|
b.Fatalf("InterfaceAddrs failed: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkInterfacesAndAddrs(b *testing.B) {
|
|
|
|
ifi := loopbackInterface()
|
|
|
|
if ifi == nil {
|
2013-02-25 07:05:40 -07:00
|
|
|
b.Skip("loopback interface not found")
|
2013-02-21 09:19:04 -07:00
|
|
|
}
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
if _, err := ifi.Addrs(); err != nil {
|
|
|
|
b.Fatalf("Interface.Addrs failed: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkInterfacesAndMulticastAddrs(b *testing.B) {
|
|
|
|
ifi := loopbackInterface()
|
|
|
|
if ifi == nil {
|
2013-02-25 07:05:40 -07:00
|
|
|
b.Skip("loopback interface not found")
|
2013-02-21 09:19:04 -07:00
|
|
|
}
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
if _, err := ifi.MulticastAddrs(); err != nil {
|
|
|
|
b.Fatalf("Interface.MulticastAddrs failed: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|