more vendoring

vendor/QmY1q6BMPywiUXEKAjehsgmPaBeLHTzs3FNaptUsbmpngb/crypto-sha3/xor.go

+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !amd64,!386 appengine
+
+package sha3
+
+var (
+	xorIn            = xorInGeneric
+	copyOut          = copyOutGeneric
+	xorInUnaligned   = xorInGeneric
+	copyOutUnaligned = copyOutGeneric
+)
+
+const xorImplementationUnaligned = "generic"

vendor/QmY1q6BMPywiUXEKAjehsgmPaBeLHTzs3FNaptUsbmpngb/crypto-sha3/xor_generic.go

+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+import "encoding/binary"
+
+// xorInGeneric xors the bytes in buf into the state; it
+// makes no non-portable assumptions about memory layout
+// or alignment.
+func xorInGeneric(d *state, buf []byte) {
+	n := len(buf) / 8
+
+	for i := 0; i < n; i++ {
+		a := binary.LittleEndian.Uint64(buf)
+		d.a[i] ^= a
+		buf = buf[8:]
+	}
+}
+
+// copyOutGeneric copies ulint64s to a byte buffer.
+func copyOutGeneric(d *state, b []byte) {
+	for i := 0; len(b) >= 8; i++ {
+		binary.LittleEndian.PutUint64(b, d.a[i])
+		b = b[8:]
+	}
+}

vendor/QmY1q6BMPywiUXEKAjehsgmPaBeLHTzs3FNaptUsbmpngb/crypto-sha3/xor_unaligned.go

+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build amd64 386
+// +build !appengine
+
+package sha3
+
+import "unsafe"
+
+func xorInUnaligned(d *state, buf []byte) {
+	bw := (*[maxRate / 8]uint64)(unsafe.Pointer(&buf[0]))
+	n := len(buf)
+	if n >= 72 {
+		d.a[0] ^= bw[0]
+		d.a[1] ^= bw[1]
+		d.a[2] ^= bw[2]
+		d.a[3] ^= bw[3]
+		d.a[4] ^= bw[4]
+		d.a[5] ^= bw[5]
+		d.a[6] ^= bw[6]
+		d.a[7] ^= bw[7]
+		d.a[8] ^= bw[8]
+	}
+	if n >= 104 {
+		d.a[9] ^= bw[9]
+		d.a[10] ^= bw[10]
+		d.a[11] ^= bw[11]
+		d.a[12] ^= bw[12]
+	}
+	if n >= 136 {
+		d.a[13] ^= bw[13]
+		d.a[14] ^= bw[14]
+		d.a[15] ^= bw[15]
+		d.a[16] ^= bw[16]
+	}
+	if n >= 144 {
+		d.a[17] ^= bw[17]
+	}
+	if n >= 168 {
+		d.a[18] ^= bw[18]
+		d.a[19] ^= bw[19]
+		d.a[20] ^= bw[20]
+	}
+}
+
+func copyOutUnaligned(d *state, buf []byte) {
+	ab := (*[maxRate]uint8)(unsafe.Pointer(&d.a[0]))
+	copy(buf, ab[:])
+}
+
+var (
+	xorIn   = xorInUnaligned
+	copyOut = copyOutUnaligned
+)
+
+const xorImplementationUnaligned = "unaligned"

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/.travis.yml

+language: go
+
+go:
+  - 1.3
+  - release
+  - tip
+
+script:
+  - go test -race -cpu=5 -v ./...

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/README.md

