updated multiaddr

Godeps/Godeps.json

 {
 	"ImportPath": "github.com/jbenet/go-ipfs",
-	"GoVersion": "go1.3.3",
+	"GoVersion": "go1.3",
 	"Packages": [
 		"./..."
 	],
@@ -102,8 +102,8 @@
 		},
 		{
 			"ImportPath": "github.com/jbenet/go-multiaddr",
-			"Comment": "0.1.2-17-g68a2067",
-			"Rev": "68a20675cb0829da219def0d90afe17a7219e8c7"
+			"Comment": "0.1.2-27-g62a88e0",
+			"Rev": "62a88e015e1bf5d6aaca29aec1aba0722f21c8d3"
 		},
 		{
 			"ImportPath": "github.com/jbenet/go-multihash",

Godeps/_workspace/src/github.com/jbenet/go-multiaddr/README.md

@@ -34,16 +34,6 @@ addr.Protocols()
 // }
 ```
 
-### Other formats
-
-```go
-// handles the stupid url version too
-m = ma.NewUrl("udp4://127.0.0.1:1234")
-// <Multiaddr /ip4/127.0.0.1/udp/1234>
-m.Url(buf)
-// udp4://127.0.0.1:1234
-```
-
 ### En/decapsulate
 
 ```go

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

@@ -67,6 +67,30 @@ func bytesToString(b []byte) (ret string, err error) {
 	return s, nil
 }
 
+func bytesSplit(b []byte) (ret [][]byte, err error) {
+	// panic handler, in case we try accessing bytes incorrectly.
+	defer func() {
+		if e := recover(); e != nil {
+			ret = [][]byte{}
+			err = e.(error)
+		}
+	}()
+
+	ret = [][]byte{}
+	for len(b) > 0 {
+		p := ProtocolWithCode(int(b[0]))
+		if p == nil {
+			return [][]byte{}, fmt.Errorf("no protocol with code %d", b[0])
+		}
+
+		length := 1 + (p.Size / 8)
+		ret = append(ret, b[:length])
+		b = b[length:]
+	}
+
+	return ret, nil
+}
+
 func addressStringToBytes(p *Protocol, s string) []byte {
 	switch p.Code {
 

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

@@ -84,10 +84,10 @@ func (m *multiaddr) Encapsulate(o Multiaddr) Multiaddr {
 	mb := m.bytes
 	ob := o.Bytes()
 
-	var b bytes.Buffer
-	b.Write(mb)
-	b.Write(ob)
-	return &multiaddr{bytes: b.Bytes()}
+	b := make([]byte, len(mb)+len(ob))
+	copy(b, mb)
+	copy(b[len(mb):], ob)
+	return &multiaddr{bytes: b}
 }
 
 // Decapsulate unwraps Multiaddr up until the given Multiaddr is found.

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

+package main
+
+import (
+	"encoding/hex"
+	"flag"
+	"fmt"
+	"os"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
+	manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
+)
+
+// flags
+var formats = []string{"string", "bytes", "hex", "slice"}
+var format string
+var hideLoopback bool
+
+func init() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "usage: %s [<multiaddr>]\n\nFlags:\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	usage := fmt.Sprintf("output format, one of: %v", formats)
+	flag.StringVar(&format, "format", "string", usage)
+	flag.StringVar(&format, "f", "string", usage+" (shorthand)")
+	flag.BoolVar(&hideLoopback, "hide-loopback", false, "do not display loopback addresses")
+}
+
+func main() {
+	flag.Parse()
+	args := flag.Args()
+	if len(args) == 0 {
+		output(localAddresses()...)
+	} else {
+		output(address(args[0]))
+	}
+}
+
+func localAddresses() []ma.Multiaddr {
+	maddrs, err := manet.InterfaceMultiaddrs()
+	if err != nil {
+		die(err)
+	}
+
+	if !hideLoopback {
+		return maddrs
+	}
+
+	var maddrs2 []ma.Multiaddr
+	for _, a := range maddrs {
+		if !manet.IsIPLoopback(a) {
+			maddrs2 = append(maddrs2, a)
+		}
+	}
+
+	return maddrs2
+}
+
+func address(addr string) ma.Multiaddr {
+	m, err := ma.NewMultiaddr(addr)
+	if err != nil {
+		die(err)
+	}
+
+	return m
+}
+
+func output(ms ...ma.Multiaddr) {
+	for _, m := range ms {
+		fmt.Println(outfmt(m))
+	}
+}
+
+func outfmt(m ma.Multiaddr) string {
+	switch format {
+	case "string":
+		return m.String()
+	case "slice":
+		return fmt.Sprintf("%v", m.Bytes())
+	case "bytes":
+		return string(m.Bytes())
+	case "hex":
+		return "0x" + hex.EncodeToString(m.Bytes())
+	}
+
+	die("error: invalid format", format)
+	return ""
+}
+
+func die(v ...interface{}) {
+	fmt.Fprint(os.Stderr, v...)
+	fmt.Fprint(os.Stderr, "\n")
+	flag.Usage()
+	os.Exit(-1)
+}

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

@@ -91,6 +91,49 @@ func TestBytesToString(t *testing.T) {
 	testString("/ip4/127.0.0.1/udp/1234", "047f0000011104d2")
 }
 
+func TestBytesSplitAndJoin(t *testing.T) {
+
+	testString := func(s string, res []string) {
+		m, err := NewMultiaddr(s)
+		if err != nil {
+			t.Error("failed to convert", s)
+		}
+
+		split := Split(m)
+		if len(split) != len(res) {
+			t.Error("not enough split components", split)
+			return
+		}
+
+		for i, a := range split {
+			if a.String() != res[i] {
+				t.Errorf("split component failed: %s != %s", a, res[i])
+			}
+		}
+
+		joined := Join(split...)
+		if !m.Equal(joined) {
+			t.Errorf("joined components failed: %s != %s", m, joined)
+		}
+
+		// modifying underlying bytes is fine.
+		m2 := m.(*multiaddr)
+		for i := range m2.bytes {
+			m2.bytes[i] = 0
+		}
+
+		for i, a := range split {
+			if a.String() != res[i] {
+				t.Errorf("split component failed: %s != %s", a, res[i])
+			}
+		}
+	}
+
+	testString("/ip4/1.2.3.4/udp/1234", []string{"/ip4/1.2.3.4", "/udp/1234"})
+	testString("/ip4/1.2.3.4/tcp/1/ip4/2.3.4.5/udp/2",
+		[]string{"/ip4/1.2.3.4", "/tcp/1", "/ip4/2.3.4.5", "/udp/2"})
+}
+
 func TestProtocols(t *testing.T) {
 	m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
 	if err != nil {

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

-package net
+package manet
 
 import (
 	"fmt"
@@ -62,6 +62,13 @@ func FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
 		}
 		return FromIP(ac.IP)
 
+	case "ip+net":
+		ac, ok := a.(*net.IPNet)
+		if !ok {
+			return nil, errIncorrectNetAddr
+		}
+		return FromIP(ac.IP)
+
 	default:
 		return nil, fmt.Errorf("unknown network %v", a.Network())
 	}
@@ -123,30 +130,3 @@ func DialArgs(m ma.Multiaddr) (string, string, error) {
 	}
 	return network, host, nil
 }
-
-// IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols.
-// This means: /{IP4, IP6}[/{TCP, UDP}]
-func IsThinWaist(m ma.Multiaddr) bool {
-	p := m.Protocols()
-
-	// nothing? not even a waist.
-	if len(p) == 0 {
-		return false
-	}
-
-	if p[0].Code != ma.P_IP4 && p[0].Code != ma.P_IP6 {
-		return false
-	}
-
-	// only IP? still counts.
-	if len(p) == 1 {
-		return true
-	}
-
-	switch p[1].Code {
-	case ma.P_TCP, ma.P_UDP, ma.P_IP4, ma.P_IP6:
-		return true
-	default:
-		return false
-	}
-}

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

-package net
+package manet
 
 import (
 	"net"

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

-// Package net provides Multiaddr specific versions of common
+// Package manet provides Multiaddr specific versions of common
 // functions in stdlib's net package. This means wrappers of
 // standard net symbols like net.Dial and net.Listen, as well
 // as conversion to/from net.Addr.
-package net
+package manet

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

+package manet
+
+import (
+	"bytes"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
+)
+
+// Loopback Addresses
+var (
+	// IP4Loopback is the ip4 loopback multiaddr
+	IP4Loopback = ma.StringCast("/ip4/127.0.0.1")
+
+	// IP6Loopback is the ip6 loopback multiaddr
+	IP6Loopback = ma.StringCast("/ip6/::1")
+
+	// IP6LinkLocalLoopback is the ip6 link-local loopback multiaddr
+	IP6LinkLocalLoopback = ma.StringCast("/ip6/fe80::1")
+)
+
+// Unspecified Addresses (used for )
+var (
+	IP4Unspecified = ma.StringCast("/ip4/0.0.0.0")
+	IP6Unspecified = ma.StringCast("/ip6/::")
+)
+
+// IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols.
+// This means: /{IP4, IP6}[/{TCP, UDP}]
+func IsThinWaist(m ma.Multiaddr) bool {
+	p := m.Protocols()
+
+	// nothing? not even a waist.
+	if len(p) == 0 {
+		return false
+	}
+
+	if p[0].Code != ma.P_IP4 && p[0].Code != ma.P_IP6 {
+		return false
+	}
+
+	// only IP? still counts.
+	if len(p) == 1 {
+		return true
+	}
+
+	switch p[1].Code {
+	case ma.P_TCP, ma.P_UDP, ma.P_IP4, ma.P_IP6:
+		return true
+	default:
+		return false
+	}
+}
+
+// IsIPLoopback returns whether a Multiaddr is a "Loopback" IP address
+// This means either /ip4/127.0.0.1 or /ip6/::1
+func IsIPLoopback(m ma.Multiaddr) bool {
+	b := m.Bytes()
+
+	// /ip4/127 prefix (_entire_ /8 is loopback...)
+	if bytes.HasPrefix(b, []byte{4, 127}) {
+		return true
+	}
+
+	// /ip6/::1
+	if IP6Loopback.Equal(m) || IP6LinkLocalLoopback.Equal(m) {
+		return true
+	}
+
+	return false
+}
+
+// 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 {
+	return IP4Unspecified.Equal(m) || IP6Unspecified.Equal(m)
+}

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

-package net
+package manet
 
 import (
 	"fmt"
@@ -216,3 +216,20 @@ func Listen(laddr ma.Multiaddr) (Listener, error) {
 		laddr:    laddr,
 	}, nil
 }
+
+// InterfaceMultiaddrs will return the addresses matching net.InterfaceAddrs
+func InterfaceMultiaddrs() ([]ma.Multiaddr, error) {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return nil, err
+	}
+
+	maddrs := make([]ma.Multiaddr, len(addrs))
+	for i, a := range addrs {
+		maddrs[i], err = FromNetAddr(a)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return maddrs, nil
+}

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

-package net
+package manet
 
 import (
 	"bytes"
@@ -198,3 +198,47 @@ func TestListenAndDial(t *testing.T) {
 	cA.Close()
 	wg.Wait()
 }
+
+func TestIPLoopback(t *testing.T) {
+	if IP4Loopback.String() != "/ip4/127.0.0.1" {
+		t.Error("IP4Loopback incorrect:", IP4Loopback)
+	}
+
+	if IP6Loopback.String() != "/ip6/::1" {
+		t.Error("IP6Loopback incorrect:", IP6Loopback)
+	}
+
+	if IP6LinkLocalLoopback.String() != "/ip6/fe80::1" {
+		t.Error("IP6LinkLocalLoopback incorrect:", IP6Loopback)
+	}
+
+	if !IsIPLoopback(IP4Loopback) {
+		t.Error("IsIPLoopback failed (IP4Loopback)")
+	}
+
+	if !IsIPLoopback(IP6Loopback) {
+		t.Error("IsIPLoopback failed (IP6Loopback)")
+	}
+
+	if !IsIPLoopback(IP6LinkLocalLoopback) {
+		t.Error("IsIPLoopback failed (IP6LinkLocalLoopback)")
+	}
+}
+
+func TestIPUnspecified(t *testing.T) {
+	if IP4Unspecified.String() != "/ip4/0.0.0.0" {
+		t.Error("IP4Unspecified incorrect:", IP4Unspecified)
+	}
+
+	if IP6Unspecified.String() != "/ip6/::" {
+		t.Error("IP6Unspecified incorrect:", IP6Unspecified)
+	}
+
+	if !IsIPUnspecified(IP4Unspecified) {
+		t.Error("IsIPUnspecified failed (IP4Unspecified)")
+	}
+
+	if !IsIPUnspecified(IP6Unspecified) {
+		t.Error("IsIPUnspecified failed (IP6Unspecified)")
+	}
+}

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

+package multiaddr
+
+import "fmt"
+
+// Split returns the sub-address portions of a multiaddr.
+func Split(m Multiaddr) []Multiaddr {
+	split, err := bytesSplit(m.Bytes())
+	if err != nil {
+		panic(fmt.Errorf("invalid multiaddr %s", m.String()))
+	}
+
+	addrs := make([]Multiaddr, len(split))
+	for i, addr := range split {
+		addrs[i] = &multiaddr{bytes: addr}
+	}
+	return addrs
+}
+
+// Join returns a combination of addresses.
+func Join(ms ...Multiaddr) Multiaddr {
+
+	length := 0
+	bs := make([][]byte, len(ms))
+	for i, m := range ms {
+		bs[i] = m.Bytes()
+		length += len(bs[i])
+	}
+
+	bidx := 0
+	b := make([]byte, length)
+	for _, mb := range bs {
+		for i := range mb {
+			b[bidx] = mb[i]
+			bidx++
+		}
+	}
+	return &multiaddr{bytes: b}
+}
+
+// Cast re-casts a byte slice as a multiaddr. will panic if it fails to parse.
+func Cast(b []byte) Multiaddr {
+	_, err := bytesToString(b)
+	if err != nil {
+		panic(fmt.Errorf("multiaddr failed to parse: %s", err))
+	}
+	return &multiaddr{bytes: b}
+}
+
+// StringCast like Cast, but parses a string. Will also panic if it fails to parse.
+func StringCast(s string) Multiaddr {
+	m, err := NewMultiaddr(s)
+	if err != nil {
+		panic(fmt.Errorf("multiaddr failed to parse: %s", err))
+	}
+	return m
+}