multiaddr update: recognize link local ip6

Godeps/Godeps.json

@@ -135,7 +135,7 @@
 		},
 		{
 			"ImportPath": "github.com/jbenet/go-multiaddr-net",
-			"Rev": "2b8f35303d2855c79f9f3f9b3584338a1ff7edbd"
+			"Rev": "04044c2289504304472715d827a8f564fa3759a8"
 		},
 		{
 			"ImportPath": "github.com/jbenet/go-multihash",

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/.travis.yml

+language: go
+
+go:
+  - 1.3
+  - release
+  - tip
+
+script:
+  - make test
+
+env: TEST_VERBOSE=1

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/Makefile

@@ -12,5 +12,8 @@ vendor: godep
 install: dep
 	cd multiaddr && go install
 
+test:
+	go test ./...
+
 dep:
 	cd multiaddr && go get ./...

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/convert.go

@@ -112,13 +112,13 @@ func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
 	}
 
 	switch network {
-	case "tcp":
+	case "tcp", "tcp4", "tcp6":
 		return net.ResolveTCPAddr(network, host)
-	case "udp":
+	case "udp", "udp4", "udp6":
 		return net.ResolveUDPAddr(network, host)
-	case "utp":
+	case "utp", "utp4", "utp6":
 		return utp.ResolveUTPAddr(network, host)
-	case "ip":
+	case "ip", "ip4", "ip6":
 		return net.ResolveIPAddr(network, host)
 	}
 
@@ -158,8 +158,10 @@ func DialArgs(m ma.Multiaddr) (string, string, error) {
 	var host string
 	switch parts[0] {
 	case "ip4":
+		network = network + "4"
 		host = strings.Join([]string{parts[1], parts[3]}, ":")
 	case "ip6":
+		network = network + "6"
 		host = fmt.Sprintf("[%s]:%s", parts[1], parts[3])
 	}
 	return network, host, nil

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/convert_test.go

@@ -152,7 +152,10 @@ func TestDialArgs(t *testing.T) {
 		}
 	}
 
-	test("/ip4/127.0.0.1/udp/1234", "udp", "127.0.0.1:1234")
-	test("/ip4/127.0.0.1/tcp/4321", "tcp", "127.0.0.1:4321")
-	test("/ip4/127.0.0.1/udp/1234/utp", "utp", "127.0.0.1:1234")
+	test("/ip4/127.0.0.1/udp/1234", "udp4", "127.0.0.1:1234")
+	test("/ip4/127.0.0.1/tcp/4321", "tcp4", "127.0.0.1:4321")
+	test("/ip4/127.0.0.1/udp/1234/utp", "utp4", "127.0.0.1:1234")
+	test("/ip6/::1/udp/1234", "udp6", "[::1]:1234")
+	test("/ip6/::1/tcp/4321", "tcp6", "[::1]:4321")
+	test("/ip6/::1/udp/1234/utp", "utp6", "[::1]:1234")
 }

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/ip.go