+# go-multiaddr
+
+[multiaddr](https://github.com/jbenet/multiaddr) implementation in Go.
+
+## Example
+
+### Simple
+
+```go
+import ma "github.com/jbenet/go-multiaddr"
+
+// construct from a string (err signals parse failure)
+m1, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+
+// construct from bytes (err signals parse failure)
+m2, err := ma.NewMultiaddrBytes(m1.Bytes())
+
+// true
+strings.Equal(m1.String(), "/ip4/127.0.0.1/udp/1234")
+strings.Equal(m1.String(), m2.String())
+bytes.Equal(m1.Bytes(), m2.Bytes())
+m1.Equal(m2)
+m2.Equal(m1)
+```
+
+### Protocols
+
+```go
+// get the multiaddr protocol description objects
+addr.Protocols()
+// []Protocol{
+//   Protocol{ Code: 4, Name: 'ip4', Size: 32},
+//   Protocol{ Code: 17, Name: 'udp', Size: 16},
+// }
+```
+
+### En/decapsulate
+
+```go
+m.Encapsulate(ma.NewMultiaddr("/sctp/5678"))
+// <Multiaddr /ip4/127.0.0.1/udp/1234/sctp/5678>
+m.Decapsulate(ma.NewMultiaddr("/udp")) // up to + inc last occurrence of subaddr
+// <Multiaddr /ip4/127.0.0.1>
+```
+
+### Tunneling
+
+Multiaddr allows expressing tunnels very nicely.
+
+```js
+printer, _ := ma.NewMultiaddr("/ip4/192.168.0.13/tcp/80")
+proxy, _ := ma.NewMultiaddr("/ip4/10.20.30.40/tcp/443")
+printerOverProxy := proxy.Encapsulate(printer)
+// /ip4/10.20.30.40/tcp/443/ip4/192.168.0.13/tcp/80
+
+proxyAgain := printerOverProxy.Decapsulate(printer)
+// /ip4/10.20.30.40/tcp/443
+```

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/codec.go

+package multiaddr
+
+import (
+	"encoding/base32"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	mh "QmdeauTdyf38KDQB4Cc4CurPWRRb5pej27NCXPA7kbPTJy/go-multihash"
+)
+
+func stringToBytes(s string) ([]byte, error) {
+
+	// consume trailing slashes
+	s = strings.TrimRight(s, "/")
+
+	b := []byte{}
+	sp := strings.Split(s, "/")
+
+	if sp[0] != "" {
+		return nil, fmt.Errorf("invalid multiaddr, must begin with /")
+	}
+
+	// consume first empty elem
+	sp = sp[1:]
+
+	for len(sp) > 0 {
+		p := ProtocolWithName(sp[0])
+		if p.Code == 0 {
+			return nil, fmt.Errorf("no protocol with name %s", sp[0])
+		}
+		b = append(b, CodeToVarint(p.Code)...)
+		sp = sp[1:]
+
+		if p.Size == 0 { // no length.
+			continue
+		}
+
+		if len(sp) < 1 {
+			return nil, fmt.Errorf("protocol requires address, none given: %s", p.Name)
+		}
+		a, err := addressStringToBytes(p, sp[0])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse %s: %s %s", p.Name, sp[0], err)
+		}
+		b = append(b, a...)
+		sp = sp[1:]
+	}
+	return b, nil
+}
+
+func bytesToString(b []byte) (ret string, err error) {
+	// panic handler, in case we try accessing bytes incorrectly.
+	defer func() {
+		if e := recover(); e != nil {
+			ret = ""
+			switch e := e.(type) {
+			case error:
+				err = e
+			case string:
+				err = errors.New(e)
+			default:
+				err = fmt.Errorf("%v", e)
+			}
+		}
+	}()
+
+	s := ""
+
+	for len(b) > 0 {
+
+		code, n := ReadVarintCode(b)
+		b = b[n:]
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			return "", fmt.Errorf("no protocol with code %d", code)
+		}
+		s += "/" + p.Name
+
+		if p.Size == 0 {
+			continue
+		}
+
+		size := sizeForAddr(p, b)
+		a, err := addressBytesToString(p, b[:size])
+		if err != nil {
+			return "", err
+		}
+		if len(a) > 0 {
+			s += "/" + a
+		}
+		b = b[size:]
+	}
+
+	return s, nil
+}
+
+func sizeForAddr(p Protocol, b []byte) int {
+	switch {
+	case p.Size > 0:
+		return (p.Size / 8)
+	case p.Size == 0:
+		return 0
+	default:
+		size, n := ReadVarintCode(b)
+		return size + n
+	}
+}
+
+func bytesSplit(b []byte) (ret [][]byte, err error) {
+	// panic handler, in case we try accessing bytes incorrectly.
+	defer func() {
+		if e := recover(); e != nil {
+			ret = [][]byte{}
+			err = e.(error)
+		}
+	}()
+
+	ret = [][]byte{}
+	for len(b) > 0 {
+		code, n := ReadVarintCode(b)
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			return [][]byte{}, fmt.Errorf("no protocol with code %d", b[0])
+		}
+
+		size := sizeForAddr(p, b[n:])
+		length := n + size
+		ret = append(ret, b[:length])
+		b = b[length:]
+	}
+
+	return ret, nil
+}
+
+func addressStringToBytes(p Protocol, s string) ([]byte, error) {
+	switch p.Code {
+
+	case P_IP4: // ipv4
+		i := net.ParseIP(s).To4()
+		if i == nil {
+			return nil, fmt.Errorf("failed to parse ip4 addr: %s", s)
+		}
+		return i, nil
+
+	case P_IP6: // ipv6
+		i := net.ParseIP(s).To16()
+		if i == nil {
+			return nil, fmt.Errorf("failed to parse ip6 addr: %s", s)
+		}
+		return i, nil
+
+	// tcp udp dccp sctp
+	case P_TCP, P_UDP, P_DCCP, P_SCTP:
+		i, err := strconv.Atoi(s)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse %s addr: %s", p.Name, err)
+		}
+		if i >= 65536 {
+			return nil, fmt.Errorf("failed to parse %s addr: %s", p.Name, "greater than 65536")
+		}
+		b := make([]byte, 2)
+		binary.BigEndian.PutUint16(b, uint16(i))
+		return b, nil
+
+	case P_ONION:
+		addr := strings.Split(s, ":")
+		if len(addr) != 2 {
+			return nil, fmt.Errorf("failed to parse %s addr: %s does not contain a port number.", p.Name, s)
+		}
+
+		// onion address without the ".onion" substring
+		if len(addr[0]) != 16 {
+			return nil, fmt.Errorf("failed to parse %s addr: %s not a Tor onion address.", p.Name, s)
+		}
+		onionHostBytes, err := base32.StdEncoding.DecodeString(strings.ToUpper(addr[0]))
+		if err != nil {
+			return nil, fmt.Errorf("failed to decode base32 %s addr: %s %s", p.Name, s, err)
+		}
+
+		// onion port number
+		i, err := strconv.Atoi(addr[1])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse %s addr: %s", p.Name, err)
+		}
+		if i >= 65536 {
+			return nil, fmt.Errorf("failed to parse %s addr: %s", p.Name, "port greater than 65536")
+		}
+		if i < 1 {
+			return nil, fmt.Errorf("failed to parse %s addr: %s", p.Name, "port less than 1")
+		}
+
+		onionPortBytes := make([]byte, 2)
+		binary.BigEndian.PutUint16(onionPortBytes, uint16(i))
+		bytes := []byte{}
+		bytes = append(bytes, onionHostBytes...)
+		bytes = append(bytes, onionPortBytes...)
+		return bytes, nil
+
+	case P_IPFS: // ipfs
+		// the address is a varint prefixed multihash string representation
+		m, err := mh.FromB58String(s)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse ipfs addr: %s %s", s, err)
+		}
+		size := CodeToVarint(len(m))
+		b := append(size, m...)
+		return b, nil
+	}
+
+	return []byte{}, fmt.Errorf("failed to parse %s addr: unknown", p.Name)
+}
+
+func addressBytesToString(p Protocol, b []byte) (string, error) {
+	switch p.Code {
+
+	// ipv4,6
+	case P_IP4, P_IP6:
+		return net.IP(b).String(), nil
+
+	// tcp udp dccp sctp
+	case P_TCP, P_UDP, P_DCCP, P_SCTP:
+		i := binary.BigEndian.Uint16(b)
+		return strconv.Itoa(int(i)), nil
+
+	case P_IPFS: // ipfs
+		// the address is a varint-prefixed multihash string representation
+		size, n := ReadVarintCode(b)
+		b = b[n:]
+		if len(b) != size {
+			panic("inconsistent lengths")
+		}
+		m, err := mh.Cast(b)
+		if err != nil {
+			return "", err
+		}
+		return m.B58String(), nil
+	}
+
+	return "", fmt.Errorf("unknown protocol")
+}

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/doc.go

