From 917be904376b1a5b1b454c87f6e9c6a35e38e53e Mon Sep 17 00:00:00 2001
From: Juan Batiz-Benet <juan@benet.ai>
Date: Sat, 11 Oct 2014 03:02:46 -0700
Subject: [PATCH 1/2] updated multiaddr for net pkg

---
 Godeps/Godeps.json                            |   6 +-
 .../jbenet/go-multiaddr/.travis.yml           |  10 +
 .../jbenet/go-multiaddr/net/README.md         |  11 +
 .../go-multiaddr/{net.go => net/convert.go}   |  28 +--
 .../{net_test.go => net/convert_test.go}      |  22 +-
 .../github.com/jbenet/go-multiaddr/net/doc.go |   5 +
 .../github.com/jbenet/go-multiaddr/net/net.go | 218 ++++++++++++++++++
 .../jbenet/go-multiaddr/net/net_test.go       | 200 ++++++++++++++++
 daemon/daemon.go                              |   3 +-
 daemon/daemon_client.go                       |   3 +-
 net/conn/conn.go                              |   5 +-
 net/swarm/conn.go                             |   3 +-
 net/swarm/swarm_test.go                       |   3 +-
 server/http/http.go                           |   3 +-
 14 files changed, 487 insertions(+), 33 deletions(-)
 create mode 100644 Godeps/_workspace/src/github.com/jbenet/go-multiaddr/.travis.yml
 create mode 100644 Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/README.md
 rename Godeps/_workspace/src/github.com/jbenet/go-multiaddr/{net.go => net/convert.go} (78%)
 rename Godeps/_workspace/src/github.com/jbenet/go-multiaddr/{net_test.go => net/convert_test.go} (81%)
 create mode 100644 Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/doc.go
 create mode 100644 Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net.go
 create mode 100644 Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net_test.go

diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index e8704e9a7..901dd011e 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "github.com/jbenet/go-ipfs",
-	"GoVersion": "go1.3.3",
+	"GoVersion": "go1.3",
 	"Packages": [
 		"./..."
 	],
