diff --git a/convert.go b/convert.go index 973820c..e978046 100644 --- a/convert.go +++ b/convert.go @@ -3,7 +3,6 @@ package manet import ( "fmt" "net" - "strings" ma "github.com/multiformats/go-multiaddr" ) @@ -68,43 +67,82 @@ func parseBasicNetMaddr(maddr ma.Multiaddr) (net.Addr, error) { // FromIP converts a net.IP type to a Multiaddr. func FromIP(ip net.IP) (ma.Multiaddr, error) { + var proto string switch { case ip.To4() != nil: - return ma.NewMultiaddr("/ip4/" + ip.String()) + proto = "ip4" case ip.To16() != nil: - return ma.NewMultiaddr("/ip6/" + ip.String()) + proto = "ip6" default: return nil, errIncorrectNetAddr } + return ma.NewComponent(proto, ip.String()) } // DialArgs is a convenience function returning arguments for use in net.Dial func DialArgs(m ma.Multiaddr) (string, string, error) { - // TODO: find a 'good' way to eliminate the function. - // My preference is with a multiaddr.Format(...) function - if !IsThinWaist(m) { + var ( + zone, network, ip, port string + ) + + ma.ForEach(m, func(c ma.Component) bool { + switch network { + case "": + switch c.Protocol().Code { + case ma.P_IP6ZONE: + zone = c.Value() + return true + case ma.P_IP6: + network = "ip6" + ip = c.Value() + return true + case ma.P_IP4: + network = "ip4" + ip = c.Value() + return true + } + case "ip4": + switch c.Protocol().Code { + case ma.P_UDP: + network = "udp4" + case ma.P_TCP: + network = "tcp4" + default: + return false + } + port = c.Value() + case "ip6": + switch c.Protocol().Code { + case ma.P_UDP: + network = "udp6" + case ma.P_TCP: + network = "tcp6" + default: + return false + } + port = c.Value() + } + // Done. + return false + }) + switch network { + case "ip6": + if zone != "" { + ip += "%" + zone + } + fallthrough + case "ip4": + return network, ip, nil + case "tcp4", "udp4": + return network, ip + ":" + port, nil + case "tcp6", "udp6": + if zone != "" { + ip += "%" + zone + } + return network, "[" + ip + "]" + ":" + port, nil + default: return "", "", fmt.Errorf("%s is not a 'thin waist' address", m) } - - str := m.String() - parts := strings.Split(str, "/")[1:] - - if len(parts) == 2 { // only IP - return parts[0], parts[1], nil - } - - network := parts[2] - - 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 } func parseTCPNetAddr(a net.Addr) (ma.Multiaddr, error) { diff --git a/convert_test.go b/convert_test.go index 2977adf..0d06741 100644 --- a/convert_test.go +++ b/convert_test.go @@ -141,4 +141,10 @@ func TestDialArgs(t *testing.T) { test("/ip4/127.0.0.1/tcp/4321", "tcp4", "127.0.0.1:4321") test("/ip6/::1/udp/1234", "udp6", "[::1]:1234") test("/ip6/::1/tcp/4321", "tcp6", "[::1]:4321") + test("/ip6/::1", "ip6", "::1") // Just an IP + test("/ip4/1.2.3.4", "ip4", "1.2.3.4") // Just an IP + test("/ip6zone/foo/ip6/::1/tcp/4321", "tcp6", "[::1%foo]:4321") // zone + test("/ip6zone/foo/ip6/::1", "ip6", "::1%foo") // no TCP + test("/ip6zone/foo/ip6/::1/ip6zone/bar", "ip6", "::1%foo") // IP over IP + test("/ip6zone/foo/ip4/127.0.0.1/ip6zone/bar", "ip4", "127.0.0.1") // Skip zones in IP } diff --git a/ip.go b/ip.go index e5054dc..ef39c71 100644 --- a/ip.go +++ b/ip.go @@ -1,7 +1,7 @@ package manet import ( - "bytes" + "net" ma "github.com/multiformats/go-multiaddr" ) @@ -24,14 +24,6 @@ var ( IP6Unspecified = ma.StringCast("/ip6/::") ) -// Loopback multiaddr prefixes. Any multiaddr beginning with one of the -// following byte sequences is considered a loopback multiaddr. -var loopbackPrefixes = [][]byte{ - {ma.P_IP4, 127}, // 127.* - {ma.P_IP6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 127}, // ::ffff:127.* - IP6Loopback.Bytes(), // ::1 -} - // IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols. // This means: /{IP4, IP6}[/{TCP, UDP}] func IsThinWaist(m ma.Multiaddr) bool { @@ -62,22 +54,41 @@ func IsThinWaist(m ma.Multiaddr) bool { // IsIPLoopback returns whether a Multiaddr is a "Loopback" IP address // This means either /ip4/127.*.*.*, /ip6/::1, or /ip6/::ffff:127.*.*.*.* func IsIPLoopback(m ma.Multiaddr) bool { - b := m.Bytes() - for _, prefix := range loopbackPrefixes { - if bytes.HasPrefix(b, prefix) { - return true - } + c, rest := ma.SplitFirst(m) + if rest != nil { + // Not *just* an IPv4 addr + return false + } + switch c.Protocol().Code { + case ma.P_IP4, ma.P_IP6: + return net.IP(c.RawValue()).IsLoopback() } return false } -// IsIP6LinkLocal returns if a multiaddress is an IPv6 local link. These -// 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. +// IsIP6LinkLocal returns if a an IPv6 link-local multiaddress (with zero or +// more leading zones). These addresses are non routable. func IsIP6LinkLocal(m ma.Multiaddr) bool { - return bytes.HasPrefix(m.Bytes(), []byte{ma.P_IP6, 0xfe, 0x80}) + matched := false + ma.ForEach(m, func(c ma.Component) bool { + // Too much. + if matched { + matched = false + return false + } + + switch c.Protocol().Code { + case ma.P_IP6ZONE: + return true + case ma.P_IP6: + ip := net.IP(c.RawValue()) + matched = ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast() + return true + default: + return false + } + }) + return matched } // IsIPUnspecified returns whether a Multiaddr is am Unspecified IP address diff --git a/net_test.go b/net_test.go index 553dcba..cccdabc 100644 --- a/net_test.go +++ b/net_test.go @@ -306,7 +306,7 @@ func TestIPLoopback(t *testing.T) { t.Error("IP6Loopback incorrect:", IP6Loopback) } - if IP4MappedIP6Loopback.String() != "/ip6/127.0.0.1" { + if IP4MappedIP6Loopback.String() != "/ip6/::ffff:127.0.0.1" { t.Error("IP4MappedIP6Loopback incorrect:", IP4MappedIP6Loopback) } @@ -322,6 +322,10 @@ func TestIPLoopback(t *testing.T) { t.Error("IsIPLoopback false positive (/ip4/112.123.11.1)") } + if IsIPLoopback(newMultiaddr(t, "/ip4/127.0.0.1/ip4/127.0.0.1")) { + t.Error("IsIPLoopback false positive (/ip4/127.0.0.1/127.0.0.1)") + } + if IsIPLoopback(newMultiaddr(t, "/ip4/192.168.0.1/ip6/::1")) { t.Error("IsIPLoopback false positive (/ip4/192.168.0.1/ip6/::1)") } @@ -363,7 +367,7 @@ func TestIPUnspecified(t *testing.T) { func TestIP6LinkLocal(t *testing.T) { for a := 0; a < 65536; a++ { - isLinkLocal := (a == 0xfe80) + isLinkLocal := (a&0xffc0 == 0xfe80 || a&0xff0f == 0xff02) m := newMultiaddr(t, fmt.Sprintf("/ip6/%x::1", a)) if IsIP6LinkLocal(m) != isLinkLocal { t.Errorf("IsIP6LinkLocal failed (%s != %v)", m, isLinkLocal) diff --git a/package.json b/package.json index f96e7c9..c7f0f1d 100644 --- a/package.json +++ b/package.json @@ -9,9 +9,9 @@ "gxDependencies": [ { "author": "multiformats", - "hash": "QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7", + "hash": "QmT4U94DnD8FRfqr21obWY32HLM5VExccPKMjQHofeYqr9", "name": "go-multiaddr", - "version": "1.3.0" + "version": "1.3.5" } ], "gxVersion": "0.6.0",