+/*
+Package multiaddr provides an implementation of the Multiaddr network
+address format. Multiaddr emphasizes explicitness, self-description, and
+portability. It allows applications to treat addresses as opaque tokens,
+and to avoid making assumptions about the address representation (e.g. length).
+Learn more at https://github.com/jbenet/multiaddr
+
+Basic Use:
+
+  import (
+    "bytes"
+    "strings"
+    ma "github.com/jbenet/go-multiaddr"
+  )
+
+  // construct from a string (err signals parse failure)
+  m1, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+
+  // construct from bytes (err signals parse failure)
+  m2, err := ma.NewMultiaddrBytes(m1.Bytes())
+
+  // true
+  strings.Equal(m1.String(), "/ip4/127.0.0.1/udp/1234")
+  strings.Equal(m1.String(), m2.String())
+  bytes.Equal(m1.Bytes(), m2.Bytes())
+  m1.Equal(m2)
+  m2.Equal(m1)
+
+  // tunneling (en/decap)
+  printer, _ := ma.NewMultiaddr("/ip4/192.168.0.13/tcp/80")
+  proxy, _ := ma.NewMultiaddr("/ip4/10.20.30.40/tcp/443")
+  printerOverProxy := proxy.Encapsulate(printer)
+  proxyAgain := printerOverProxy.Decapsulate(printer)
+
+*/
+package multiaddr

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/interface.go

+package multiaddr
+
+/*
+Multiaddr is a cross-protocol, cross-platform format for representing
+internet addresses. It emphasizes explicitness and self-description.
+Learn more here: https://github.com/jbenet/multiaddr
+
+Multiaddrs have both a binary and string representation.
+
+    import ma "github.com/jbenet/go-multiaddr"
+
+    addr, err := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/80")
+    // err non-nil when parsing failed.
+
+*/
+type Multiaddr interface {
+	// Equal returns whether two Multiaddrs are exactly equal
+	Equal(Multiaddr) bool
+
+	// Bytes returns the []byte representation of this Multiaddr
+	Bytes() []byte
+
+	// String returns the string representation of this Multiaddr
+	// (may panic if internal state is corrupted)
+	String() string
+
+	// Protocols returns the list of Protocols this Multiaddr includes
+	// will panic if protocol code incorrect (and bytes accessed incorrectly)
+	Protocols() []Protocol
+
+	// Encapsulate wraps this Multiaddr around another. For example:
+	//
+	//      /ip4/1.2.3.4 encapsulate /tcp/80 = /ip4/1.2.3.4/tcp/80
+	//
+	Encapsulate(Multiaddr) Multiaddr
+
+	// Decapsultate removes a Multiaddr wrapping. For example:
+	//
+	//      /ip4/1.2.3.4/tcp/80 decapsulate /ip4/1.2.3.4 = /tcp/80
+	//
+	Decapsulate(Multiaddr) Multiaddr
+}

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/multiaddr.go

