opensource/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2025-06-28 08:47:42 +08:00
Code Issues Projects Releases Wiki Activity

Merge pull request #154 from jbenet/manet

Browse Source 
use multiaddr/net
This commit is contained in:
Juan Batiz-Benet
2014-10-11 03:32:42 -07:00
parent 26c4e5004c 0bd64e7f71
commit 947d24291e
16 changed files with 511 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Godeps/Godeps.json generated
View File

@ -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",

10
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,10 @@
language: go
go:
- 1.2
- 1.3
- release
- tip
script:
- go test -v ./...

11
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/README.md generated vendored Normal file
View File

@ -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

28
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net.go → Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert.go generated vendored
View File

@ -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

22
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net_test.go → Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert_test.go generated vendored
View File

@ -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")
}

5
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/doc.go generated vendored Normal file
View File

@ -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

218
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net.go generated vendored Normal file
View File

@ -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
}

200
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net_test.go generated vendored Normal file
View File

@ -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()
}

13
daemon/daemon.go
View File

@ -4,7 +4,6 @@ import (
"encoding/json"
"fmt"
"io"
"net"
"os"
"path"
"sync"
@ -15,6 +14,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")
@ -26,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
@ -51,11 +51,6 @@ func NewDaemonListener(ipfsnode *core.IpfsNode, addr ma.Multiaddr, confdir strin
return nil, err
}
network, host, err := ma.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)
@ -69,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
}
@ -110,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)

6
daemon/daemon_client.go
View File

@ -5,10 +5,10 @@ import (
"encoding/json"
"errors"
"io"
"net"
"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,9 +73,7 @@ func SendCommand(command *Command, confdir string) error {
return err
}
network, host, err := ma.DialArgs(maddr)
conn, err := net.Dial(network, host)
conn, err := manet.Dial(maddr)
if err != nil {
return err
}

21
net/conn/conn.go
View File

@ -2,10 +2,10 @@ 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"
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"
@ -24,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
@ -36,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 {
@ -58,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 := ma.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
}
@ -103,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 ma.FromNetAddr(nconn.RemoteAddr())
}

14
net/conn/conn_test.go
View File

@ -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 {

22
net/swarm/conn.go
View File

@ -3,13 +3,13 @@ package swarm
import (
"errors"
"fmt"
"net"
spipe "github.com/jbenet/go-ipfs/crypto/spipe"
conn "github.com/jbenet/go-ipfs/net/conn"
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
@ -25,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)
}
}
@ -37,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 := ma.DialArgs(maddr)
if err != nil {
return err
}
list, err := net.Listen(netstr, addr)
list, err := manet.Listen(maddr)
if err != nil {
return err
}
@ -55,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.
@ -73,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.

4
net/swarm/swarm.go
View File

@ -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

18
net/swarm/swarm_test.go
View File

@ -2,7 +2,6 @@ package swarm
import (
"fmt"
"net"
"testing"
msg "github.com/jbenet/go-ipfs/net/message"
@ -12,10 +11,11 @@ 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"
)
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 {
@ -24,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)
@ -78,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",
@ -95,15 +95,11 @@ func TestSwarm(t *testing.T) {
if a == nil {
t.Fatal("error setting up peer (addr is nil)", peer)
}
n, h, err := ma.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 {
@ -146,6 +142,6 @@ func TestSwarm(t *testing.T) {
swarm.Close()
for _, listener := range listeners {
listener.(*net.TCPListener).Close()
listener.Close()
}
}

3
server/http/http.go
View File

@ -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
}