@@ -84,8 +84,8 @@
 		},
 		{
 			"ImportPath": "github.com/jbenet/go-multiaddr",
-			"Comment": "0.1.2-11-g2a572df",
-			"Rev": "2a572df05cbbb3a0b0b3d0095a9af16757cbbf9f"
+			"Comment": "0.1.2-17-g68a2067",
+			"Rev": "68a20675cb0829da219def0d90afe17a7219e8c7"
 		},
 		{
 			"ImportPath": "github.com/jbenet/go-multihash",
diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/.travis.yml b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/.travis.yml
new file mode 100644
index 000000000..32ce5a786
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/.travis.yml
@@ -0,0 +1,10 @@
+language: go
+
+go:
+  - 1.2
+  - 1.3
+  - release
+  - tip
+
+script:
+  - go test -v ./...
diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/README.md b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/README.md
new file mode 100644
index 000000000..41f1cb337
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/README.md
@@ -0,0 +1,11 @@
+# multiaddr/net - Multiaddr friendly net
+
+Package multiaddr/net 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.
+
+Docs:
+
+- `multiaddr/net`: https://godoc.org/github.com/jbenet/go-multiaddr/net
+- `multiaddr`: https://godoc.org/github.com/jbenet/go-multiaddr
diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert.go
similarity index 78%
rename from Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go
rename to Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert.go
index cddebd0fb..d7749d89d 100644
--- a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert.go
@@ -1,15 +1,17 @@
-package multiaddr
+package net
 
 import (
 	"fmt"
 	"net"
 	"strings"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
 var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
 
 // FromNetAddr converts a net.Addr type to a Multiaddr.
-func FromNetAddr(a net.Addr) (Multiaddr, error) {
+func FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	switch a.Network() {
 	case "tcp", "tcp4", "tcp6":
 		ac, ok := a.(*net.TCPAddr)
@@ -24,7 +26,7 @@ func FromNetAddr(a net.Addr) (Multiaddr, error) {
 		}
 
 		// Get TCP Addr
-		tcpm, err := NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
+		tcpm, err := ma.NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
 		if err != nil {
 			return nil, errIncorrectNetAddr
 		}
@@ -45,7 +47,7 @@ func FromNetAddr(a net.Addr) (Multiaddr, error) {
 		}
 
 		// Get UDP Addr
-		udpm, err := NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
+		udpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
 		if err != nil {
 			return nil, errIncorrectNetAddr
 		}
@@ -68,8 +70,8 @@ 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)
+func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+	network, host, err := DialArgs(maddr)
 	if err != nil {
 		return nil, err
 	}
@@ -87,19 +89,19 @@ func ToNetAddr(ma Multiaddr) (net.Addr, error) {
 }
 
 // FromIP converts a net.IP type to a Multiaddr.
-func FromIP(ip net.IP) (Multiaddr, error) {
+func FromIP(ip net.IP) (ma.Multiaddr, error) {
 	switch {
 	case ip.To4() != nil:
-		return NewMultiaddr("/ip4/" + ip.String())
+		return ma.NewMultiaddr("/ip4/" + ip.String())
 	case ip.To16() != nil:
-		return NewMultiaddr("/ip6/" + ip.String())
+		return ma.NewMultiaddr("/ip6/" + ip.String())
 	default:
 		return nil, errIncorrectNetAddr
 	}
 }
 
 // DialArgs is a convenience function returning arguments for use in net.Dial
-func DialArgs(m Multiaddr) (string, string, error) {
+func DialArgs(m ma.Multiaddr) (string, string, error) {
 	if !IsThinWaist(m) {
 		return "", "", fmt.Errorf("%s is not a 'thin waist' address", m)
 	}
@@ -124,7 +126,7 @@ func DialArgs(m Multiaddr) (string, string, error) {
 
 // IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols.
 // This means: /{IP4, IP6}[/{TCP, UDP}]
-func IsThinWaist(m Multiaddr) bool {
+func IsThinWaist(m ma.Multiaddr) bool {
 	p := m.Protocols()
 
 	// nothing? not even a waist.
@@ -132,7 +134,7 @@ func IsThinWaist(m Multiaddr) bool {
 		return false
 	}
 
-	if p[0].Code != P_IP4 && p[0].Code != P_IP6 {
+	if p[0].Code != ma.P_IP4 && p[0].Code != ma.P_IP6 {
 		return false
 	}
 
@@ -142,7 +144,7 @@ func IsThinWaist(m Multiaddr) bool {
 	}
 
 	switch p[1].Code {
-	case P_TCP, P_UDP, P_IP4, P_IP6:
+	case ma.P_TCP, ma.P_UDP, ma.P_IP4, ma.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/convert_test.go
similarity index 81%
rename from Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go
rename to Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert_test.go
index 5edb560e5..7dc8e50a3 100644
--- a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert_test.go
@@ -1,11 +1,13 @@
-package multiaddr
+package net
 
 import (
 	"net"
 	"testing"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
-type GenFunc func() (Multiaddr, error)
+type GenFunc func() (ma.Multiaddr, error)
 
 func testConvert(t *testing.T, s string, gen GenFunc) {
 	m, err := gen()
@@ -19,7 +21,7 @@ func testConvert(t *testing.T, s string, gen GenFunc) {
 }
 
 func testToNetAddr(t *testing.T, maddr, ntwk, addr string) {
-	m, err := NewMultiaddr(maddr)
+	m, err := ma.NewMultiaddr(maddr)
 	if err != nil {
 		t.Fatal("failed to generate.")
 	}
@@ -57,19 +59,19 @@ func testToNetAddr(t *testing.T, maddr, ntwk, addr string) {
 }
 
 func TestFromIP4(t *testing.T) {
-	testConvert(t, "/ip4/10.20.30.40", func() (Multiaddr, error) {
+	testConvert(t, "/ip4/10.20.30.40", func() (ma.Multiaddr, error) {
 		return FromIP(net.ParseIP("10.20.30.40"))
 	})
 }
 
 func TestFromIP6(t *testing.T) {
-	testConvert(t, "/ip6/2001:4860:0:2001::68", func() (Multiaddr, error) {
+	testConvert(t, "/ip6/2001:4860:0:2001::68", func() (ma.Multiaddr, error) {
 		return FromIP(net.ParseIP("2001:4860:0:2001::68"))
 	})
 }
 
 func TestFromTCP(t *testing.T) {
-	testConvert(t, "/ip4/10.20.30.40/tcp/1234", func() (Multiaddr, error) {
+	testConvert(t, "/ip4/10.20.30.40/tcp/1234", func() (ma.Multiaddr, error) {
 		return FromNetAddr(&net.TCPAddr{
 			IP:   net.ParseIP("10.20.30.40"),
 			Port: 1234,
@@ -78,7 +80,7 @@ func TestFromTCP(t *testing.T) {
 }
 
 func TestFromUDP(t *testing.T) {
-	testConvert(t, "/ip4/10.20.30.40/udp/1234", func() (Multiaddr, error) {
+	testConvert(t, "/ip4/10.20.30.40/udp/1234", func() (ma.Multiaddr, error) {
 		return FromNetAddr(&net.UDPAddr{
 			IP:   net.ParseIP("10.20.30.40"),
 			Port: 1234,
@@ -103,19 +105,19 @@ func TestThinWaist(t *testing.T) {
 	}
 
 	for a, res := range addrs {
-		ma, err := NewMultiaddr(a)
+		m, err := ma.NewMultiaddr(a)
 		if err != nil {
 			t.Fatalf("failed to construct Multiaddr: %s", a)
 		}
 
-		if IsThinWaist(ma) != res {
+		if IsThinWaist(m) != res {
 			t.Fatalf("IsThinWaist(%s) != %v", a, res)
 		}
 	}
 }
 
 func TestDialArgs(t *testing.T) {
-	m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+	m, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
 	if err != nil {
 		t.Fatal("failed to construct", "/ip4/127.0.0.1/udp/1234")
 	}
diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/doc.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/doc.go
new file mode 100644
index 000000000..d73b8652f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/doc.go
@@ -0,0 +1,5 @@
+// Package net 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
diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net.go
new file mode 100644
index 000000000..3cb41622f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net.go
@@ -0,0 +1,218 @@
+package net
+
+import (
+	"fmt"
+	"net"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
+)
+
+// Conn is the equivalent of a net.Conn object. It is the
+// result of calling the Dial or Listen functions in this
+// package, with associated local and remote Multiaddrs.
+type Conn interface {
+	net.Conn
+
+	// LocalMultiaddr returns the local Multiaddr associated
+	// with this connection
+	LocalMultiaddr() ma.Multiaddr
+
+	// RemoteMultiaddr returns the remote Multiaddr associated
+	// with this connection
+	RemoteMultiaddr() ma.Multiaddr
+}
+
+// WrapNetConn wraps a net.Conn object with a Multiaddr
+// friendly Conn.
+func WrapNetConn(nconn net.Conn) (Conn, error) {
+
+	laddr, err := FromNetAddr(nconn.LocalAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert nconn.LocalAddr: %s", err)
+	}
+
+	raddr, err := FromNetAddr(nconn.RemoteAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert nconn.RemoteAddr: %s", err)
+	}
+
+	return &maConn{
+		Conn:  nconn,
+		laddr: laddr,
+		raddr: raddr,
+	}, nil
+}
+
+// maConn implements the Conn interface. It's a thin wrapper
+// around a net.Conn
+type maConn struct {
+	net.Conn
+	laddr ma.Multiaddr
+	raddr ma.Multiaddr
+}
+
+// LocalMultiaddr returns the local address associated with
+// this connection
+func (c *maConn) LocalMultiaddr() ma.Multiaddr {
+	return c.laddr
+}
+
+// RemoteMultiaddr returns the remote address associated with
+// this connection
+func (c *maConn) RemoteMultiaddr() ma.Multiaddr {
+	return c.raddr
+}
+
+// Dialer contains options for connecting to an address. It
+// is effectively the same as net.Dialer, but its LocalAddr
+// and RemoteAddr options are Multiaddrs, instead of net.Addrs.
+type Dialer struct {
+
+	// Dialer is just an embed net.Dialer, with all its options.
+	net.Dialer
+
+	// LocalAddr is the local address to use when dialing an
+	// address. The address must be of a compatible type for the
+	// network being dialed.
+	// If nil, a local address is automatically chosen.
+	LocalAddr ma.Multiaddr
+}
+
+// Dial connects to a remote address, using the options of the
+// Dialer. Dialer uses an underlying net.Dialer to Dial a
+// net.Conn, then wraps that in a Conn object (with local and
+// remote Multiaddrs).
+func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
+
+	// if a LocalAddr is specified, use it on the embedded dialer.
+	if d.LocalAddr != nil {
+		// convert our multiaddr to net.Addr friendly
+		naddr, err := ToNetAddr(d.LocalAddr)
+		if err != nil {
+			return nil, err
+		}
+
+		// set the dialer's LocalAddr as naddr
+		d.Dialer.LocalAddr = naddr
+	}
+
+	// get the net.Dial friendly arguments from the remote addr
+	rnet, rnaddr, err := DialArgs(remote)
+	if err != nil {
+		return nil, err
+	}
+
+	// ok, Dial!
+	nconn, err := d.Dialer.Dial(rnet, rnaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	// get local address (pre-specified or assigned within net.Conn)
+	local := d.LocalAddr
+	if local == nil {
+		local, err = FromNetAddr(nconn.LocalAddr())
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &maConn{
+		Conn:  nconn,
+		laddr: local,
+		raddr: remote,
+	}, nil
+}
+
+// Dial connects to a remote address. It uses an underlying net.Conn,
+// then wraps it in a Conn object (with local and remote Multiaddrs).
+func Dial(remote ma.Multiaddr) (Conn, error) {
+	return (&Dialer{}).Dial(remote)
+}
+
+// A Listener is a generic network listener for stream-oriented protocols.
+// it uses an embedded net.Listener, overriding net.Listener.Accept to
+// return a Conn and providing Multiaddr.
+type Listener interface {
+
+	// NetListener returns the embedded net.Listener. Use with caution.
+	NetListener() net.Listener
+
+	// Accept waits for and returns the next connection to the listener.
+	// Returns a Multiaddr friendly Conn
+	Accept() (Conn, error)
+
+	// Close closes the listener.
+	// Any blocked Accept operations will be unblocked and return errors.
+	Close() error
+
+	// Multiaddr returns the listener's (local) Multiaddr.
+	Multiaddr() ma.Multiaddr
+
+	// Addr returns the net.Listener's network address.
+	Addr() net.Addr
+}
+
+// maListener implements Listener
+type maListener struct {
+	net.Listener
+	laddr ma.Multiaddr
+}
+
+// NetListener returns the embedded net.Listener. Use with caution.
+func (l *maListener) NetListener() net.Listener {
+	return l.Listener
+}
+
+// Accept waits for and returns the next connection to the listener.
+// Returns a Multiaddr friendly Conn
+func (l *maListener) Accept() (Conn, error) {
+	nconn, err := l.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+
+	raddr, err := FromNetAddr(nconn.RemoteAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert connn.RemoteAddr: %s", err)
+	}
+
+	return &maConn{
+		Conn:  nconn,
+		laddr: l.laddr,
+		raddr: raddr,
+	}, nil
+}
+
+// Multiaddr returns the listener's (local) Multiaddr.
+func (l *maListener) Multiaddr() ma.Multiaddr {
+	return l.laddr
+}
+
+// Addr returns the listener's network address.
+func (l *maListener) Addr() net.Addr {
+	return l.Listener.Addr()
+}
+
+// Listen announces on the local network address laddr.
+// The Multiaddr must be a "ThinWaist" stream-oriented network:
+// ip4/tcp, ip6/tcp, (TODO: unix, unixpacket)
+// See Dial for the syntax of laddr.
+func Listen(laddr ma.Multiaddr) (Listener, error) {
+
+	// get the net.Listen friendly arguments from the remote addr
+	lnet, lnaddr, err := DialArgs(laddr)
+	if err != nil {
+		return nil, err
+	}
+
+	nl, err := net.Listen(lnet, lnaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return &maListener{
+		Listener: nl,
+		laddr:    laddr,
+	}, nil
+}
diff --git a/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net_test.go b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net_test.go
new file mode 100644
index 000000000..316a57afa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net_test.go
@@ -0,0 +1,200 @@
+package net
+
+import (
+	"bytes"
+	"net"
+	"sync"
+	"testing"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
+)
+
+func newMultiaddr(t *testing.T, m string) ma.Multiaddr {
+	maddr, err := ma.NewMultiaddr(m)
+	if err != nil {
+		t.Fatalf("failed to construct multiaddr: %s", m)
+	}
+	return maddr
+}
+
+func TestDial(t *testing.T) {
+
+	listener, err := net.Listen("tcp", "127.0.0.1:4321")
+	if err != nil {
+		t.Fatal("failed to listen")
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+
+		cB, err := listener.Accept()
+		if err != nil {
+			t.Fatal("failed to accept")
+		}
+
+		// echo out
+		buf := make([]byte, 1024)
+		for {
+			_, err := cB.Read(buf)
+			if err != nil {
+				break
+			}
+			cB.Write(buf)
+		}
+
+		wg.Done()
+	}()
+
+	maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4321")
+	cA, err := Dial(maddr)
+	if err != nil {
+		t.Fatal("failed to dial")
+	}
+
+	buf := make([]byte, 1024)
+	if _, err := cA.Write([]byte("beep boop")); err != nil {
+		t.Fatal("failed to write:", err)
+	}
+
+	if _, err := cA.Read(buf); err != nil {
+		t.Fatal("failed to read:", buf, err)
+	}
+
+	if !bytes.Equal(buf[:9], []byte("beep boop")) {
+		t.Fatal("failed to echo:", buf)
+	}
+
+	maddr2 := cA.RemoteMultiaddr()
+	if !maddr2.Equal(maddr) {
+		t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+	}
+
+	cA.Close()
+	wg.Wait()
+}
+
+func TestListen(t *testing.T) {
+
+	maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4322")
+	listener, err := Listen(maddr)
+	if err != nil {
+		t.Fatal("failed to listen")
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+
+		cB, err := listener.Accept()
+		if err != nil {
+			t.Fatal("failed to accept")
+		}
+
+		if !cB.LocalMultiaddr().Equal(maddr) {
+			t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
+		}
+
+		// echo out
+		buf := make([]byte, 1024)
+		for {
+			_, err := cB.Read(buf)
+			if err != nil {
+				break
+			}
+			cB.Write(buf)
+		}
+
+		wg.Done()
+	}()
+
+	cA, err := net.Dial("tcp", "127.0.0.1:4322")
+	if err != nil {
+		t.Fatal("failed to dial")
+	}
+
+	buf := make([]byte, 1024)
+	if _, err := cA.Write([]byte("beep boop")); err != nil {
+		t.Fatal("failed to write:", err)
+	}
+
+	if _, err := cA.Read(buf); err != nil {
+		t.Fatal("failed to read:", buf, err)
+	}
+
+	if !bytes.Equal(buf[:9], []byte("beep boop")) {
+		t.Fatal("failed to echo:", buf)
+	}
+
+	maddr2, err := FromNetAddr(cA.RemoteAddr())
+	if err != nil {
+		t.Fatal("failed to convert", err)
+	}
+	if !maddr2.Equal(maddr) {
+		t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+	}
+
+	cA.Close()
+	wg.Wait()
+}
+
+func TestListenAndDial(t *testing.T) {
+
+	maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4323")
+	listener, err := Listen(maddr)
+	if err != nil {
+		t.Fatal("failed to listen")
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+
+		cB, err := listener.Accept()
+		if err != nil {
+			t.Fatal("failed to accept")
+		}
+
+		if !cB.LocalMultiaddr().Equal(maddr) {
+			t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
+		}
+
+		// echo out
+		buf := make([]byte, 1024)
+		for {
+			_, err := cB.Read(buf)
+			if err != nil {
+				break
+			}
+			cB.Write(buf)
+		}
+
+		wg.Done()
+	}()
+
+	cA, err := Dial(newMultiaddr(t, "/ip4/127.0.0.1/tcp/4323"))
+	if err != nil {
+		t.Fatal("failed to dial")
+	}
+
+	buf := make([]byte, 1024)
+	if _, err := cA.Write([]byte("beep boop")); err != nil {
+		t.Fatal("failed to write:", err)
+	}
+
+	if _, err := cA.Read(buf); err != nil {
+		t.Fatal("failed to read:", buf, err)
+	}
+
+	if !bytes.Equal(buf[:9], []byte("beep boop")) {
+		t.Fatal("failed to echo:", buf)
+	}
+
+	maddr2 := cA.RemoteMultiaddr()
+	if !maddr2.Equal(maddr) {
+		t.Fatal("remote multiaddr not equal:", maddr, maddr2)
+	}
+
+	cA.Close()
+	wg.Wait()
+}
diff --git a/daemon/daemon.go b/daemon/daemon.go
index 735503d57..875779ed0 100644
--- a/daemon/daemon.go
+++ b/daemon/daemon.go
@@ -15,6 +15,7 @@ import (
 
 	lock "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/camlistore/lock"
 	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"
 )
 
 var log = u.Logger("daemon")
@@ -51,7 +52,7 @@ func NewDaemonListener(ipfsnode *core.IpfsNode, addr ma.Multiaddr, confdir strin
 		return nil, err
 	}
 
-	network, host, err := ma.DialArgs(addr)
+	network, host, err := manet.DialArgs(addr)
 	if err != nil {
 		return nil, err
 	}
diff --git a/daemon/daemon_client.go b/daemon/daemon_client.go
index 478b7fd7d..557aa2b1b 100644
--- a/daemon/daemon_client.go
+++ b/daemon/daemon_client.go
@@ -9,6 +9,7 @@ import (
 	"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"
 
 	u "github.com/jbenet/go-ipfs/util"
 )
@@ -73,7 +74,7 @@ func SendCommand(command *Command, confdir string) error {
 		return err
 	}
 
-	network, host, err := ma.DialArgs(maddr)
+	network, host, err := manet.DialArgs(maddr)
 
 	conn, err := net.Dial(network, host)
 	if err != nil {
diff --git a/net/conn/conn.go b/net/conn/conn.go
index ef3619b24..2bf6bb95e 100644
--- a/net/conn/conn.go
+++ b/net/conn/conn.go
@@ -6,6 +6,7 @@ import (
 
 	msgio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio"
 	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"
 
 	spipe "github.com/jbenet/go-ipfs/crypto/spipe"
 	peer "github.com/jbenet/go-ipfs/peer"
@@ -58,7 +59,7 @@ func Dial(network string, peer *peer.Peer) (*Conn, error) {
 		return nil, fmt.Errorf("No address for network %s", network)
 	}
 
-	network, host, err := ma.DialArgs(addr)
+	network, host, err := manet.DialArgs(addr)
 	if err != nil {
 		return nil, err
 	}
@@ -107,5 +108,5 @@ func (c *Conn) Close() error {
 // NetConnMultiaddr returns the net.Conn's address, recast as a multiaddr.
 // (consider moving this directly into the multiaddr package)
 func NetConnMultiaddr(nconn net.Conn) (ma.Multiaddr, error) {
-	return ma.FromNetAddr(nconn.RemoteAddr())
+	return manet.FromNetAddr(nconn.RemoteAddr())
 }
diff --git a/net/swarm/conn.go b/net/swarm/conn.go
index a2577f186..86c8df5d3 100644
--- a/net/swarm/conn.go
+++ b/net/swarm/conn.go
@@ -10,6 +10,7 @@ import (
 	msg "github.com/jbenet/go-ipfs/net/message"
 
 	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"
 )
 
 // Open listeners for each network the swarm should listen on
@@ -37,7 +38,7 @@ func (s *Swarm) listen() error {
 
 // Listen for new connections on the given multiaddr
 func (s *Swarm) connListen(maddr ma.Multiaddr) error {
-	netstr, addr, err := ma.DialArgs(maddr)
+	netstr, addr, err := manet.DialArgs(maddr)
 	if err != nil {
 		return err
 	}
diff --git a/net/swarm/swarm_test.go b/net/swarm/swarm_test.go
index 7d7c13802..5effe2909 100644
--- a/net/swarm/swarm_test.go
+++ b/net/swarm/swarm_test.go
@@ -12,6 +12,7 @@ import (
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 	msgio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio"
 	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"
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
 )
 
@@ -95,7 +96,7 @@ func TestSwarm(t *testing.T) {
 		if a == nil {
 			t.Fatal("error setting up peer (addr is nil)", peer)
 		}
-		n, h, err := ma.DialArgs(a)
+		n, h, err := manet.DialArgs(a)
 		if err != nil {
 			t.Fatal("error getting dial args from addr")
 		}
diff --git a/server/http/http.go b/server/http/http.go
index 14eff9cd2..2aae48aa3 100644
--- a/server/http/http.go
+++ b/server/http/http.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/gorilla/mux"
 	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"
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
 
 	core "github.com/jbenet/go-ipfs/core"
@@ -24,7 +25,7 @@ func Serve(address ma.Multiaddr, node *core.IpfsNode) error {
 	r.PathPrefix("/ipfs/").Handler(handler).Methods("GET")
 	http.Handle("/", r)
 
-	_, host, err := ma.DialArgs(address)
+	_, host, err := manet.DialArgs(address)
 	if err != nil {
 		return err
 	}

From 0bd64e7f7137700f573d393d7a6e8d48fd644f8c Mon Sep 17 00:00:00 2001
From: Juan Batiz-Benet <juan@benet.ai>
Date: Sat, 11 Oct 2014 03:24:33 -0700
Subject: [PATCH 2/2] move net -> multiaddr/net

transition our use of the net package to multiaddr/net
---
 daemon/daemon.go        | 12 +++---------
 daemon/daemon_client.go |  5 +----
 net/conn/conn.go        | 20 ++++----------------
 net/conn/conn_test.go   | 14 +++++++++-----
 net/swarm/conn.go       | 21 +++++----------------
 net/swarm/swarm.go      |  4 ++--
 net/swarm/swarm_test.go | 17 ++++++-----------
 7 files changed, 30 insertions(+), 63 deletions(-)

diff --git a/daemon/daemon.go b/daemon/daemon.go
index 875779ed0..5156e741d 100644
--- a/daemon/daemon.go
+++ b/daemon/daemon.go
@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"net"
 	"os"
 	"path"
 	"sync"
@@ -27,7 +26,7 @@ const LockFile = "daemon.lock"
 // starting up a new set of connections
 type DaemonListener struct {
 	node   *core.IpfsNode
-	list   net.Listener
+	list   manet.Listener
 	closed bool
 	wg     sync.WaitGroup
 	lk     io.Closer
@@ -52,11 +51,6 @@ func NewDaemonListener(ipfsnode *core.IpfsNode, addr ma.Multiaddr, confdir strin
 		return nil, err
 	}
 
-	network, host, err := manet.DialArgs(addr)
-	if err != nil {
-		return nil, err
-	}
-
 	ofi, err := os.Create(confdir + "/rpcaddress")
 	if err != nil {
 		log.Warning("Could not create rpcaddress file: %s", err)
@@ -70,7 +64,7 @@ func NewDaemonListener(ipfsnode *core.IpfsNode, addr ma.Multiaddr, confdir strin
 	}
 	ofi.Close()
 
-	list, err := net.Listen(network, host)
+	list, err := manet.Listen(addr)
 	if err != nil {
 		return nil, err
 	}
@@ -111,7 +105,7 @@ func (dl *DaemonListener) Listen() {
 	}
 }
 
-func (dl *DaemonListener) handleConnection(conn net.Conn) {
+func (dl *DaemonListener) handleConnection(conn manet.Conn) {
 	defer conn.Close()
 
 	dec := json.NewDecoder(conn)
diff --git a/daemon/daemon_client.go b/daemon/daemon_client.go
index 557aa2b1b..8db861535 100644
--- a/daemon/daemon_client.go
+++ b/daemon/daemon_client.go
@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
-	"net"
 	"os"
 
 	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
@@ -74,9 +73,7 @@ func SendCommand(command *Command, confdir string) error {
 		return err
 	}
 
-	network, host, err := manet.DialArgs(maddr)
-
-	conn, err := net.Dial(network, host)
+	conn, err := manet.Dial(maddr)
 	if err != nil {
 		return err
 	}
diff --git a/net/conn/conn.go b/net/conn/conn.go
index 2bf6bb95e..dcf6c9231 100644
--- a/net/conn/conn.go
+++ b/net/conn/conn.go
@@ -2,7 +2,6 @@ package conn
 
 import (
 	"fmt"
-	"net"
 
 	msgio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio"
 	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
@@ -25,7 +24,7 @@ const MaxMessageSize = 1 << 20
 type Conn struct {
 	Peer *peer.Peer
 	Addr ma.Multiaddr
-	Conn net.Conn
+	Conn manet.Conn
 
 	Closed   chan bool
 	Outgoing *msgio.Chan
@@ -37,11 +36,11 @@ type Conn struct {
 type Map map[u.Key]*Conn
 
 // NewConn constructs a new connection
-func NewConn(peer *peer.Peer, addr ma.Multiaddr, nconn net.Conn) (*Conn, error) {
+func NewConn(peer *peer.Peer, addr ma.Multiaddr, mconn manet.Conn) (*Conn, error) {
 	conn := &Conn{
 		Peer: peer,
 		Addr: addr,
-		Conn: nconn,
+		Conn: mconn,
 	}
 
 	if err := conn.newChans(); err != nil {
@@ -59,12 +58,7 @@ func Dial(network string, peer *peer.Peer) (*Conn, error) {
 		return nil, fmt.Errorf("No address for network %s", network)
 	}
 
-	network, host, err := manet.DialArgs(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	nconn, err := net.Dial(network, host)
+	nconn, err := manet.Dial(addr)
 	if err != nil {
 		return nil, err
 	}
@@ -104,9 +98,3 @@ func (c *Conn) Close() error {
 	c.Closed <- true
 	return err
 }
-
-// NetConnMultiaddr returns the net.Conn's address, recast as a multiaddr.
-// (consider moving this directly into the multiaddr package)
-func NetConnMultiaddr(nconn net.Conn) (ma.Multiaddr, error) {
-	return manet.FromNetAddr(nconn.RemoteAddr())
-}
diff --git a/net/conn/conn_test.go b/net/conn/conn_test.go
index 219004be8..95d5833df 100644
--- a/net/conn/conn_test.go
+++ b/net/conn/conn_test.go
@@ -1,12 +1,12 @@
 package conn
 
 import (
-	"net"
 	"testing"
 
 	peer "github.com/jbenet/go-ipfs/peer"
 
 	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"
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
 )
 
@@ -26,7 +26,7 @@ func setupPeer(id string, addr string) (*peer.Peer, error) {
 	return p, nil
 }
 
-func echoListen(listener *net.TCPListener) {
+func echoListen(listener manet.Listener) {
 	for {
 		c, err := listener.Accept()
 		if err == nil {
@@ -36,7 +36,7 @@ func echoListen(listener *net.TCPListener) {
 	}
 }
 
-func echo(c net.Conn) {
+func echo(c manet.Conn) {
 	for {
 		data := make([]byte, 1024)
 		i, err := c.Read(data)
@@ -55,11 +55,15 @@ func echo(c net.Conn) {
 
 func TestDial(t *testing.T) {
 
-	listener, err := net.Listen("tcp", "127.0.0.1:1234")
+	maddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/1234")
+	if err != nil {
+		t.Fatal("failure to parse multiaddr")
+	}
+	listener, err := manet.Listen(maddr)
 	if err != nil {
 		t.Fatal("error setting up listener", err)
 	}
-	go echoListen(listener.(*net.TCPListener))
+	go echoListen(listener)
 
 	p, err := setupPeer("11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", "/ip4/127.0.0.1/tcp/1234")
 	if err != nil {
diff --git a/net/swarm/conn.go b/net/swarm/conn.go
index 86c8df5d3..7d5c47b5c 100644
--- a/net/swarm/conn.go
+++ b/net/swarm/conn.go
@@ -3,7 +3,6 @@ package swarm
 import (
 	"errors"
 	"fmt"
-	"net"
 
 	spipe "github.com/jbenet/go-ipfs/crypto/spipe"
 	conn "github.com/jbenet/go-ipfs/net/conn"
@@ -26,7 +25,7 @@ func (s *Swarm) listen() error {
 		if err != nil {
 			hasErr = true
 			retErr.Errors[i] = err
-			log.Error("Failed to listen on: %s [%s]", addr, err)
+			log.Error("Failed to listen on: %s - %s", addr, err)
 		}
 	}
 
@@ -38,12 +37,7 @@ func (s *Swarm) listen() error {
 
 // Listen for new connections on the given multiaddr
 func (s *Swarm) connListen(maddr ma.Multiaddr) error {
-	netstr, addr, err := manet.DialArgs(maddr)
-	if err != nil {
-		return err
-	}
-
-	list, err := net.Listen(netstr, addr)
+	list, err := manet.Listen(maddr)
 	if err != nil {
 		return err
 	}
@@ -56,8 +50,7 @@ func (s *Swarm) connListen(maddr ma.Multiaddr) error {
 		for {
 			nconn, err := list.Accept()
 			if err != nil {
-				e := fmt.Errorf("Failed to accept connection: %s - %s [%s]",
-					netstr, addr, err)
+				e := fmt.Errorf("Failed to accept connection: %s - %s", maddr, err)
 				s.errChan <- e
 
 				// if cancel is nil, we're closed.
@@ -74,13 +67,9 @@ func (s *Swarm) connListen(maddr ma.Multiaddr) error {
 }
 
 // Handle getting ID from this peer, handshake, and adding it into the map
-func (s *Swarm) handleIncomingConn(nconn net.Conn) {
+func (s *Swarm) handleIncomingConn(nconn manet.Conn) {
 
-	addr, err := conn.NetConnMultiaddr(nconn)
-	if err != nil {
-		s.errChan <- err
-		return
-	}
+	addr := nconn.RemoteMultiaddr()
 
 	// Construct conn with nil peer for now, because we don't know its ID yet.
 	// connSetup will figure this out, and pull out / construct the peer.
diff --git a/net/swarm/swarm.go b/net/swarm/swarm.go
index fffc1fcef..057e4ad26 100644
--- a/net/swarm/swarm.go
+++ b/net/swarm/swarm.go
@@ -3,7 +3,6 @@ package swarm
 import (
 	"errors"
 	"fmt"
-	"net"
 	"sync"
 
 	conn "github.com/jbenet/go-ipfs/net/conn"
@@ -13,6 +12,7 @@ import (
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 	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"
 )
 
 var log = u.Logger("swarm")
@@ -62,7 +62,7 @@ type Swarm struct {
 	connsLock sync.RWMutex
 
 	// listeners for each network address
-	listeners []net.Listener
+	listeners []manet.Listener
 
 	// cancel is an internal function used to stop the Swarm's processing.
 	cancel context.CancelFunc
diff --git a/net/swarm/swarm_test.go b/net/swarm/swarm_test.go
index 5effe2909..88de9198d 100644
--- a/net/swarm/swarm_test.go
+++ b/net/swarm/swarm_test.go
@@ -2,7 +2,6 @@ package swarm
 
 import (
 	"fmt"
-	"net"
 	"testing"
 
 	msg "github.com/jbenet/go-ipfs/net/message"
@@ -16,7 +15,7 @@ import (
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
 )
 
-func pingListen(t *testing.T, listener *net.TCPListener, peer *peer.Peer) {
+func pingListen(t *testing.T, listener manet.Listener, peer *peer.Peer) {
 	for {
 		c, err := listener.Accept()
 		if err == nil {
@@ -25,7 +24,7 @@ func pingListen(t *testing.T, listener *net.TCPListener, peer *peer.Peer) {
 	}
 }
 
-func pong(t *testing.T, c net.Conn, peer *peer.Peer) {
+func pong(t *testing.T, c manet.Conn, peer *peer.Peer) {
 	mrw := msgio.NewReadWriter(c)
 	for {
 		data := make([]byte, 1024)
@@ -79,7 +78,7 @@ func TestSwarm(t *testing.T) {
 		t.Error(err)
 	}
 	var peers []*peer.Peer
-	var listeners []net.Listener
+	var listeners []manet.Listener
 	peerNames := map[string]string{
 		"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a31": "/ip4/127.0.0.1/tcp/2345",
 		"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a32": "/ip4/127.0.0.1/tcp/3456",
@@ -96,15 +95,11 @@ func TestSwarm(t *testing.T) {
 		if a == nil {
 			t.Fatal("error setting up peer (addr is nil)", peer)
 		}
-		n, h, err := manet.DialArgs(a)
-		if err != nil {
-			t.Fatal("error getting dial args from addr")
-		}
-		listener, err := net.Listen(n, h)
+		listener, err := manet.Listen(a)
 		if err != nil {
 			t.Fatal("error setting up listener", err)
 		}
-		go pingListen(t, listener.(*net.TCPListener), peer)
+		go pingListen(t, listener, peer)
 
 		_, err = swarm.Dial(peer)
 		if err != nil {
@@ -147,6 +142,6 @@ func TestSwarm(t *testing.T) {
 
 	swarm.Close()
 	for _, listener := range listeners {
-		listener.(*net.TCPListener).Close()
+		listener.Close()
 	}
 }