@cryptotaxi247 / kubo / commits / 917be9043

updated multiaddr for net pkg

Juan Batiz-Benet committed Oct 11, 2014 at 03:02 UTC 917be904376b1a5b1b454c87f6e9c6a35e38e53e
14 files changed +487 -33
Godeps/Godeps.json
+3 -3
@@ -1,6 +1,6 @@
1 {
2 "ImportPath": "github.com/jbenet/go-ipfs",
3 - "GoVersion": "go1.3.3",
3 + "GoVersion": "go1.3",
4 "Packages": [
5 "./..."
6 ],
@@ -84,8 +84,8 @@
84 },
85 {
86 "ImportPath": "github.com/jbenet/go-multiaddr",
87 - "Comment": "0.1.2-11-g2a572df",
88 - "Rev": "2a572df05cbbb3a0b0b3d0095a9af16757cbbf9f"
87 + "Comment": "0.1.2-17-g68a2067",
88 + "Rev": "68a20675cb0829da219def0d90afe17a7219e8c7"
89 },
90 {
91 "ImportPath": "github.com/jbenet/go-multihash",
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/.travis.yml new
+10
@@ -0,0 +1,10 @@
1 +language: go
2 +
3 +go:
4 + - 1.2
5 + - 1.3
6 + - release
7 + - tip
8 +
9 +script:
10 + - go test -v ./...
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/README.md new
+11
@@ -0,0 +1,11 @@
1 +# multiaddr/net - Multiaddr friendly net
2 +
3 +Package multiaddr/net provides Multiaddr specific versions of common
4 +functions in stdlib's net package. This means wrappers of
5 +standard net symbols like net.Dial and net.Listen, as well
6 +as conversion to/from net.Addr.
7 +
8 +Docs:
9 +
10 +- `multiaddr/net`: https://godoc.org/github.com/jbenet/go-multiaddr/net
11 +- `multiaddr`: https://godoc.org/github.com/jbenet/go-multiaddr
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert.go renamed
+15 -13
@@ -1,15 +1,17 @@
1 -package multiaddr
1 +package net
2
3 import (
4 "fmt"
5 "net"
6 "strings"
7 +
8 + ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
9 )
10
11 var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
12
13 // FromNetAddr converts a net.Addr type to a Multiaddr.
12 -func FromNetAddr(a net.Addr) (Multiaddr, error) {
14 +func FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
15 switch a.Network() {
16 case "tcp", "tcp4", "tcp6":
17 ac, ok := a.(*net.TCPAddr)
@@ -24,7 +26,7 @@ func FromNetAddr(a net.Addr) (Multiaddr, error) {
26 }
27
28 // Get TCP Addr
27 - tcpm, err := NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
29 + tcpm, err := ma.NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
30 if err != nil {
31 return nil, errIncorrectNetAddr
32 }
@@ -45,7 +47,7 @@ func FromNetAddr(a net.Addr) (Multiaddr, error) {
47 }
48
49 // Get UDP Addr
48 - udpm, err := NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
50 + udpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
51 if err != nil {
52 return nil, errIncorrectNetAddr
53 }
@@ -68,8 +70,8 @@ func FromNetAddr(a net.Addr) (Multiaddr, error) {
70 // ToNetAddr converts a Multiaddr to a net.Addr
71 // Must be ThinWaist. acceptable protocol stacks are:
72 // /ip{4,6}/{tcp, udp}
71 -func ToNetAddr(ma Multiaddr) (net.Addr, error) {
72 - network, host, err := DialArgs(ma)
73 +func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
74 + network, host, err := DialArgs(maddr)
75 if err != nil {
76 return nil, err
77 }
@@ -87,19 +89,19 @@ func ToNetAddr(ma Multiaddr) (net.Addr, error) {
89 }
90
91 // FromIP converts a net.IP type to a Multiaddr.
90 -func FromIP(ip net.IP) (Multiaddr, error) {
92 +func FromIP(ip net.IP) (ma.Multiaddr, error) {
93 switch {
94 case ip.To4() != nil:
93 - return NewMultiaddr("/ip4/" + ip.String())
95 + return ma.NewMultiaddr("/ip4/" + ip.String())
96 case ip.To16() != nil:
95 - return NewMultiaddr("/ip6/" + ip.String())
97 + return ma.NewMultiaddr("/ip6/" + ip.String())
98 default:
99 return nil, errIncorrectNetAddr
100 }
101 }
102
103 // DialArgs is a convenience function returning arguments for use in net.Dial
102 -func DialArgs(m Multiaddr) (string, string, error) {
104 +func DialArgs(m ma.Multiaddr) (string, string, error) {
105 if !IsThinWaist(m) {
106 return "", "", fmt.Errorf("%s is not a 'thin waist' address", m)
107 }
@@ -124,7 +126,7 @@ func DialArgs(m Multiaddr) (string, string, error) {
126
127 // IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols.
128 // This means: /{IP4, IP6}[/{TCP, UDP}]
127 -func IsThinWaist(m Multiaddr) bool {
129 +func IsThinWaist(m ma.Multiaddr) bool {
130 p := m.Protocols()
131
132 // nothing? not even a waist.
@@ -132,7 +134,7 @@ func IsThinWaist(m Multiaddr) bool {
134 return false
135 }
136
135 - if p[0].Code != P_IP4 && p[0].Code != P_IP6 {
137 + if p[0].Code != ma.P_IP4 && p[0].Code != ma.P_IP6 {
138 return false
139 }
140
@@ -142,7 +144,7 @@ func IsThinWaist(m Multiaddr) bool {
144 }
145
146 switch p[1].Code {
145 - case P_TCP, P_UDP, P_IP4, P_IP6:
147 + case ma.P_TCP, ma.P_UDP, ma.P_IP4, ma.P_IP6:
148 return true
149 default:
150 return false
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/convert_test.go renamed
+12 -10
@@ -1,11 +1,13 @@
1 -package multiaddr
1 +package net
2
3 import (
4 "net"
5 "testing"
6 +
7 + ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
8 )
9
8 -type GenFunc func() (Multiaddr, error)
10 +type GenFunc func() (ma.Multiaddr, error)
11
12 func testConvert(t *testing.T, s string, gen GenFunc) {
13 m, err := gen()
@@ -19,7 +21,7 @@ func testConvert(t *testing.T, s string, gen GenFunc) {
21 }
22
23 func testToNetAddr(t *testing.T, maddr, ntwk, addr string) {
22 - m, err := NewMultiaddr(maddr)
24 + m, err := ma.NewMultiaddr(maddr)
25 if err != nil {
26 t.Fatal("failed to generate.")
27 }
@@ -57,19 +59,19 @@ func testToNetAddr(t *testing.T, maddr, ntwk, addr string) {
59 }
60
61 func TestFromIP4(t *testing.T) {
60 - testConvert(t, "/ip4/10.20.30.40", func() (Multiaddr, error) {
62 + testConvert(t, "/ip4/10.20.30.40", func() (ma.Multiaddr, error) {
63 return FromIP(net.ParseIP("10.20.30.40"))
64 })
65 }
66
67 func TestFromIP6(t *testing.T) {
66 - testConvert(t, "/ip6/2001:4860:0:2001::68", func() (Multiaddr, error) {
68 + testConvert(t, "/ip6/2001:4860:0:2001::68", func() (ma.Multiaddr, error) {
69 return FromIP(net.ParseIP("2001:4860:0:2001::68"))
70 })
71 }
72
73 func TestFromTCP(t *testing.T) {
72 - testConvert(t, "/ip4/10.20.30.40/tcp/1234", func() (Multiaddr, error) {
74 + testConvert(t, "/ip4/10.20.30.40/tcp/1234", func() (ma.Multiaddr, error) {
75 return FromNetAddr(&net.TCPAddr{
76 IP: net.ParseIP("10.20.30.40"),
77 Port: 1234,
@@ -78,7 +80,7 @@ func TestFromTCP(t *testing.T) {
80 }
81
82 func TestFromUDP(t *testing.T) {
81 - testConvert(t, "/ip4/10.20.30.40/udp/1234", func() (Multiaddr, error) {
83 + testConvert(t, "/ip4/10.20.30.40/udp/1234", func() (ma.Multiaddr, error) {
84 return FromNetAddr(&net.UDPAddr{
85 IP: net.ParseIP("10.20.30.40"),
86 Port: 1234,
@@ -103,19 +105,19 @@ func TestThinWaist(t *testing.T) {
105 }
106
107 for a, res := range addrs {
106 - ma, err := NewMultiaddr(a)
108 + m, err := ma.NewMultiaddr(a)
109 if err != nil {
110 t.Fatalf("failed to construct Multiaddr: %s", a)
111 }
112
111 - if IsThinWaist(ma) != res {
113 + if IsThinWaist(m) != res {
114 t.Fatalf("IsThinWaist(%s) != %v", a, res)
115 }
116 }
117 }
118
119 func TestDialArgs(t *testing.T) {
118 - m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
120 + m, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
121 if err != nil {
122 t.Fatal("failed to construct", "/ip4/127.0.0.1/udp/1234")
123 }
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/doc.go new
+5
@@ -0,0 +1,5 @@
1 +// Package net provides Multiaddr specific versions of common
2 +// functions in stdlib's net package. This means wrappers of
3 +// standard net symbols like net.Dial and net.Listen, as well
4 +// as conversion to/from net.Addr.
5 +package net
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net.go new
+218
@@ -0,0 +1,218 @@
1 +package net
2 +
3 +import (
4 + "fmt"
5 + "net"
6 +
7 + ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
8 +)
9 +
10 +// Conn is the equivalent of a net.Conn object. It is the
11 +// result of calling the Dial or Listen functions in this
12 +// package, with associated local and remote Multiaddrs.
13 +type Conn interface {
14 + net.Conn
15 +
16 + // LocalMultiaddr returns the local Multiaddr associated
17 + // with this connection
18 + LocalMultiaddr() ma.Multiaddr
19 +
20 + // RemoteMultiaddr returns the remote Multiaddr associated
21 + // with this connection
22 + RemoteMultiaddr() ma.Multiaddr
23 +}
24 +
25 +// WrapNetConn wraps a net.Conn object with a Multiaddr
26 +// friendly Conn.
27 +func WrapNetConn(nconn net.Conn) (Conn, error) {
28 +
29 + laddr, err := FromNetAddr(nconn.LocalAddr())
30 + if err != nil {
31 + return nil, fmt.Errorf("failed to convert nconn.LocalAddr: %s", err)
32 + }
33 +
34 + raddr, err := FromNetAddr(nconn.RemoteAddr())
35 + if err != nil {
36 + return nil, fmt.Errorf("failed to convert nconn.RemoteAddr: %s", err)
37 + }
38 +
39 + return &maConn{
40 + Conn: nconn,
41 + laddr: laddr,
42 + raddr: raddr,
43 + }, nil
44 +}
45 +
46 +// maConn implements the Conn interface. It's a thin wrapper
47 +// around a net.Conn
48 +type maConn struct {
49 + net.Conn
50 + laddr ma.Multiaddr
51 + raddr ma.Multiaddr
52 +}
53 +
54 +// LocalMultiaddr returns the local address associated with
55 +// this connection
56 +func (c *maConn) LocalMultiaddr() ma.Multiaddr {
57 + return c.laddr
58 +}
59 +
60 +// RemoteMultiaddr returns the remote address associated with
61 +// this connection
62 +func (c *maConn) RemoteMultiaddr() ma.Multiaddr {
63 + return c.raddr
64 +}
65 +
66 +// Dialer contains options for connecting to an address. It
67 +// is effectively the same as net.Dialer, but its LocalAddr
68 +// and RemoteAddr options are Multiaddrs, instead of net.Addrs.
69 +type Dialer struct {
70 +
71 + // Dialer is just an embed net.Dialer, with all its options.
72 + net.Dialer
73 +
74 + // LocalAddr is the local address to use when dialing an
75 + // address. The address must be of a compatible type for the
76 + // network being dialed.
77 + // If nil, a local address is automatically chosen.
78 + LocalAddr ma.Multiaddr
79 +}
80 +
81 +// Dial connects to a remote address, using the options of the
82 +// Dialer. Dialer uses an underlying net.Dialer to Dial a
83 +// net.Conn, then wraps that in a Conn object (with local and
84 +// remote Multiaddrs).
85 +func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
86 +
87 + // if a LocalAddr is specified, use it on the embedded dialer.
88 + if d.LocalAddr != nil {
89 + // convert our multiaddr to net.Addr friendly
90 + naddr, err := ToNetAddr(d.LocalAddr)
91 + if err != nil {
92 + return nil, err
93 + }
94 +
95 + // set the dialer's LocalAddr as naddr
96 + d.Dialer.LocalAddr = naddr
97 + }
98 +
99 + // get the net.Dial friendly arguments from the remote addr
100 + rnet, rnaddr, err := DialArgs(remote)
101 + if err != nil {
102 + return nil, err
103 + }
104 +
105 + // ok, Dial!
106 + nconn, err := d.Dialer.Dial(rnet, rnaddr)
107 + if err != nil {
108 + return nil, err
109 + }
110 +
111 + // get local address (pre-specified or assigned within net.Conn)
112 + local := d.LocalAddr
113 + if local == nil {
114 + local, err = FromNetAddr(nconn.LocalAddr())
115 + if err != nil {
116 + return nil, err
117 + }
118 + }
119 +
120 + return &maConn{
121 + Conn: nconn,
122 + laddr: local,
123 + raddr: remote,
124 + }, nil
125 +}
126 +
127 +// Dial connects to a remote address. It uses an underlying net.Conn,
128 +// then wraps it in a Conn object (with local and remote Multiaddrs).
129 +func Dial(remote ma.Multiaddr) (Conn, error) {
130 + return (&Dialer{}).Dial(remote)
131 +}
132 +
133 +// A Listener is a generic network listener for stream-oriented protocols.
134 +// it uses an embedded net.Listener, overriding net.Listener.Accept to
135 +// return a Conn and providing Multiaddr.
136 +type Listener interface {
137 +
138 + // NetListener returns the embedded net.Listener. Use with caution.
139 + NetListener() net.Listener
140 +
141 + // Accept waits for and returns the next connection to the listener.
142 + // Returns a Multiaddr friendly Conn
143 + Accept() (Conn, error)
144 +
145 + // Close closes the listener.
146 + // Any blocked Accept operations will be unblocked and return errors.
147 + Close() error
148 +
149 + // Multiaddr returns the listener's (local) Multiaddr.
150 + Multiaddr() ma.Multiaddr
151 +
152 + // Addr returns the net.Listener's network address.
153 + Addr() net.Addr
154 +}
155 +
156 +// maListener implements Listener
157 +type maListener struct {
158 + net.Listener
159 + laddr ma.Multiaddr
160 +}
161 +
162 +// NetListener returns the embedded net.Listener. Use with caution.
163 +func (l *maListener) NetListener() net.Listener {
164 + return l.Listener
165 +}
166 +
167 +// Accept waits for and returns the next connection to the listener.
168 +// Returns a Multiaddr friendly Conn
169 +func (l *maListener) Accept() (Conn, error) {
170 + nconn, err := l.Listener.Accept()
171 + if err != nil {
172 + return nil, err
173 + }
174 +
175 + raddr, err := FromNetAddr(nconn.RemoteAddr())
176 + if err != nil {
177 + return nil, fmt.Errorf("failed to convert connn.RemoteAddr: %s", err)
178 + }
179 +
180 + return &maConn{
181 + Conn: nconn,
182 + laddr: l.laddr,
183 + raddr: raddr,
184 + }, nil
185 +}
186 +
187 +// Multiaddr returns the listener's (local) Multiaddr.
188 +func (l *maListener) Multiaddr() ma.Multiaddr {
189 + return l.laddr
190 +}
191 +
192 +// Addr returns the listener's network address.
193 +func (l *maListener) Addr() net.Addr {
194 + return l.Listener.Addr()
195 +}
196 +
197 +// Listen announces on the local network address laddr.
198 +// The Multiaddr must be a "ThinWaist" stream-oriented network:
199 +// ip4/tcp, ip6/tcp, (TODO: unix, unixpacket)
200 +// See Dial for the syntax of laddr.
201 +func Listen(laddr ma.Multiaddr) (Listener, error) {
202 +
203 + // get the net.Listen friendly arguments from the remote addr
204 + lnet, lnaddr, err := DialArgs(laddr)
205 + if err != nil {
206 + return nil, err
207 + }
208 +
209 + nl, err := net.Listen(lnet, lnaddr)
210 + if err != nil {
211 + return nil, err
212 + }
213 +
214 + return &maListener{
215 + Listener: nl,
216 + laddr: laddr,
217 + }, nil
218 +}
Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net/net_test.go new
+200
@@ -0,0 +1,200 @@
1 +package net
2 +
3 +import (
4 + "bytes"
5 + "net"
6 + "sync"
7 + "testing"
8 +
9 + ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
10 +)
11 +
12 +func newMultiaddr(t *testing.T, m string) ma.Multiaddr {
13 + maddr, err := ma.NewMultiaddr(m)
14 + if err != nil {
15 + t.Fatalf("failed to construct multiaddr: %s", m)
16 + }
17 + return maddr
18 +}
19 +
20 +func TestDial(t *testing.T) {
21 +
22 + listener, err := net.Listen("tcp", "127.0.0.1:4321")
23 + if err != nil {
24 + t.Fatal("failed to listen")
25 + }
26 +
27 + var wg sync.WaitGroup
28 + wg.Add(1)
29 + go func() {
30 +
31 + cB, err := listener.Accept()
32 + if err != nil {
33 + t.Fatal("failed to accept")
34 + }
35 +
36 + // echo out
37 + buf := make([]byte, 1024)
38 + for {
39 + _, err := cB.Read(buf)
40 + if err != nil {
41 + break
42 + }
43 + cB.Write(buf)
44 + }
45 +
46 + wg.Done()
47 + }()
48 +
49 + maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4321")
50 + cA, err := Dial(maddr)
51 + if err != nil {
52 + t.Fatal("failed to dial")
53 + }
54 +
55 + buf := make([]byte, 1024)
56 + if _, err := cA.Write([]byte("beep boop")); err != nil {
57 + t.Fatal("failed to write:", err)
58 + }
59 +
60 + if _, err := cA.Read(buf); err != nil {
61 + t.Fatal("failed to read:", buf, err)
62 + }
63 +
64 + if !bytes.Equal(buf[:9], []byte("beep boop")) {
65 + t.Fatal("failed to echo:", buf)
66 + }
67 +
68 + maddr2 := cA.RemoteMultiaddr()
69 + if !maddr2.Equal(maddr) {
70 + t.Fatal("remote multiaddr not equal:", maddr, maddr2)
71 + }
72 +
73 + cA.Close()
74 + wg.Wait()
75 +}
76 +
77 +func TestListen(t *testing.T) {
78 +
79 + maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4322")
80 + listener, err := Listen(maddr)
81 + if err != nil {
82 + t.Fatal("failed to listen")
83 + }
84 +
85 + var wg sync.WaitGroup
86 + wg.Add(1)
87 + go func() {
88 +
89 + cB, err := listener.Accept()
90 + if err != nil {
91 + t.Fatal("failed to accept")
92 + }
93 +
94 + if !cB.LocalMultiaddr().Equal(maddr) {
95 + t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
96 + }
97 +
98 + // echo out
99 + buf := make([]byte, 1024)
100 + for {
101 + _, err := cB.Read(buf)
102 + if err != nil {
103 + break
104 + }
105 + cB.Write(buf)
106 + }
107 +
108 + wg.Done()
109 + }()
110 +
111 + cA, err := net.Dial("tcp", "127.0.0.1:4322")
112 + if err != nil {
113 + t.Fatal("failed to dial")
114 + }
115 +
116 + buf := make([]byte, 1024)
117 + if _, err := cA.Write([]byte("beep boop")); err != nil {
118 + t.Fatal("failed to write:", err)
119 + }
120 +
121 + if _, err := cA.Read(buf); err != nil {
122 + t.Fatal("failed to read:", buf, err)
123 + }
124 +
125 + if !bytes.Equal(buf[:9], []byte("beep boop")) {
126 + t.Fatal("failed to echo:", buf)
127 + }
128 +
129 + maddr2, err := FromNetAddr(cA.RemoteAddr())
130 + if err != nil {
131 + t.Fatal("failed to convert", err)
132 + }
133 + if !maddr2.Equal(maddr) {
134 + t.Fatal("remote multiaddr not equal:", maddr, maddr2)
135 + }
136 +
137 + cA.Close()
138 + wg.Wait()
139 +}
140 +
141 +func TestListenAndDial(t *testing.T) {
142 +
143 + maddr := newMultiaddr(t, "/ip4/127.0.0.1/tcp/4323")
144 + listener, err := Listen(maddr)
145 + if err != nil {
146 + t.Fatal("failed to listen")
147 + }
148 +
149 + var wg sync.WaitGroup
150 + wg.Add(1)
151 + go func() {
152 +
153 + cB, err := listener.Accept()
154 + if err != nil {
155 + t.Fatal("failed to accept")
156 + }
157 +
158 + if !cB.LocalMultiaddr().Equal(maddr) {
159 + t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
160 + }
161 +
162 + // echo out
163 + buf := make([]byte, 1024)
164 + for {
165 + _, err := cB.Read(buf)
166 + if err != nil {
167 + break
168 + }
169 + cB.Write(buf)
170 + }
171 +
172 + wg.Done()
173 + }()
174 +
175 + cA, err := Dial(newMultiaddr(t, "/ip4/127.0.0.1/tcp/4323"))
176 + if err != nil {
177 + t.Fatal("failed to dial")
178 + }
179 +
180 + buf := make([]byte, 1024)
181 + if _, err := cA.Write([]byte("beep boop")); err != nil {
182 + t.Fatal("failed to write:", err)
183 + }
184 +
185 + if _, err := cA.Read(buf); err != nil {
186 + t.Fatal("failed to read:", buf, err)
187 + }
188 +
189 + if !bytes.Equal(buf[:9], []byte("beep boop")) {
190 + t.Fatal("failed to echo:", buf)
191 + }
192 +
193 + maddr2 := cA.RemoteMultiaddr()
194 + if !maddr2.Equal(maddr) {
195 + t.Fatal("remote multiaddr not equal:", maddr, maddr2)
196 + }
197 +
198 + cA.Close()
199 + wg.Wait()
200 +}
daemon/daemon.go
+2 -1
@@ -15,6 +15,7 @@ import (
15
16 lock "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/camlistore/lock"
17 ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
18 + manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
19 )
20
21 var log = u.Logger("daemon")
@@ -51,7 +52,7 @@ func NewDaemonListener(ipfsnode *core.IpfsNode, addr ma.Multiaddr, confdir strin
52 return nil, err
53 }
54
54 - network, host, err := ma.DialArgs(addr)
55 + network, host, err := manet.DialArgs(addr)
56 if err != nil {
57 return nil, err
58 }
daemon/daemon_client.go
+2 -1
@@ -9,6 +9,7 @@ import (
9 "os"
10
11 ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
12 + manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
13
14 u "github.com/jbenet/go-ipfs/util"
15 )
@@ -73,7 +74,7 @@ func SendCommand(command *Command, confdir string) error {
74 return err
75 }
76
76 - network, host, err := ma.DialArgs(maddr)
77 + network, host, err := manet.DialArgs(maddr)
78
79 conn, err := net.Dial(network, host)
80 if err != nil {
net/conn/conn.go
+3 -2
@@ -6,6 +6,7 @@ import (
6
7 msgio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio"
8 ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
9 + manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
10
11 spipe "github.com/jbenet/go-ipfs/crypto/spipe"
12 peer "github.com/jbenet/go-ipfs/peer"
@@ -58,7 +59,7 @@ func Dial(network string, peer *peer.Peer) (*Conn, error) {
59 return nil, fmt.Errorf("No address for network %s", network)
60 }
61
61 - network, host, err := ma.DialArgs(addr)
62 + network, host, err := manet.DialArgs(addr)
63 if err != nil {
64 return nil, err
65 }
@@ -107,5 +108,5 @@ func (c *Conn) Close() error {
108 // NetConnMultiaddr returns the net.Conn's address, recast as a multiaddr.
109 // (consider moving this directly into the multiaddr package)
110 func NetConnMultiaddr(nconn net.Conn) (ma.Multiaddr, error) {
110 - return ma.FromNetAddr(nconn.RemoteAddr())
111 + return manet.FromNetAddr(nconn.RemoteAddr())
112 }
net/swarm/conn.go
+2 -1
@@ -10,6 +10,7 @@ import (
10 msg "github.com/jbenet/go-ipfs/net/message"
11
12 ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
13 + manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
14 )
15
16 // Open listeners for each network the swarm should listen on
@@ -37,7 +38,7 @@ func (s *Swarm) listen() error {
38
39 // Listen for new connections on the given multiaddr
40 func (s *Swarm) connListen(maddr ma.Multiaddr) error {
40 - netstr, addr, err := ma.DialArgs(maddr)
41 + netstr, addr, err := manet.DialArgs(maddr)
42 if err != nil {
43 return err
44 }
net/swarm/swarm_test.go
+2 -1
@@ -12,6 +12,7 @@ import (
12 context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
13 msgio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio"
14 ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
15 + manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
16 mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
17 )
18
@@ -95,7 +96,7 @@ func TestSwarm(t *testing.T) {
96 if a == nil {
97 t.Fatal("error setting up peer (addr is nil)", peer)
98 }
98 - n, h, err := ma.DialArgs(a)
99 + n, h, err := manet.DialArgs(a)
100 if err != nil {
101 t.Fatal("error getting dial args from addr")
102 }
server/http/http.go
+2 -1
@@ -7,6 +7,7 @@ import (
7
8 "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/gorilla/mux"
9 ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
10 + manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
11 mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
12
13 core "github.com/jbenet/go-ipfs/core"
@@ -24,7 +25,7 @@ func Serve(address ma.Multiaddr, node *core.IpfsNode) error {
25 r.PathPrefix("/ipfs/").Handler(handler).Methods("GET")
26 http.Handle("/", r)
27
27 - _, host, err := ma.DialArgs(address)
28 + _, host, err := manet.DialArgs(address)
29 if err != nil {
30 return err
31 }