+package multiaddr
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+)
+
+// multiaddr is the data structure representing a Multiaddr
+type multiaddr struct {
+	bytes []byte
+}
+
+// NewMultiaddr parses and validates an input string, returning a *Multiaddr
+func NewMultiaddr(s string) (Multiaddr, error) {
+	b, err := stringToBytes(s)
+	if err != nil {
+		return nil, err
+	}
+	return &multiaddr{bytes: b}, nil
+}
+
+// NewMultiaddrBytes initializes a Multiaddr from a byte representation.
+// It validates it as an input string.
+func NewMultiaddrBytes(b []byte) (Multiaddr, error) {
+	s, err := bytesToString(b)
+	if err != nil {
+		return nil, err
+	}
+	return NewMultiaddr(s)
+}
+
+// Equal tests whether two multiaddrs are equal
+func (m *multiaddr) Equal(m2 Multiaddr) bool {
+	return bytes.Equal(m.bytes, m2.Bytes())
+}
+
+// Bytes returns the []byte representation of this Multiaddr
+func (m *multiaddr) Bytes() []byte {
+	// consider returning copy to prevent changing underneath us?
+	cpy := make([]byte, len(m.bytes))
+	copy(cpy, m.bytes)
+	return cpy
+}
+
+// String returns the string representation of a Multiaddr
+func (m *multiaddr) String() string {
+	s, err := bytesToString(m.bytes)
+	if err != nil {
+		panic("multiaddr failed to convert back to string. corrupted?")
+	}
+	return s
+}
+
+// Protocols returns the list of protocols this Multiaddr has.
+// will panic in case we access bytes incorrectly.
+func (m *multiaddr) Protocols() []Protocol {
+
+	// panic handler, in case we try accessing bytes incorrectly.
+	defer func() {
+		if e := recover(); e != nil {
+			err := e.(error)
+			panic("Multiaddr.Protocols error: " + err.Error())
+		}
+	}()
+
+	size := 0
+	ps := []Protocol{}
+	b := m.bytes[:]
+	for len(b) > 0 {
+		code, n := ReadVarintCode(b)
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			// this is a panic (and not returning err) because this should've been
+			// caught on constructing the Multiaddr
+			panic(fmt.Errorf("no protocol with code %d", b[0]))
+		}
+		ps = append(ps, p)
+		b = b[n:]
+
+		size = sizeForAddr(p, b)
+		b = b[size:]
+	}
+	return ps
+}
+
+// Encapsulate wraps a given Multiaddr, returning the resulting joined Multiaddr
+func (m *multiaddr) Encapsulate(o Multiaddr) Multiaddr {
+	mb := m.bytes
+	ob := o.Bytes()
+
+	b := make([]byte, len(mb)+len(ob))
+	copy(b, mb)
+	copy(b[len(mb):], ob)
+	return &multiaddr{bytes: b}
+}
+
+// Decapsulate unwraps Multiaddr up until the given Multiaddr is found.
+func (m *multiaddr) Decapsulate(o Multiaddr) Multiaddr {
+	s1 := m.String()
+	s2 := o.String()
+	i := strings.LastIndex(s1, s2)
+	if i < 0 {
+		// if multiaddr not contained, returns a copy.
+		cpy := make([]byte, len(m.bytes))
+		copy(cpy, m.bytes)
+		return &multiaddr{bytes: cpy}
+	}
+
+	ma, err := NewMultiaddr(s1[:i])
+	if err != nil {
+		panic("Multiaddr.Decapsulate incorrect byte boundaries.")
+	}
+	return ma
+}

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/multiaddr_test.go

