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
- Variables
- func AddProtocol(p Protocol) error
- func CodeToVarint(num int) []byte
- func ForEach(m Multiaddr, cb func(c Component) bool)
- func ReadVarintCode(buf []byte) (int, int, error)
- func SplitFirst(m Multiaddr) (*Component, Multiaddr)
- func SplitFunc(m Multiaddr, cb func(Component) bool) (Multiaddr, Multiaddr)
- func SplitLast(m Multiaddr) (Multiaddr, *Component)
- func SwapToP2pMultiaddrs()
- func VarintSize(num int) int
- func VarintToCode(buf []byte) int
- type Component
- func (c *Component) Bytes() []byte
- func (c *Component) Decapsulate(o Multiaddr) Multiaddr
- func (c *Component) Encapsulate(o Multiaddr) Multiaddr
- func (c *Component) Equal(o Multiaddr) bool
- func (c *Component) Protocol() Protocol
- func (c *Component) Protocols() []Protocol
- func (c *Component) RawValue() []byte
- func (c *Component) String() string
- func (c *Component) Value() string
- func (c *Component) ValueForProtocol(code int) (string, error)
- type Multiaddr
- type Protocol
- type Transcoder
Constants ¶
const ( P_IP4 = 0x0004 P_TCP = 0x0006 P_UDP = 0x0111 P_DCCP = 0x0021 P_IP6 = 0x0029 P_IP6ZONE = 0x002A P_QUIC = 0x01CC P_SCTP = 0x0084 P_UDT = 0x012D P_UTP = 0x012E P_UNIX = 0x0190 P_P2P = 0x01A5 P_IPFS = 0x01A5 // alias for backwards compatability 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...
const (
LengthPrefixedVarSize = -1
)
These are special sizes
Variables ¶
var ErrProtocolNotFound = fmt.Errorf("protocol not found in multiaddr")
var Protocols = []Protocol{}
Protocols is the list of multiaddr protocols supported by this module.
var TranscoderIP4 = NewTranscoderFromFunctions(ip4StB, ip4BtS, nil)
var TranscoderIP6 = NewTranscoderFromFunctions(ip6StB, ip6BtS, nil)
var TranscoderIP6Zone = NewTranscoderFromFunctions(ip6zoneStB, ip6zoneBtS, ip6zoneVal)
var TranscoderOnion = NewTranscoderFromFunctions(onionStB, onionBtS, nil)
var TranscoderP2P = NewTranscoderFromFunctions(p2pStB, p2pBtS, p2pVal)
var TranscoderPort = NewTranscoderFromFunctions(portStB, portBtS, nil)
var TranscoderUnix = NewTranscoderFromFunctions(unixStB, unixBtS, nil)
Functions ¶
func AddProtocol ¶
func CodeToVarint ¶
CodeToVarint converts an integer to a varint-encoded []byte
func ForEach ¶
ForEach walks over the multiaddr, component by component.
This function iterates over components *by value* to avoid allocating.
func ReadVarintCode ¶
ReadVarintCode reads a varint code from the beginning of buf. returns the code, and the number of bytes read.
func SplitFirst ¶
SplitFirst returns the first component and the rest of the multiaddr.
func SplitFunc ¶
SplitFunc splits the multiaddr when the callback first returns true. The component on which the callback first returns will be included in the *second* multiaddr.
func SwapToP2pMultiaddrs ¶
func SwapToP2pMultiaddrs()
SwapToP2pMultiaddrs is a function to make the transition from /ipfs/... multiaddrs to /p2p/... multiaddrs easier The first stage of the rollout is to ship this package to all users so that all users of multiaddr can parse both /ipfs/ and /p2p/ multiaddrs as the same code (P_P2P). During this stage of the rollout, all addresses with P_P2P will continue printing as /ipfs/, so that older clients without the new parsing code won't break. Once the network has adopted the new parsing code broadly enough, users of multiaddr can add a call to this method to an init function in their codebase. This will cause any P_P2P multiaddr to print out as /p2p/ instead of /ipfs/. Note that the binary serialization of this multiaddr does not change at any point. This means that this code is not a breaking network change at any point
func VarintSize ¶
VarintSize returns the size (in bytes) of `num` encoded as a varint.
func VarintToCode ¶
VarintToCode converts a varint-encoded []byte to an integer protocol code
Types ¶
type Component ¶
type Component struct {
// contains filtered or unexported fields
}
Component is a single multiaddr Component.
func NewComponent ¶
NewComponent constructs a new multiaddr component
func (*Component) Decapsulate ¶
func (*Component) Encapsulate ¶
type Multiaddr ¶
type Multiaddr interface { // Equal returns whether two Multiaddrs are exactly equal Equal(Multiaddr) bool // Bytes returns the []byte representation of this Multiaddr // // This function may expose immutable, internal state. Do not modify. 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 // // Note: protocols can appear multiple times in a single multiaddr. // Consider using `ForEach` to walk over the addr manually. 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 NewMultiaddr ¶
NewMultiaddr parses and validates an input string, returning a *Multiaddr
func NewMultiaddrBytes ¶
NewMultiaddrBytes initializes a Multiaddr from a byte representation. It validates it as an input string.
func StringCast ¶
StringCast like Cast, but parses a string. Will also panic if it fails to parse.
type Protocol ¶
type Protocol struct { // Name is the string representation of the protocol code. E.g., ip4, // ip6, tcp, udp, etc. Name string // Code is the protocol's multicodec (a normal, non-varint number). Code int // VCode is a precomputed varint encoded version of Code. VCode []byte // Size is the size of the argument to this protocol. // // * Size == 0 means this protocol takes no argument. // * Size > 0 means this protocol takes a constant sized argument. // * Size < 0 means this protocol takes a variable length, varint // prefixed argument. Size int // a size of -1 indicates a length-prefixed variable size // Path indicates a path protocol (e.g., unix). When parsing multiaddr // strings, path protocols consume the remainder of the address instead // of stopping at the next forward slash. // // Size must be LengthPrefixedVarSize. Path bool // Transcoder converts between the byte representation and the string // representation of this protocol's argument (if any). // // This should only be non-nil if Size != 0 Transcoder Transcoder }
Protocol is a Multiaddr protocol description structure.
func ProtocolWithCode ¶
ProtocolWithCode returns the Protocol description with given protocol code.
func ProtocolWithName ¶
ProtocolWithName returns the Protocol description with given string name.
func ProtocolsWithString ¶
ProtocolsWithString returns a slice of protocols matching given string.