core

Documentation

Index

• Constants
• type AddHandler
• type AddHandlerFunc
• type AllowedPublicKey
• type Core
  • func New(cert *tls.Certificate, logger Logger, opts ...SetupOption) (*Core, error)
  • func (c *Core) AddPeer(u *url.URL, sintf string) error
  • func (c *Core) Address() net.IP
  • func (c *Core) CallPeer(u *url.URL, sintf string) error
  • func (c *Core) GetPaths() []PathEntryInfo
  • func (c *Core) GetPeers() []PeerInfo
  • func (c *Core) GetSelf() SelfInfo
  • func (c *Core) GetSessions() []SessionInfo
  • func (c *Core) GetTree() []TreeEntryInfo
  • func (c *Core) Listen(u *url.URL, sintf string) (*Listener, error)
  • func (c *Core) ListenLocal(u *url.URL, sintf string) (*Listener, error)
  • func (c *Core) MTU() uint64
  • func (c *Core) PublicKey() ed25519.PublicKey
  • func (c *Core) ReadFrom(p []byte) (n int, from net.Addr, err error)
  • func (c *Core) RemovePeer(u *url.URL, sintf string) error
  • func (c *Core) RetryPeersNow()
  • func (c *Core) SetAdmin(a AddHandler) error
  • func (c *Core) SetLogger(log Logger)
  • func (c *Core) SetPathNotify(notify func(ed25519.PublicKey))
  • func (c *Core) Stop()
  • func (c *Core) Subnet() net.IPNet
  • func (c *Core) WriteTo(p []byte, addr net.Addr) (n int, err error)
• type DebugGetPeersRequest
• type DebugGetPeersResponse
• type DebugGetSelfRequest
• type DebugGetSelfResponse
• type DebugGetTreeRequest
• type DebugGetTreeResponse
• type GetNodeInfoRequest
• type GetNodeInfoResponse
• type ListenAddress
• type Listener
  • func (l *Listener) Addr() net.Addr
• type Logger
• type NodeInfo
• type NodeInfoPrivacy
• type PathEntryInfo
• type Peer
• type PeerFilter
• type PeerInfo
• type SelfInfo
• type SessionInfo
• type SetupOption
• type TreeEntryInfo

Constants

const (
	ProtocolVersionMajor uint16 = 0
	ProtocolVersionMinor uint16 = 5
)

const ErrHandshakeHashFailure = handshakeError("invalid hash length")

const ErrHandshakeIncorrectPassword = handshakeError("password does not match remote side")

const ErrHandshakeInvalidLength = handshakeError("invalid handshake length, possible version mismatch")

const ErrHandshakeInvalidPassword = handshakeError("invalid password supplied, check your config")

const ErrHandshakeInvalidPreamble = handshakeError("invalid handshake, remote side is not Yggdrasil")

const ErrLinkAlreadyConfigured = linkError("peer is already configured")

const ErrLinkMaxBackoffInvalid = linkError("max backoff duration invalid")

const ErrLinkNoSuitableIPs = linkError("peer has no suitable addresses")

const ErrLinkNotConfigured = linkError("peer is not configured")

const ErrLinkPasswordInvalid = linkError("invalid password supplied")

const ErrLinkPinnedKeyInvalid = linkError("pinned public key is invalid")

const ErrLinkPriorityInvalid = linkError("priority value is invalid")

const ErrLinkSNINotSupported = linkError("SNI not supported on this link type")

const ErrLinkUnrecognisedSchema = linkError("link schema unknown")

Types

type AddHandler

type AddHandler interface {
	AddHandler(name, desc string, args []string, handlerfunc AddHandlerFunc) error
}

type AddHandlerFunc

type AddHandlerFunc func(json.RawMessage) (interface{}, error)

type AllowedPublicKey

type AllowedPublicKey ed25519.PublicKey

type Core

type Core struct {
	// This is the main data structure that holds everything else for a node
	// We're going to keep our own copy of the provided config - that way we can
	// guarantee that it will be covered by the mutex
	phony.Inbox
	*iwe.PacketConn
	// contains filtered or unexported fields
}

The Core object represents the Yggdrasil node. You should create a Core object for each Yggdrasil node you plan to run.

func New

func New(cert *tls.Certificate, logger Logger, opts ...SetupOption) (*Core, error)

func (*Core) AddPeer

func (c *Core) AddPeer(u *url.URL, sintf string) error

AddPeer adds a peer. This should be specified in the peer URI format, e.g.:

tcp://a.b.c.d:e
socks://a.b.c.d:e/f.g.h.i:j

This adds the peer to the peer list, so that they will be called again if the connection drops.

func (*Core) Address

func (c *Core) Address() net.IP

Address gets the IPv6 address of the Yggdrasil node. This is always a /128 address. The IPv6 address is only relevant when the node is operating as an IP router and often is meaningless when embedded into an application, unless that application also implements either VPN functionality or deals with IP packets specifically.

func (*Core) CallPeer

func (c *Core) CallPeer(u *url.URL, sintf string) error

CallPeer calls a peer once. This should be specified in the peer URI format, e.g.:

tcp://a.b.c.d:e
socks://a.b.c.d:e/f.g.h.i:j

This does not add the peer to the peer list, so if the connection drops, the peer will not be called again automatically.

func (*Core) GetPaths

func (c *Core) GetPaths() []PathEntryInfo

func (*Core) GetPeers

