multiaddr

package module
v0.0.5 Latest Latest
Warning

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

 Go to latest Published: Dec 20, 2024 License: MIT Imports: 20 Imported by: 71

README

go-multiaddr

GoDoc 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
import ma "github.com/multiformats/go-multiaddr"

m, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
// <Multiaddr /ip4/127.0.0.1/udp/1234>

sctpMA, err := ma.NewMultiaddr("/sctp/5678")

m.Encapsulate(sctpMA)
// <Multiaddr /ip4/127.0.0.1/udp/1234/sctp/5678>

udpMA, err := ma.NewMultiaddr("/udp/1234")

m.Decapsulate(udpMA) // 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

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 "gitlab.dms3.io/mf/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               = 4
	P_TCP               = 6
	P_DNS               = 53 // 4 or 6
	P_DNS4              = 54
	P_DNS6              = 55
	P_DNSADDR           = 56
	P_UDP               = 273
	P_DCCP              = 33
	P_IP6               = 41
	P_IP6ZONE           = 42
	P_IPCIDR            = 43
	P_QUIC              = 460
	P_QUIC_V1           = 461
	P_WEBTRANSPORT      = 465
	P_CERTHASH          = 466
	P_SCTP              = 132
	P_CIRCUIT           = 290
	P_UDT               = 301
	P_UTP               = 302
	P_UNIX              = 400
	P_P2P               = 421
	P_IPFS              = P_P2P // alias for backwards compatibility
	P_HTTP              = 480
	P_HTTP_PATH         = 481
	P_HTTPS             = 443 // deprecated alias for /tls/http
	P_ONION             = 444 // also for backwards compatibility
	P_ONION3            = 445
	P_GARLIC64          = 446
	P_GARLIC32          = 447
	P_P2P_WEBRTC_DIRECT = 276 // Deprecated. use webrtc-direct instead
	P_TLS               = 448
	P_SNI               = 449
	P_NOISE             = 454
	P_WS                = 477
	P_WSS               = 478 // deprecated alias for /tls/ws
	P_PLAINTEXTV2       = 7367777
	P_WEBRTC_DIRECT     = 280
	P_WEBRTC            = 281
	P_MEMORY            = 777
	P_DMS3              = 4063653 // hex: 0x3E01A5
)

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

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{}

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

View Source 
var TranscoderCertHash = NewTranscoderFromFunctions(certHashStB, certHashBtS, validateCertHash)
View Source 
var TranscoderDMS3 = NewTranscoderFromFunctions(dms3StB, dms3BtS, dms3Val)
View Source 
var TranscoderDns = NewTranscoderFromFunctions(dnsStB, dnsBtS, dnsVal)
View Source 
var TranscoderGarlic32 = NewTranscoderFromFunctions(garlic32StB, garlic32BtS, garlic32Validate)
View Source 
var TranscoderGarlic64 = NewTranscoderFromFunctions(garlic64StB, garlic64BtS, garlic64Validate)
View Source 
var TranscoderHTTPPath = NewTranscoderFromFunctions(httpPathStB, httpPathBtS, validateHTTPPath)
View Source 
var TranscoderIP4 = NewTranscoderFromFunctions(ip4StB, ip4BtS, nil)
View Source 
var TranscoderIP6 = NewTranscoderFromFunctions(ip6StB, ip6BtS, nil)
View Source 
var TranscoderIP6Zone = NewTranscoderFromFunctions(ip6zoneStB, ip6zoneBtS, ip6zoneVal)
View Source 
var TranscoderIPCIDR = NewTranscoderFromFunctions(ipcidrStB, ipcidrBtS, ipcidrValidate)
View Source 
var TranscoderMemory = NewTranscoderFromFunctions(memoryStB, memoryBtS, memoryValidate)
View Source 
var TranscoderOnion = NewTranscoderFromFunctions(onionStB, onionBtS, onionValidate)
View Source 
var TranscoderOnion3 = NewTranscoderFromFunctions(onion3StB, onion3BtS, onion3Validate)
View Source 
var TranscoderP2P = NewTranscoderFromFunctions(p2pStB, p2pBtS, p2pVal)
View Source 
var TranscoderPort = NewTranscoderFromFunctions(portStB, portBtS, nil)
View Source 
var TranscoderUnix = NewTranscoderFromFunctions(unixStB, unixBtS, unixValidate)

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 Contains added in v0.0.4 

func Contains(addrs []Multiaddr, addr Multiaddr) bool

Contains reports whether addr is contained in addrs.

func ForEach 

func ForEach(m Multiaddr, cb func(c Component) bool)

ForEach walks over the multiaddr, component by component.

This function iterates over components *by value* to avoid allocating. Return true to continue iteration, false to stop.

func ReadVarintCode 

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

func SplitFirst 

func SplitFirst(m Multiaddr) (*Component, Multiaddr)

SplitFirst returns the first component and the rest of the multiaddr.

func SplitFunc 

func SplitFunc(m Multiaddr, cb func(Component) bool) (Multiaddr, Multiaddr)

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 SplitLast 

func SplitLast(m Multiaddr) (Multiaddr, *Component)

SplitLast returns the rest of the multiaddr and the last component.

Types

type Action 

type Action int32

Action is an enum modelling all possible filter actions. 

