diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 71ee4c0e1..e8704e9a7 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -84,8 +84,8 @@ }, { "ImportPath": "github.com/jbenet/go-multiaddr", - "Comment": "0.1.2-9-g1ec9436", - "Rev": "1ec9436b1d642f4f04c0d9e21a0719cda3d659ee" + "Comment": "0.1.2-11-g2a572df", + "Rev": "2a572df05cbbb3a0b0b3d0095a9af16757cbbf9f" }, { "ImportPath": "github.com/jbenet/go-multihash", diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/codec.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/codec.go index c79742652..a6cf9911c 100644 --- a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/codec.go +++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/codec.go @@ -9,6 +9,10 @@ import ( ) func stringToBytes(s string) ([]byte, error) { + + // consume trailing slashes + s = strings.TrimRight(s, "/") + b := []byte{} sp := strings.Split(s, "/") diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/multiaddr_test.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/multiaddr_test.go index 12d621463..3a7820400 100644 --- a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/multiaddr_test.go +++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/multiaddr_test.go @@ -18,6 +18,7 @@ func TestEqual(t *testing.T) { m1 := newMultiaddr(t, "/ip4/127.0.0.1/udp/1234") m2 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234") m3 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234") + m4 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234/") if m1.Equal(m2) { t.Error("should not be equal") @@ -38,6 +39,14 @@ func TestEqual(t *testing.T) { if !m1.Equal(m1) { t.Error("should be equal") } + + if !m2.Equal(m4) { + t.Error("should be equal") + } + + if !m4.Equal(m3) { + t.Error("should be equal") + } } func TestStringToBytes(t *testing.T) { diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go index ed91dc2e1..cddebd0fb 100644 --- a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go +++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go @@ -65,6 +65,27 @@ func FromNetAddr(a net.Addr) (Multiaddr, error) { } } +// ToNetAddr converts a Multiaddr to a net.Addr +// Must be ThinWaist. acceptable protocol stacks are: +// /ip{4,6}/{tcp, udp} +func ToNetAddr(ma Multiaddr) (net.Addr, error) { + network, host, err := DialArgs(ma) + if err != nil { + return nil, err + } + + switch network { + case "tcp": + return net.ResolveTCPAddr(network, host) + case "udp": + return net.ResolveUDPAddr(network, host) + case "ip": + return net.ResolveIPAddr(network, host) + } + + return nil, fmt.Errorf("network not supported: %s", network) +} + // FromIP converts a net.IP type to a Multiaddr. func FromIP(ip net.IP) (Multiaddr, error) { switch { @@ -85,8 +106,12 @@ func DialArgs(m Multiaddr) (string, string, error) { str := m.String() parts := strings.Split(str, "/")[1:] - network := parts[2] + if len(parts) == 2 { // only IP + return parts[0], parts[1], nil + } + + network := parts[2] var host string switch parts[0] { case "ip4": @@ -98,16 +123,28 @@ func DialArgs(m Multiaddr) (string, string, error) { } // IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols. -// This means: /{IP4, IP6}/{TCP, UDP} +// This means: /{IP4, IP6}[/{TCP, UDP}] func IsThinWaist(m Multiaddr) bool { p := m.Protocols() + + // nothing? not even a waist. + if len(p) == 0 { + return false + } + if p[0].Code != P_IP4 && p[0].Code != P_IP6 { return false } - if p[1].Code != P_TCP && p[1].Code != P_UDP { - return false + // only IP? still counts. + if len(p) == 1 { + return true } - return true + switch p[1].Code { + case P_TCP, P_UDP, P_IP4, P_IP6: + return true + default: + return false + } } diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go index c9cb4b4ac..5edb560e5 100644 --- a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go +++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go @@ -18,6 +18,44 @@ func testConvert(t *testing.T, s string, gen GenFunc) { } } +func testToNetAddr(t *testing.T, maddr, ntwk, addr string) { + m, err := NewMultiaddr(maddr) + if err != nil { + t.Fatal("failed to generate.") + } + + naddr, err := ToNetAddr(m) + if addr == "" { // should fail + if err == nil { + t.Fatalf("failed to error: %s", m) + } + return + } + + // shouldn't fail + if err != nil { + t.Fatalf("failed to convert to net addr: %s", m) + } + + if naddr.String() != addr { + t.Fatalf("naddr.Address() == %s != %s", naddr, addr) + } + + if naddr.Network() != ntwk { + t.Fatalf("naddr.Network() == %s != %s", naddr.Network(), ntwk) + } + + // should convert properly + switch ntwk { + case "tcp": + _ = naddr.(*net.TCPAddr) + case "udp": + _ = naddr.(*net.UDPAddr) + case "ip": + _ = naddr.(*net.IPAddr) + } +} + func TestFromIP4(t *testing.T) { testConvert(t, "/ip4/10.20.30.40", func() (Multiaddr, error) { return FromIP(net.ParseIP("10.20.30.40")) @@ -48,6 +86,34 @@ func TestFromUDP(t *testing.T) { }) } +func TestThinWaist(t *testing.T) { + addrs := map[string]bool{ + "/ip4/127.0.0.1/udp/1234": true, + "/ip4/127.0.0.1/tcp/1234": true, + "/ip4/127.0.0.1/udp/1234/tcp/1234": true, + "/ip4/127.0.0.1/tcp/12345/ip4/1.2.3.4": true, + "/ip6/::1/tcp/80": true, + "/ip6/::1/udp/80": true, + "/ip6/::1": true, + "/tcp/1234/ip4/1.2.3.4": false, + "/tcp/1234": false, + "/tcp/1234/udp/1234": false, + "/ip4/1.2.3.4/ip4/2.3.4.5": true, + "/ip6/::1/ip4/2.3.4.5": true, + } + + for a, res := range addrs { + ma, err := NewMultiaddr(a) + if err != nil { + t.Fatalf("failed to construct Multiaddr: %s", a) + } + + if IsThinWaist(ma) != res { + t.Fatalf("IsThinWaist(%s) != %v", a, res) + } + } +} + func TestDialArgs(t *testing.T) { m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234") if err != nil {