@@ -57,7 +57,7 @@ func IsIPLoopback(m ma.Multiaddr) bool {
 	b := m.Bytes()
 
 	// /ip4/127 prefix (_entire_ /8 is loopback...)
-	if bytes.HasPrefix(b, []byte{4, 127}) {
+	if bytes.HasPrefix(b, []byte{ma.P_IP4, 127}) {
 		return true
 	}
 
@@ -69,6 +69,14 @@ func IsIPLoopback(m ma.Multiaddr) bool {
 	return false
 }
 
+// IP6 Link Local addresses are non routable. The prefix is technically
+// fe80::/10, but we test fe80::/16 for simplicity (no need to mask).
+// So far, no hardware interfaces exist long enough to use those 2 bits.
+// Send a PR if there is.
+func IsIP6LinkLocal(m ma.Multiaddr) bool {
+	return bytes.HasPrefix(m.Bytes(), []byte{ma.P_IP6, 0xfe, 0x80})
+}
+
 // IsIPUnspecified returns whether a Multiaddr is am Unspecified IP address
 // This means either /ip4/0.0.0.0 or /ip6/::
 func IsIPUnspecified(m ma.Multiaddr) bool {

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/net.go

@@ -106,12 +106,12 @@ func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
 	// ok, Dial!
 	var nconn net.Conn
 	switch rnet {
-	case "tcp":
+	case "tcp", "tcp4", "tcp6":
 		nconn, err = d.Dialer.Dial(rnet, rnaddr)
 		if err != nil {
 			return nil, err
 		}
-	case "utp":
+	case "udp", "udp4", "udp6":
 		return nil, fmt.Errorf("utp is currently broken")
 
 		// // construct utp dialer, with options on our net.Dialer
@@ -236,6 +236,14 @@ func Listen(laddr ma.Multiaddr) (Listener, error) {
 		return nil, err
 	}
 
+	// we need to fetch the new multiaddr from the listener, as it
+	// may have resolved to some other value.
+	nladdr, err := FromNetAddr(nl.Addr())
+	if err != nil {
+		return nil, err
+	}
+	laddr = nladdr
+
 	return &maListener{
 		Listener: nl,
 		laddr:    laddr,
@@ -258,3 +266,30 @@ func InterfaceMultiaddrs() ([]ma.Multiaddr, error) {
 	}
 	return maddrs, nil
 }
+
+// AddrMatch returns the Multiaddrs that match the protocol stack on addr
+func AddrMatch(match ma.Multiaddr, addrs []ma.Multiaddr) []ma.Multiaddr {
+
+	// we should match transports entirely.
+	p1s := match.Protocols()
+
+	out := make([]ma.Multiaddr, 0, len(addrs))
+	for _, a := range addrs {
+		p2s := a.Protocols()
+		if len(p1s) != len(p2s) {
+			continue
+		}
+
+		match := true
+		for i, p2 := range p2s {
+			if p1s[i].Code != p2.Code {
+				match = false
+				break
+			}
+		}
+		if match {
+			out = append(out, a)
+		}
+	}
+	return out
+}

Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net/net_test.go

@@ -2,6 +2,7 @@ package manet
 
 import (
 	"bytes"
+	"fmt"
 	"net"
 	"sync"
 	"testing"
@@ -140,7 +141,10 @@ func TestListen(t *testing.T) {
 
 func TestListenAddrs(t *testing.T) {
 
-	test := func(addr string, succeed bool) {
+	test := func(addr, resaddr string, succeed bool) {
+		if resaddr == "" {
+			resaddr = addr
+		}
 
 		maddr := newMultiaddr(t, addr)
 		l, err := Listen(maddr)
@@ -151,10 +155,13 @@ func TestListenAddrs(t *testing.T) {
 			return
 		}
 		if succeed && err != nil {
-			t.Fatal("failed to listen", addr, err)
+			t.Error("failed to listen", addr, err)
 		}
 		if l == nil {
-			t.Fatal("failed to listen", addr, succeed, err)
+			t.Error("failed to listen", addr, succeed, err)
+		}
+		if l.Multiaddr().String() != resaddr {
+			t.Error("listen addr did not resolve properly", l.Multiaddr().String(), resaddr, succeed, err)
 		}
 
 		if err = l.Close(); err != nil {
@@ -162,9 +169,18 @@ func TestListenAddrs(t *testing.T) {
 		}
 	}
 
-	test("/ip4/127.0.0.1/tcp/4324", true)
-	test("/ip4/127.0.0.1/udp/4325", false)
-	test("/ip4/127.0.0.1/udp/4326/udt", false)
+	test("/ip4/127.0.0.1/tcp/4324", "", true)
+	test("/ip4/127.0.0.1/udp/4325", "", false)
+	test("/ip4/127.0.0.1/udp/4326/udt", "", false)
+	test("/ip4/0.0.0.0/tcp/4324", "", true)
+	test("/ip4/0.0.0.0/udp/4325", "", false)
+	test("/ip4/0.0.0.0/udp/4326/udt", "", false)
+	test("/ip6/::1/tcp/4324", "", true)
+	test("/ip6/::1/udp/4325", "", false)
+	test("/ip6/::1/udp/4326/udt", "", false)
+	test("/ip6/::/tcp/4324", "", true)
+	test("/ip6/::/udp/4325", "", false)
+	test("/ip6/::/udp/4326/udt", "", false)
 	// test("/ip4/127.0.0.1/udp/4326/utp", true)
 }
 
@@ -334,3 +350,89 @@ func TestIPUnspecified(t *testing.T) {
 		t.Error("IsIPUnspecified failed (IP6Unspecified)")
 	}
 }
+
+func TestIP6LinkLocal(t *testing.T) {
+	if !IsIP6LinkLocal(IP6LinkLocalLoopback) {
+		t.Error("IsIP6LinkLocal failed (IP6LinkLocalLoopback)")
+	}
+
+	for a := 0; a < 65536; a++ {
+		isLinkLocal := (a == 0xfe80)
+		m := newMultiaddr(t, fmt.Sprintf("/ip6/%x::1", a))
+		if IsIP6LinkLocal(m) != isLinkLocal {
+			t.Error("IsIP6LinkLocal failed (%s != %v)", m, isLinkLocal)
+		}
+	}
+}
+
+func TestAddrMatch(t *testing.T) {
+
+	test := func(m ma.Multiaddr, input, expect []ma.Multiaddr) {
+		actual := AddrMatch(m, input)
+		testSliceEqual(t, expect, actual)
+	}
+
+	a := []ma.Multiaddr{
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/2345"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234"),
+		newMultiaddr(t, "/ip6/::1/tcp/2345"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+	}
+
+	test(a[0], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/2345"),
+	})
+	test(a[2], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/tcp/2345"),
+	})
+	test(a[4], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/udp/1234"),
+	})
+	test(a[6], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+		newMultiaddr(t, "/ip4/1.2.3.4/tcp/1234/ip6/::1"),
+	})
+	test(a[8], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip6/::1/tcp/1234"),
+		newMultiaddr(t, "/ip6/::1/tcp/2345"),
+	})
+	test(a[10], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/tcp/2345"),
+	})
+	test(a[12], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/udp/1234"),
+	})
+	test(a[14], a, []ma.Multiaddr{
+		newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+		newMultiaddr(t, "/ip6/::1/tcp/1234/ip6/::1"),
+	})
+
+}
+
+func testSliceEqual(t *testing.T, a, b []ma.Multiaddr) {
+	if len(a) != len(b) {
+		t.Error("differ", a, b)
+	}
+	for i, addrA := range a {
+		if !addrA.Equal(b[i]) {
+			t.Error("differ", a, b)
+		}
+	}
+}