+package multiaddr
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+)
+
+func newMultiaddr(t *testing.T, a string) Multiaddr {
+	m, err := NewMultiaddr(a)
+	if err != nil {
+		t.Error(err)
+	}
+	return m
+}
+
+func TestConstructFails(t *testing.T) {
+	cases := []string{
+		"/ip4",
+		"/ip4/::1",
+		"/ip4/fdpsofodsajfdoisa",
+		"/ip6",
+		"/udp",
+		"/tcp",
+		"/sctp",
+		"/udp/65536",
+		"/tcp/65536",
+		"/onion/9imaq4ygg2iegci7:80",
+		"/onion/aaimaq4ygg2iegci7:80",
+		"/onion/timaq4ygg2iegci7:0",
+		"/onion/timaq4ygg2iegci7:-1",
+		"/onion/timaq4ygg2iegci7",
+		"/onion/timaq4ygg2iegci@:666",
+		"/udp/1234/sctp",
+		"/udp/1234/udt/1234",
+		"/udp/1234/utp/1234",
+		"/ip4/127.0.0.1/udp/jfodsajfidosajfoidsa",
+		"/ip4/127.0.0.1/udp",
+		"/ip4/127.0.0.1/tcp/jfodsajfidosajfoidsa",
+		"/ip4/127.0.0.1/tcp",
+		"/ip4/127.0.0.1/ipfs",
+		"/ip4/127.0.0.1/ipfs/tcp",
+	}
+
+	for _, a := range cases {
+		if _, err := NewMultiaddr(a); err == nil {
+			t.Errorf("should have failed: %s - %s", a, err)
+		}
+	}
+}
+
+func TestConstructSucceeds(t *testing.T) {
+	cases := []string{
+		"/ip4/1.2.3.4",
+		"/ip4/0.0.0.0",
+		"/ip6/::1",
+		"/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21",
+		"/onion/timaq4ygg2iegci7:1234",
+		"/onion/timaq4ygg2iegci7:80/http",
+		"/udp/0",
+		"/tcp/0",
+		"/sctp/0",
+		"/udp/1234",
+		"/tcp/1234",
+		"/sctp/1234",
+		"/udp/65535",
+		"/tcp/65535",
+		"/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+		"/udp/1234/sctp/1234",
+		"/udp/1234/udt",
+		"/udp/1234/utp",
+		"/tcp/1234/http",
+		"/tcp/1234/https",
+		"/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+		"/ip4/127.0.0.1/udp/1234",
+		"/ip4/127.0.0.1/udp/0",
+		"/ip4/127.0.0.1/tcp/1234",
+		"/ip4/127.0.0.1/tcp/1234/",
+		"/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+		"/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+	}
+
+	for _, a := range cases {
+		if _, err := NewMultiaddr(a); err != nil {
+			t.Errorf("should have succeeded: %s -- %s", a, err)
+		}
+	}
+}
+
+func TestEqual(t *testing.T) {
+	m1 := newMultiaddr(t, "/ip4/127.0.0.1/udp/1234")
+	m2 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234")
+	m3 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234")
+	m4 := newMultiaddr(t, "/ip4/127.0.0.1/tcp/1234/")
+
+	if m1.Equal(m2) {
+		t.Error("should not be equal")
+	}
+
+	if m2.Equal(m1) {
+		t.Error("should not be equal")
+	}
+
+	if !m2.Equal(m3) {
+		t.Error("should be equal")
+	}
+
+	if !m3.Equal(m2) {
+		t.Error("should be equal")
+	}
+
+	if !m1.Equal(m1) {
+		t.Error("should be equal")
+	}
+
+	if !m2.Equal(m4) {
+		t.Error("should be equal")
+	}
+
+	if !m4.Equal(m3) {
+		t.Error("should be equal")
+	}
+}
+
+func TestStringToBytes(t *testing.T) {
+
+	testString := func(s string, h string) {
+		b1, err := hex.DecodeString(h)
+		if err != nil {
+			t.Error("failed to decode hex", h)
+		}
+
+		b2, err := stringToBytes(s)
+		if err != nil {
+			t.Error("failed to convert", s)
+		}
+
+		if !bytes.Equal(b1, b2) {
+			t.Error("failed to convert", s, "to", b1, "got", b2)
+		}
+	}
+
+	testString("/ip4/127.0.0.1/udp/1234", "047f0000011104d2")
+	testString("/ip4/127.0.0.1/tcp/4321", "047f0000010610e1")
+	testString("/ip4/127.0.0.1/udp/1234/ip4/127.0.0.1/tcp/4321", "047f0000011104d2047f0000010610e1")
+}
+
+func TestBytesToString(t *testing.T) {
+
+	testString := func(s1 string, h string) {
+		b, err := hex.DecodeString(h)
+		if err != nil {
+			t.Error("failed to decode hex", h)
+		}
+
+		s2, err := bytesToString(b)
+		if err != nil {
+			t.Error("failed to convert", b)
+		}
+
+		if s1 != s2 {
+			t.Error("failed to convert", b, "to", s1, "got", s2)
+		}
+	}
+
+	testString("/ip4/127.0.0.1/udp/1234", "047f0000011104d2")
+	testString("/ip4/127.0.0.1/tcp/4321", "047f0000010610e1")
+	testString("/ip4/127.0.0.1/udp/1234/ip4/127.0.0.1/tcp/4321", "047f0000011104d2047f0000010610e1")
+}
+
+func TestBytesSplitAndJoin(t *testing.T) {
+
+	testString := func(s string, res []string) {
+		m, err := NewMultiaddr(s)
+		if err != nil {
+			t.Fatal("failed to convert", s, err)
+		}
+
+		split := Split(m)
+		if len(split) != len(res) {
+			t.Error("not enough split components", split)
+			return
+		}
+
+		for i, a := range split {
+			if a.String() != res[i] {
+				t.Errorf("split component failed: %s != %s", a, res[i])
+			}
+		}
+
+		joined := Join(split...)
+		if !m.Equal(joined) {
+			t.Errorf("joined components failed: %s != %s", m, joined)
+		}
+
+		// modifying underlying bytes is fine.
+		m2 := m.(*multiaddr)
+		for i := range m2.bytes {
+			m2.bytes[i] = 0
+		}
+
+		for i, a := range split {
+			if a.String() != res[i] {
+				t.Errorf("split component failed: %s != %s", a, res[i])
+			}
+		}
+	}
+
+	testString("/ip4/1.2.3.4/udp/1234", []string{"/ip4/1.2.3.4", "/udp/1234"})
+	testString("/ip4/1.2.3.4/tcp/1/ip4/2.3.4.5/udp/2",
+		[]string{"/ip4/1.2.3.4", "/tcp/1", "/ip4/2.3.4.5", "/udp/2"})
+	testString("/ip4/1.2.3.4/utp/ip4/2.3.4.5/udp/2/udt",
+		[]string{"/ip4/1.2.3.4", "/utp", "/ip4/2.3.4.5", "/udp/2", "/udt"})
+}
+
+func TestProtocols(t *testing.T) {
+	m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+	if err != nil {
+		t.Error("failed to construct", "/ip4/127.0.0.1/udp/1234")
+	}
+
+	ps := m.Protocols()
+	if ps[0].Code != ProtocolWithName("ip4").Code {
+		t.Error(ps[0], ProtocolWithName("ip4"))
+		t.Error("failed to get ip4 protocol")
+	}
+
+	if ps[1].Code != ProtocolWithName("udp").Code {
+		t.Error(ps[1], ProtocolWithName("udp"))
+		t.Error("failed to get udp protocol")
+	}
+
+}
+
+func TestProtocolsWithString(t *testing.T) {
+	pwn := ProtocolWithName
+	good := map[string][]Protocol{
+		"/ip4":                    []Protocol{pwn("ip4")},
+		"/ip4/tcp":                []Protocol{pwn("ip4"), pwn("tcp")},
+		"ip4/tcp/udp/ip6":         []Protocol{pwn("ip4"), pwn("tcp"), pwn("udp"), pwn("ip6")},
+		"////////ip4/tcp":         []Protocol{pwn("ip4"), pwn("tcp")},
+		"ip4/udp/////////":        []Protocol{pwn("ip4"), pwn("udp")},
+		"////////ip4/tcp////////": []Protocol{pwn("ip4"), pwn("tcp")},
+	}
+
+	for s, ps1 := range good {
+		ps2, err := ProtocolsWithString(s)
+		if err != nil {
+			t.Error("ProtocolsWithString(%s) should have succeeded", s)
+		}
+
+		for i, ps1p := range ps1 {
+			ps2p := ps2[i]
+			if ps1p.Code != ps2p.Code {
+				t.Errorf("mismatch: %s != %s, %s", ps1p.Name, ps2p.Name, s)
+			}
+		}
+	}
+
+	bad := []string{
+		"dsijafd",                           // bogus proto
+		"/ip4/tcp/fidosafoidsa",             // bogus proto
+		"////////ip4/tcp/21432141/////////", // bogus proto
+		"////////ip4///////tcp/////////",    // empty protos in between
+	}
+
+	for _, s := range bad {
+		if _, err := ProtocolsWithString(s); err == nil {
+			t.Error("ProtocolsWithString(%s) should have failed", s)
+		}
+	}
+
+}
+
+func TestEncapsulate(t *testing.T) {
+	m, err := NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+	if err != nil {
+		t.Error(err)
+	}
+
+	m2, err := NewMultiaddr("/udp/5678")
+	if err != nil {
+		t.Error(err)
+	}
+
+	b := m.Encapsulate(m2)
+	if s := b.String(); s != "/ip4/127.0.0.1/udp/1234/udp/5678" {
+		t.Error("encapsulate /ip4/127.0.0.1/udp/1234/udp/5678 failed.", s)
+	}
+
+	m3, _ := NewMultiaddr("/udp/5678")
+	c := b.Decapsulate(m3)
+	if s := c.String(); s != "/ip4/127.0.0.1/udp/1234" {
+		t.Error("decapsulate /udp failed.", "/ip4/127.0.0.1/udp/1234", s)
+	}
+
+	m4, _ := NewMultiaddr("/ip4/127.0.0.1")
+	d := c.Decapsulate(m4)
+	if s := d.String(); s != "" {
+		t.Error("decapsulate /ip4 failed.", "/", s)
+	}
+}

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/package.json