func (c *Core) GetPeers() []PeerInfo

func (*Core) GetSelf

func (c *Core) GetSelf() SelfInfo

func (*Core) GetSessions

func (c *Core) GetSessions() []SessionInfo

func (*Core) GetTree

func (c *Core) GetTree() []TreeEntryInfo

func (*Core) Listen

func (c *Core) Listen(u *url.URL, sintf string) (*Listener, error)

Listen starts a new listener (either TCP or TLS). The input should be a url.URL parsed from a string of the form e.g. "tcp://a.b.c.d:e". In the case of a link-local address, the interface should be provided as the second argument.

func (*Core) ListenLocal

func (c *Core) ListenLocal(u *url.URL, sintf string) (*Listener, error)

ListenLocal starts a listener, like the Listen function, but is used for more trustworthy situations where you want to ignore AllowedPublicKeys, i.e. with multicast listeners.

func (*Core) MTU

func (c *Core) MTU() uint64

func (*Core) PublicKey

func (c *Core) PublicKey() ed25519.PublicKey

func (*Core) ReadFrom

func (c *Core) ReadFrom(p []byte) (n int, from net.Addr, err error)

func (*Core) RemovePeer

func (c *Core) RemovePeer(u *url.URL, sintf string) error

RemovePeer removes a peer. The peer should be specified in URI format, see AddPeer. The peer is not disconnected immediately.

func (*Core) RetryPeersNow

func (c *Core) RetryPeersNow()

func (*Core) SetAdmin

func (c *Core) SetAdmin(a AddHandler) error

SetAdmin must be called after Init and before Start. It sets the admin handler for NodeInfo and the Debug admin functions.

func (*Core) SetLogger

func (c *Core) SetLogger(log Logger)

SetLogger sets the output logger of the Yggdrasil node after startup. This may be useful if you want to redirect the output later. Note that this expects a Logger from the github.com/gologme/log package and not from Go's built-in log package.

func (*Core) SetPathNotify

func (c *Core) SetPathNotify(notify func(ed25519.PublicKey))

func (*Core) Stop

func (c *Core) Stop()

Stop shuts down the Yggdrasil node.

func (*Core) Subnet

func (c *Core) Subnet() net.IPNet

Subnet gets the routed IPv6 subnet of the Yggdrasil node. This is always a /64 subnet. The IPv6 subnet is only relevant when the node is operating as an IP router and often is meaningless when embedded into an application, unless that application also implements either VPN functionality or deals with IP packets specifically.

func (*Core) WriteTo

func (c *Core) WriteTo(p []byte, addr net.Addr) (n int, err error)

type DebugGetPeersRequest

type DebugGetPeersRequest struct {
	Key string `json:"key"`
}

type DebugGetPeersResponse

type DebugGetPeersResponse map[string]interface{}

type DebugGetSelfRequest

type DebugGetSelfRequest struct {
	Key string `json:"key"`
}

type DebugGetSelfResponse

type DebugGetSelfResponse map[string]interface{}

type DebugGetTreeRequest

type DebugGetTreeRequest struct {
	Key string `json:"key"`
}

type DebugGetTreeResponse

type DebugGetTreeResponse map[string]interface{}

type GetNodeInfoRequest

type GetNodeInfoRequest struct {
	Key string `json:"key"`
}

type GetNodeInfoResponse

type GetNodeInfoResponse map[string]json.RawMessage

type ListenAddress

type ListenAddress string

type Listener

type Listener struct {
	Cancel context.CancelFunc
	// contains filtered or unexported fields
}

func (*Listener) Addr

func (l *Listener) Addr() net.Addr

type Logger

type Logger interface {
	Printf(string, ...interface{})
	Println(...interface{})
	Infof(string, ...interface{})
	Infoln(...interface{})
	Warnf(string, ...interface{})
	Warnln(...interface{})
	Errorf(string, ...interface{})
	Errorln(...interface{})
	Debugf(string, ...interface{})
	Debugln(...interface{})
	Traceln(...interface{})
}

type NodeInfo

type NodeInfo map[string]interface{}

type NodeInfoPrivacy

type NodeInfoPrivacy bool

type PathEntryInfo

type PathEntryInfo struct {
	Key      ed25519.PublicKey
	Path     []uint64
	Sequence uint64
}

type Peer

type Peer struct {
	URI             string
	SourceInterface string
}

type PeerFilter

type PeerFilter func(net.IP) bool

type PeerInfo

type PeerInfo struct {
	URI           string
	Up            bool
	Inbound       bool
	LastError     error
	LastErrorTime time.Time
	Key           ed25519.PublicKey
	Root          ed25519.PublicKey
	Coords        []uint64
	Port          uint64
	Priority      uint8
	Cost          uint64
	RXBytes       uint64
	TXBytes       uint64
	RXRate        uint64
	TXRate        uint64
	Uptime        time.Duration
	Latency       time.Duration
}

type SelfInfo

type SelfInfo struct {
	Key            ed25519.PublicKey
	RoutingEntries uint64
}

type SessionInfo

type SessionInfo struct {
	Key     ed25519.PublicKey
	RXBytes uint64
	TXBytes uint64
	Uptime  time.Duration
}

type SetupOption

type SetupOption interface {
	// contains filtered or unexported methods
}

type TreeEntryInfo

type TreeEntryInfo struct {
	Key      ed25519.PublicKey
	Parent   ed25519.PublicKey
	Sequence uint64
}