const (
	ActionNone Action = iota // zero value.
	ActionAccept
	ActionDeny
)

type Component 

type Component struct {
	// contains filtered or unexported fields
}

Component is a single multiaddr Component.

func NewComponent 

func NewComponent(protocol, value string) (*Component, error)

NewComponent constructs a new multiaddr component

func (*Component) Bytes 

func (c *Component) Bytes() []byte

func (*Component) Decapsulate 

func (c *Component) Decapsulate(o Multiaddr) Multiaddr

func (*Component) Encapsulate 

func (c *Component) Encapsulate(o Multiaddr) Multiaddr

func (*Component) Equal 

func (c *Component) Equal(o Multiaddr) bool

func (*Component) MarshalBinary 

func (c *Component) MarshalBinary() ([]byte, error)

func (*Component) MarshalJSON 

func (c *Component) MarshalJSON() ([]byte, error)

func (*Component) MarshalText 

func (c *Component) MarshalText() ([]byte, error)

func (*Component) Protocol 

func (c *Component) Protocol() Protocol

func (*Component) Protocols 

func (c *Component) Protocols() []Protocol

func (*Component) RawValue 

func (c *Component) RawValue() []byte

func (*Component) String 

func (c *Component) String() string

func (*Component) UnmarshalBinary 

func (c *Component) UnmarshalBinary(data []byte) error

func (*Component) UnmarshalJSON 

func (m *Component) UnmarshalJSON(data []byte) error

func (*Component) UnmarshalText 

func (c *Component) UnmarshalText(data []byte) error

func (*Component) Value 

func (c *Component) Value() string

func (*Component) ValueForProtocol 

func (c *Component) ValueForProtocol(code int) (string, error)

type Filters 

type Filters struct {
	DefaultAction Action
	// contains filtered or unexported fields
}

Filters is a structure representing a collection of accept/deny net.IPNet filters, together with the DefaultAction flag, which represents the default filter policy.

Note that the last policy added to the Filters is authoritative.

func NewFilters 

func NewFilters() *Filters

NewFilters constructs and returns a new set of net.IPNet filters. By default, the new filter accepts all addresses.

func (*Filters) ActionForFilter 

func (fs *Filters) ActionForFilter(ipnet net.IPNet) (action Action, ok bool)

func (*Filters) AddFilter 

func (fs *Filters) AddFilter(ipnet net.IPNet, action Action)

AddFilter adds a rule to the Filters set, enforcing the desired action for the provided IPNet mask.

func (*Filters) AddrBlocked 

func (fs *Filters) AddrBlocked(a Multiaddr) (deny bool)

AddrBlocked parses a ma.Multiaddr and, if a valid netip is found, it applies the Filter set rules, returning true if the given address should be denied, and false if the given address is accepted.

If a parsing error occurs, or no filter matches, the Filters' default is returned.

TODO: currently, the last filter to match wins always, but it shouldn't be that way. 

Instead, the highest-specific last filter should win; that way more specific filters
override more general ones.

func (*Filters) FiltersForAction 

func (fs *Filters) FiltersForAction(action Action) (result []net.IPNet)

FiltersForAction returns the filters associated with the indicated action.

func (*Filters) RemoveLiteral 

func (fs *Filters) RemoveLiteral(ipnet net.IPNet) (removed bool)

RemoveLiteral removes the first filter associated with the supplied IPNet, returning whether something was removed or not. It makes no distinction between whether the rule is an accept or a deny.

type Multiaddr 

type Multiaddr interface {
	json.Marshaler
	json.Unmarshaler
	encoding.TextMarshaler
	encoding.TextUnmarshaler
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler

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

	// Decapsulate removes a Multiaddr wrapping. For example:
	//
	//      /ip4/1.2.3.4/tcp/80 decapsulate /tcp/80 = /ip4/1.2.3.4
	//      /ip4/1.2.3.4/tcp/80 decapsulate /udp/80 = /ip4/1.2.3.4/tcp/80
	//      /ip4/1.2.3.4/tcp/80 decapsulate /ip4/1.2.3.4 = nil
	//
	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 "gitlab.dms3.io/mf/go-multiaddr"

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

	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 FilterAddrs added in v0.0.4 

func FilterAddrs(a []Multiaddr, filters ...func(Multiaddr) bool) []Multiaddr

FilterAddrs is a filter that removes certain addresses, according to the given filters. If all filters return true, the address is kept.

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.

func Unique added in v0.0.4 

func Unique(addrs []Multiaddr) []Multiaddr

Unique deduplicates addresses in place, leave only unique addresses. It doesn't allocate.

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 

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 

type Transcoder interface {
	// Validates and encodes to bytes a multiaddr that's in the string representation.
	StringToBytes(string) ([]byte, error)
	// Validates and decodes to a string a multiaddr that's in the bytes representation.
	BytesToString([]byte) (string, error)
	// Validates bytes when parsing a multiaddr that's already in the bytes representation.
	ValidateBytes([]byte) error
}

func NewTranscoderFromFunctions 

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

Source Files

View all Source files

Directories

Path Synopsis
Package manet provides Multiaddr specific versions of common functions in stdlib's net package.
 Package manet provides Multiaddr specific versions of common functions in stdlib's net package.

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.