+{
+  "name": "go-multiaddr",
+  "author": "whyrusleeping",
+  "version": "1.0.0",
+  "gxDependencies": [
+    {
+      "name": "go-multihash",
+      "hash": "QmdeauTdyf38KDQB4Cc4CurPWRRb5pej27NCXPA7kbPTJy",
+      "version": "1.0.0"
+    }
+  ],
+  "language": "go",
+  "gx": {
+    "dvcsimport": "github.com/jbenet/go-multiaddr"
+  }
+}
\ No newline at end of file

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/protocols.csv

+code	size	name
+4	32	ip4
+6	16	tcp
+17	16	udp
+33	16	dccp
+41	128	ip6
+132	16	sctp
+301	0	udt
+302	0	utp
+421	V	ipfs
+480	0	http
+443	0	https
+444	10	onion
\ No newline at end of file

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/protocols.go

+package multiaddr
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+)
+
+// Protocol is a Multiaddr protocol description structure.
+type Protocol struct {
+	Code  int
+	Size  int // a size of -1 indicates a length-prefixed variable size
+	Name  string
+	VCode []byte
+}
+
+// replicating table here to:
+// 1. avoid parsing the csv
+// 2. ensuring errors in the csv don't screw up code.
+// 3. changing a number has to happen in two places.
+const (
+	P_IP4   = 4
+	P_TCP   = 6
+	P_UDP   = 17
+	P_DCCP  = 33
+	P_IP6   = 41
+	P_SCTP  = 132
+	P_UTP   = 301
+	P_UDT   = 302
+	P_IPFS  = 421
+	P_HTTP  = 480
+	P_HTTPS = 443
+	P_ONION = 444
+)
+
+// These are special sizes
+const (
+	LengthPrefixedVarSize = -1
+)
+
+// Protocols is the list of multiaddr protocols supported by this module.
+var Protocols = []Protocol{
+	Protocol{P_IP4, 32, "ip4", CodeToVarint(P_IP4)},
+	Protocol{P_TCP, 16, "tcp", CodeToVarint(P_TCP)},
+	Protocol{P_UDP, 16, "udp", CodeToVarint(P_UDP)},
+	Protocol{P_DCCP, 16, "dccp", CodeToVarint(P_DCCP)},
+	Protocol{P_IP6, 128, "ip6", CodeToVarint(P_IP6)},
+	// these require varint:
+	Protocol{P_SCTP, 16, "sctp", CodeToVarint(P_SCTP)},
+	Protocol{P_ONION, 80, "onion", CodeToVarint(P_ONION)},
+	Protocol{P_UTP, 0, "utp", CodeToVarint(P_UTP)},
+	Protocol{P_UDT, 0, "udt", CodeToVarint(P_UDT)},
+	Protocol{P_HTTP, 0, "http", CodeToVarint(P_HTTP)},
+	Protocol{P_HTTPS, 0, "https", CodeToVarint(P_HTTPS)},
+	Protocol{P_IPFS, LengthPrefixedVarSize, "ipfs", CodeToVarint(P_IPFS)},
+}
+
+// ProtocolWithName returns the Protocol description with given string name.
+func ProtocolWithName(s string) Protocol {
+	for _, p := range Protocols {
+		if p.Name == s {
+			return p
+		}
+	}
+	return Protocol{}
+}
+
+// ProtocolWithCode returns the Protocol description with given protocol code.
+func ProtocolWithCode(c int) Protocol {
+	for _, p := range Protocols {
+		if p.Code == c {
+			return p
+		}
+	}
+	return Protocol{}
+}
+
+// ProtocolsWithString returns a slice of protocols matching given string.
+func ProtocolsWithString(s string) ([]Protocol, error) {
+	s = strings.Trim(s, "/")
+	sp := strings.Split(s, "/")
+	if len(sp) == 0 {
+		return nil, nil
+	}
+
+	t := make([]Protocol, len(sp))
+	for i, name := range sp {
+		p := ProtocolWithName(name)
+		if p.Code == 0 {
+			return nil, fmt.Errorf("no protocol with name: %s", name)
+		}
+		t[i] = p
+	}
+	return t, nil
+}
+
+// CodeToVarint converts an integer to a varint-encoded []byte
+func CodeToVarint(num int) []byte {
+	buf := make([]byte, (num/7)+1) // varint package is uint64
+	n := binary.PutUvarint(buf, uint64(num))
+	return buf[:n]
+}
+
+// VarintToCode converts a varint-encoded []byte to an integer protocol code
+func VarintToCode(buf []byte) int {
+	num, _ := ReadVarintCode(buf)
+	return num
+}
+
+// ReadVarintCode reads a varint code from the beginning of buf.
+// returns the code, and the number of bytes read.
+func ReadVarintCode(buf []byte) (int, int) {
+	num, n := binary.Uvarint(buf)
+	if n < 0 {
+		panic("varints larger than uint64 not yet supported")
+	}
+	return int(num), n
+}

