waku-org/go-multiaddr
1
0
Fork 0
mirror of https://github.com/waku-org/go-multiaddr.git synced 2025-02-23 11:38:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

extract out yamux code in favor of modularity

Browse Source
This commit is contained in:
Jeromy 2016-06-10 15:33:31 -07:00
parent d4cfd691db
commit ff394cdaae
8 changed files with 3 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gx/lastpubver
View File

@ -1 +1 @@
1.1.0: QmbM19LB6CWweXhRE6j82qEPPcxTJqRhhsk3EexyfwTQV8
1.2.0: QmPpRcbNUXauP3zWZ1NJMLWpe4QnmEHrd2ba2D3yqWznw7

34
convert.go
View File

@ -6,7 +6,6 @@ import (
"strings"
ma "github.com/jbenet/go-multiaddr"
utp "github.com/jbenet/go-multiaddr-net/utp"
)
var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
@ -58,8 +57,6 @@ func parseBasicNetMaddr(maddr ma.Multiaddr) (net.Addr, error) {
return net.ResolveTCPAddr(network, host)
case "udp", "udp4", "udp6":
return net.ResolveUDPAddr(network, host)
case "utp", "utp4", "utp6":
return utp.ResolveAddr(network, host)
case "ip", "ip4", "ip6":
return net.ResolveIPAddr(network, host)
}
@ -95,9 +92,6 @@ func DialArgs(m ma.Multiaddr) (string, string, error) {
}
network := parts[2]
if parts[2] == "udp" && len(parts) > 4 && parts[4] == "utp" {
network = parts[4]
}
var host string
switch parts[0] {
@ -155,34 +149,6 @@ func parseUdpNetAddr(a net.Addr) (ma.Multiaddr, error) {
return ipm.Encapsulate(udpm), nil
}
func parseUtpNetAddr(a net.Addr) (ma.Multiaddr, error) {
acc, ok := a.(*utp.Addr)
if !ok {
return nil, errIncorrectNetAddr
}
// Get UDP Addr
ac, ok := acc.Child().(*net.UDPAddr)
if !ok {
return nil, errIncorrectNetAddr
}
// Get IP Addr
ipm, err := FromIP(ac.IP)
if err != nil {
return nil, errIncorrectNetAddr
}
// Get UDP Addr
utpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d/utp", ac.Port))
if err != nil {
return nil, errIncorrectNetAddr
}
// Encapsulate
return ipm.Encapsulate(utpm), nil
}
func parseIpNetAddr(a net.Addr) (ma.Multiaddr, error) {
ac, ok := a.(*net.IPAddr)
if !ok {

13
convert_test.go
View File

@ -5,7 +5,6 @@ import (
"testing"
ma "github.com/jbenet/go-multiaddr"
mautp "github.com/jbenet/go-multiaddr-net/utp"
)
type GenFunc func() (ma.Multiaddr, error)
@ -89,27 +88,17 @@ func TestFromUDP(t *testing.T) {
})
}
func TestFromUTP(t *testing.T) {
a := &net.UDPAddr{IP: net.ParseIP("10.20.30.40"), Port: 1234}
testConvert(t, "/ip4/10.20.30.40/udp/1234/utp", func() (ma.Multiaddr, error) {
return FromNetAddr(mautp.MakeAddr(a))
})
}
func TestThinWaist(t *testing.T) {
addrs := map[string]bool{
"/ip4/127.0.0.1/udp/1234": true,
"/ip4/127.0.0.1/tcp/1234": true,
"/ip4/127.0.0.1/udp/1234/utp": true,
"/ip4/127.0.0.1/udp/1234/tcp/1234": true,
"/ip4/127.0.0.1/tcp/12345/ip4/1.2.3.4": true,
"/ip6/::1/tcp/80": true,
"/ip6/::1/udp/80": true,
"/ip6/::1": true,
"/ip6/::1/utp": false,
"/tcp/1234/ip4/1.2.3.4": false,
"/tcp/1234": false,
"/tcp/1234/utp": false,
"/tcp/1234/udp/1234": false,
"/ip4/1.2.3.4/ip4/2.3.4.5": true,
"/ip6/::1/ip4/2.3.4.5": true,
@ -150,8 +139,6 @@ func TestDialArgs(t *testing.T) {
test("/ip4/127.0.0.1/udp/1234", "udp4", "127.0.0.1:1234")
test("/ip4/127.0.0.1/tcp/4321", "tcp4", "127.0.0.1:4321")
test("/ip4/127.0.0.1/udp/1234/utp", "utp4", "127.0.0.1:1234")
test("/ip6/::1/udp/1234", "udp6", "[::1]:1234")
test("/ip6/::1/tcp/4321", "tcp6", "[::1]:4321")
test("/ip6/::1/udp/1234/utp", "utp6", "[::1]:1234")
}

19
net.go
View File

@ -5,7 +5,6 @@ import (
"net"
ma "github.com/jbenet/go-multiaddr"
mautp "github.com/jbenet/go-multiaddr-net/utp"
)
// Conn is the equivalent of a net.Conn object. It is the
@ -114,16 +113,6 @@ func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
if err != nil {
return nil, err
}
case "utp", "utp4", "utp6":
utpd := mautp.Dialer{
Timeout: d.Timeout,
LocalAddr: d.Dialer.LocalAddr,
}
// construct utp dialer, with options on our net.Dialer
nconn, err = utpd.Dial(rnet, rnaddr)
if err != nil {
return nil, err
}
}
// get local address (pre-specified or assigned within net.Conn)
@ -224,13 +213,7 @@ func Listen(laddr ma.Multiaddr) (Listener, error) {
return nil, err
}
var nl net.Listener
switch lnet {
case "utp", "utp4", "utp6":
nl, err = mautp.Listen(lnet, lnaddr)
default:
nl, err = net.Listen(lnet, lnaddr)
}
nl, err := net.Listen(lnet, lnaddr)
if err != nil {
return nil, err
}

63
net_test.go
View File

@ -181,7 +181,6 @@ func TestListenAddrs(t *testing.T) {
test("/ip6/::/tcp/4324", "", true)
test("/ip6/::/udp/4325", "", false)
test("/ip6/::/udp/4326/udt", "", false)
// test("/ip4/127.0.0.1/udp/4326/utp", true)
}
func TestListenAndDial(t *testing.T) {
@ -245,68 +244,6 @@ func TestListenAndDial(t *testing.T) {
wg.Wait()
}
func TestListenAndDialUTP(t *testing.T) {
maddr := newMultiaddr(t, "/ip4/127.0.0.1/udp/4323/utp")
listener, err := Listen(maddr)
if err != nil {
t.Fatal("failed to listen: ", err)
}
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())
}
defer cB.Close()
// 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/udp/4323/utp"))
if err != nil {
t.Fatal("failed to dial", err)
}
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 TestIPLoopback(t *testing.T) {
if IP4Loopback.String() != "/ip4/127.0.0.1" {
t.Error("IP4Loopback incorrect:", IP4Loopback)

8
package.json
View File

@ -7,12 +7,6 @@
"dvcsimport": "github.com/jbenet/go-multiaddr-net"
},
"gxDependencies": [
{
"author": "whyrusleeping",
"hash": "QmaxuoSyFFzKgrujaburn4j3MQWFQu8ASqVSwrMER6Mk9L",
"name": "utp",
"version": "0.0.0"
},
{
"author": "whyrusleeping",
"hash": "QmYzDkkgAEmrcNzFCiYo6L1dTX4EAG1gZkbtdbd9trL4vd",
@ -24,5 +18,5 @@
"language": "go",
"license": "",
"name": "go-multiaddr-net",
"version": "1.1.0"
"version": "1.2.0"
}

8
registry.go
View File

@ -17,7 +17,6 @@ func init() {
defaultCodecs = NewCodecMap()
defaultCodecs.RegisterNetCodec(tcpAddrSpec)
defaultCodecs.RegisterNetCodec(udpAddrSpec)
defaultCodecs.RegisterNetCodec(utpAddrSpec)
defaultCodecs.RegisterNetCodec(ip4AddrSpec)
defaultCodecs.RegisterNetCodec(ip6AddrSpec)
defaultCodecs.RegisterNetCodec(ipnetAddrSpec)
@ -85,13 +84,6 @@ var udpAddrSpec = &NetCodec{
ConvertMultiaddr: parseBasicNetMaddr,
}
var utpAddrSpec = &NetCodec{
ProtocolName: "utp",
NetAddrNetworks: []string{"utp", "utp4", "utp6"},
ParseNetAddr: parseUtpNetAddr,
ConvertMultiaddr: parseBasicNetMaddr,
}
var ip4AddrSpec = &NetCodec{
ProtocolName: "ip4",
NetAddrNetworks: []string{"ip4"},

105
utp/utp_util.go
View File

@ -1,105 +0,0 @@
package utp
import (
"errors"
"net"
"time"
utp "github.com/anacrolix/utp"
)
type Listener struct {
*utp.Socket
}
type Conn struct {
net.Conn
}
type Addr struct {
net string
child net.Addr
}
func (ca *Addr) Network() string {
return ca.net
}
func (ca *Addr) String() string {
return ca.child.String()
}
func (ca *Addr) Child() net.Addr {
return ca.child
}
func MakeAddr(a net.Addr) net.Addr {
return &Addr{
net: "utp",
child: a,
}
}
func ResolveAddr(network string, host string) (net.Addr, error) {
a, err := net.ResolveUDPAddr("udp"+network[3:], host)
if err != nil {
return nil, err
}
return MakeAddr(a), nil
}
func (u *Conn) LocalAddr() net.Addr {
return MakeAddr(u.Conn.LocalAddr())
}
func (u *Conn) RemoteAddr() net.Addr {
return MakeAddr(u.Conn.RemoteAddr())
}
func Listen(network string, laddr string) (net.Listener, error) {
switch network {
case "utp", "utp4", "utp6":
s, err := utp.NewSocket("udp"+network[3:], laddr)
if err != nil {
return nil, err
}
return &Listener{s}, nil
default:
return nil, errors.New("unrecognized network: " + network)
}
}
func (u *Listener) Accept() (net.Conn, error) {
c, err := u.Socket.Accept()
if err != nil {
return nil, err
}
return &Conn{c}, nil
}
func (u *Listener) Addr() net.Addr {
return MakeAddr(u.Socket.Addr())
}
type Dialer struct {
Timeout time.Duration
LocalAddr net.Addr
}
func (d *Dialer) Dial(rnet string, raddr string) (net.Conn, error) {
if d.LocalAddr != nil {
s, err := utp.NewSocket(d.LocalAddr.Network(), d.LocalAddr.String())
if err != nil {
return nil, err
}
// zero timeout is the same as calling s.Dial()
return s.DialTimeout(raddr, d.Timeout)
}
return utp.DialTimeout(raddr, d.Timeout)
}