multiaddr

package module
v1.2.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 9, 2018 License: MIT Imports: 10 Imported by: 0

README

go-multiaddr

Travis CI codecov.io

multiaddr implementation in go

Multiaddr is a standard way to represent addresses that:

  • Support any standard network protocols.
  • Self-describe (include protocols).
  • Have a binary packed format.
  • Have a nice string representation.
  • Encapsulate well.

Table of Contents

Install

go get github.com/multiformats/go-multiaddr

Usage

Example
Simple
import ma "github.com/multiformats/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
// get the multiaddr protocol description objects
m1.Protocols()
// []Protocol{
//   Protocol{ Code: 4, Name: 'ip4', Size: 32},
//   Protocol{ Code: 17, Name: 'udp', Size: 16},
// }
En/decapsulate
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.

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

Maintainers

Captain: @whyrusleeping.

Contribute

Contributions welcome. Please check out the issues.

Check out our contributing document for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS Code of Conduct.

Small note: If editing the README, please conform to the standard-readme specification.

License

MIT © 2014 Juan Batiz-Benet

Documentation

Overview

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/multiformats/multiaddr

Basic Use: 

import (
  "bytes"
  "strings"
  ma "github.com/multiformats/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)

Index

Constants

View Source 
const (
	P_IP4   = 0x0004
	P_TCP   = 0x0006
	P_UDP   = 0x0111
	P_DCCP  = 0x0021
	P_IP6   = 0x0029
	P_QUIC  = 0x01CC
	P_SCTP  = 0x0084
	P_UDT   = 0x012D
	P_UTP   = 0x012E
	P_UNIX  = 0x0190
	P_IPFS  = 0x01A5
	P_HTTP  = 0x01E0
	P_HTTPS = 0x01BB
	P_ONION = 0x01BC
)

You **MUST** register your multicodecs with https://github.com/multiformats/multicodec before adding them here.

TODO: Use a single source of truth for all multicodecs instead of distributing them like this...

View Source 
const (
	LengthPrefixedVarSize = -1
)

These are special sizes

Variables

View Source 
var ErrProtocolNotFound = fmt.Errorf("protocol not found in multiaddr")
View Source 
var Protocols = []Protocol{
	Protocol{P_IP4, 32, "ip4", CodeToVarint(P_IP4), false, TranscoderIP4},
	Protocol{P_TCP, 16, "tcp", CodeToVarint(P_TCP), false, TranscoderPort},
	Protocol{P_UDP, 16, "udp", CodeToVarint(P_UDP), false, TranscoderPort},
	Protocol{P_DCCP, 16, "dccp", CodeToVarint(P_DCCP), false, TranscoderPort},
	Protocol{P_IP6, 128, "ip6", CodeToVarint(P_IP6), false, TranscoderIP6},

	Protocol{P_SCTP, 16, "sctp", CodeToVarint(P_SCTP), false, TranscoderPort},
	Protocol{P_ONION, 96, "onion", CodeToVarint(P_ONION), false, TranscoderOnion},
	Protocol{P_UTP, 0, "utp", CodeToVarint(P_UTP), false, nil},
	Protocol{P_UDT, 0, "udt", CodeToVarint(P_UDT), false, nil},
	Protocol{P_QUIC, 0, "quic", CodeToVarint(P_QUIC), false, nil},
	Protocol{P_HTTP, 0, "http", CodeToVarint(P_HTTP), false, nil},
	Protocol{P_HTTPS, 0, "https", CodeToVarint(P_HTTPS), false, nil},
	Protocol{P_IPFS, LengthPrefixedVarSize, "ipfs", CodeToVarint(P_IPFS), false, TranscoderIPFS},
	Protocol{P_UNIX, LengthPrefixedVarSize, "unix", CodeToVarint(P_UNIX), true, TranscoderUnix},
}

Protocols is the list of multiaddr protocols supported by this module.

View Source 
var TranscoderIP4 = NewTranscoderFromFunctions(ip4StB, ipBtS)
View Source 
var TranscoderIP6 = NewTranscoderFromFunctions(ip6StB, ipBtS)
View Source 
var TranscoderIPFS = NewTranscoderFromFunctions(ipfsStB, ipfsBtS)
View Source 
var TranscoderOnion = NewTranscoderFromFunctions(onionStB, onionBtS)
View Source 
var TranscoderPort = NewTranscoderFromFunctions(portStB, portBtS)
View Source 
var TranscoderUnix = NewTranscoderFromFunctions(unixStB, unixBtS)

Functions

func AddProtocol 

func AddProtocol(p Protocol) error

func CodeToVarint 

func CodeToVarint(num int) []byte

CodeToVarint converts an integer to a varint-encoded []byte

func ReadVarintCode 

func ReadVarintCode(buf []byte) (int, int, error)

ReadVarintCode reads a varint code from the beginning of buf. returns the code, and the number of bytes read.

func VarintToCode 

func VarintToCode(buf []byte) int

VarintToCode converts a varint-encoded []byte to an integer protocol code

Types

type Multiaddr 

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

	// ValueForProtocol returns the value (if any) following the specified protocol
	ValueForProtocol(code int) (string, error)
}

Multiaddr is a cross-protocol, cross-platform format for representing internet addresses. It emphasizes explicitness and self-description. Learn more here: https://github.com/multiformats/multiaddr

Multiaddrs have both a binary and string representation. 

import ma "github.com/multiformats/go-multiaddr"

addr, err := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/80")
// err non-nil when parsing failed.

func Cast 

func Cast(b []byte) Multiaddr

Cast re-casts a byte slice as a multiaddr. will panic if it fails to parse.

func Join 

func Join(ms ...Multiaddr) Multiaddr

Join returns a combination of addresses.

func NewMultiaddr 

func NewMultiaddr(s string) (a Multiaddr, err error)

NewMultiaddr parses and validates an input string, returning a *Multiaddr

func NewMultiaddrBytes 

func NewMultiaddrBytes(b []byte) (a Multiaddr, err error)

NewMultiaddrBytes initializes a Multiaddr from a byte representation. It validates it as an input string.

func Split 

func Split(m Multiaddr) []Multiaddr

Split returns the sub-address portions of a multiaddr.

func StringCast 

func StringCast(s string) Multiaddr

StringCast like Cast, but parses a string. Will also panic if it fails to parse.

type Protocol 

type Protocol struct {
	Code       int
	Size       int // a size of -1 indicates a length-prefixed variable size
	Name       string
	VCode      []byte
	Path       bool // indicates a path protocol (eg unix, http)
	Transcoder Transcoder
}

Protocol is a Multiaddr protocol description structure.

func ProtocolWithCode 

func ProtocolWithCode(c int) Protocol

ProtocolWithCode returns the Protocol description with given protocol code.

func ProtocolWithName 

func ProtocolWithName(s string) Protocol

ProtocolWithName returns the Protocol description with given string name.

func ProtocolsWithString 

func ProtocolsWithString(s string) ([]Protocol, error)

ProtocolsWithString returns a slice of protocols matching given string.

type Transcoder added in v1.1.3 

type Transcoder interface {
	StringToBytes(string) ([]byte, error)
	BytesToString([]byte) (string, error)
}

func NewTranscoderFromFunctions added in v1.1.3 

func NewTranscoderFromFunctions(s2b func(string) ([]byte, error),
	b2s func([]byte) (string, error)) Transcoder

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.