vendor/QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr/util.go

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

vendor/QmanZCL6SXRfafiUEMCBLq2QR171uQSdXQ8YAdHXLd8Cwr/go-multiaddr-net/.travis.yml

+language: go
+
+go:
+  - 1.5.1
+
+script:
+  - make test
+
+env: 
+  - TEST_VERBOSE=1 GO15VENDOREXPERIMENT=1

vendor/QmanZCL6SXRfafiUEMCBLq2QR171uQSdXQ8YAdHXLd8Cwr/go-multiaddr-net/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/QmanZCL6SXRfafiUEMCBLq2QR171uQSdXQ8YAdHXLd8Cwr/go-multiaddr-net/Makefile

+GO15VENDOREXPERIMENT=1
+
+all: install
+
+gx:
+	go get github.com/whyrusleeping/gx
+	go get github.com/whyrusleeping/gx-go
+
+dep: gx
+	gx install
+
+test: 
+	go test -race -cpu=5 -v
+

vendor/QmanZCL6SXRfafiUEMCBLq2QR171uQSdXQ8YAdHXLd8Cwr/go-multiaddr-net/README.md

+# multiaddr/net - Multiaddr friendly net
+
+Package multiaddr/net provides [Multiaddr](http://github.com/jbenet/go-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

vendor/QmanZCL6SXRfafiUEMCBLq2QR171uQSdXQ8YAdHXLd8Cwr/go-multiaddr-net/convert.go

+package manet
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	ma "QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr"
+	utp "QmanZCL6SXRfafiUEMCBLq2QR171uQSdXQ8YAdHXLd8Cwr/go-multiaddr-net/utp"
+)
+
+var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
+
+// FromNetAddr converts a net.Addr type to a Multiaddr.
+func FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	if a == nil {
+		return nil, fmt.Errorf("nil multiaddr")
+	}
+
+	switch a.Network() {
+	case "tcp", "tcp4", "tcp6":
+		ac, ok := a.(*net.TCPAddr)
+		if !ok {
+			return nil, errIncorrectNetAddr
+		}
+
+		// Get IP Addr
+		ipm, err := FromIP(ac.IP)
+		if err != nil {
+			return nil, errIncorrectNetAddr
+		}
+
+		// Get TCP Addr
+		tcpm, err := ma.NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
+		if err != nil {
+			return nil, errIncorrectNetAddr
+		}
+
+		// Encapsulate
+		return ipm.Encapsulate(tcpm), nil
+
+	case "udp", "upd4", "udp6":
+		ac, ok := a.(*net.UDPAddr)
+		if !ok {
+			return nil, errIncorrectNetAddr
+		}
+
+		// Get IP Addr
+		ipm, err := FromIP(ac.IP)
+		if err != nil {
+			return nil, errIncorrectNetAddr
+		}
+
+		// Get UDP Addr
+		udpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
+		if err != nil {
+			return nil, errIncorrectNetAddr
+		}
+
+		// Encapsulate
+		return ipm.Encapsulate(udpm), nil
+
+	case "utp", "utp4", "utp6":
+		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
+
+	case "ip", "ip4", "ip6":
+		ac, ok := a.(*net.IPAddr)
+		if !ok {
+			return nil, errIncorrectNetAddr
+		}
+		return FromIP(ac.IP)
+
+	case "ip+net":
+		ac, ok := a.(*net.IPNet)
+		if !ok {
+			return nil, errIncorrectNetAddr
+		}
+		return FromIP(ac.IP)
+
+	default:
+		return nil, fmt.Errorf("unknown network %v", a.Network())
+	}
+}
+
+// ToNetAddr converts a Multiaddr to a net.Addr
+// Must be ThinWaist. acceptable protocol stacks are:
+// /ip{4,6}/{tcp, udp}
+func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+	network, host, err := DialArgs(maddr)
+	if err != nil {
+		return nil, err
+	}
+
+	switch network {
+	case "tcp", "tcp4", "tcp6":
+		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)
+	}
+
+	return nil, fmt.Errorf("network not supported: %s", network)
+}
+
+// FromIP converts a net.IP type to a Multiaddr.
+func FromIP(ip net.IP) (ma.Multiaddr, error) {
+	switch {
+	case ip.To4() != nil:
+		return ma.NewMultiaddr("/ip4/" + ip.String())
+	case ip.To16() != nil:
+		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 ma.Multiaddr) (string, string, error) {
+	if !IsThinWaist(m) {
+		return "", "", fmt.Errorf("%s is not a 'thin waist' address", m)
+	}
+
+	str := m.String()
+	parts := strings.Split(str, "/")[1:]
+
+	if len(parts) == 2 { // only IP
+		return parts[0], parts[1], nil
+	}
+
+	network := parts[2]
+	if parts[2] == "udp" && len(parts) > 4 && parts[4] == "utp" {
+		network = parts[4]
+	}
+
+	var host string
+	switch parts[0] {
+	case "ip4":
+		network = network + "4"
+		host = strings.Join([]string{parts[1], parts[3]}, ":")
+	case "ip6":
+		network = network + "6"
+		host = fmt.Sprintf("[%s]:%s", parts[1], parts[3])
+	}
+	return network, host, nil
+}