actors

package
v0.0.0-...-4449afe Latest Latest
Warning

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

 Go to latest Published: Apr 14, 2025 License: MIT Imports: 36 Imported by: 0

README

TMan (Traffic Manager) contains logic that will try to holepunch NATs periodically if it detects that a connection is being used.

The Mermaid State Diagram under peer_state/peer_state.mermaid outlines this internal process.

The actors.mermaid diagram outlines the interactions between different actors.

Documentation

Overview

Package actors is the "meat and bones" of the toversok engine; it has an actor-message system to facilitate dynamic/resilient configuration with many peers.

For a primary reference of how actors are assembled, look at [actors.mermaid].

The sub-package peer_state contains state specific to the direct connection with another peer.

Index

Constants

View Source 
const (
	SockRecvReadTimeout  = 5 * time.Second
	ConnActivityInterval = 10 * time.Second

	// DefaultSafeMTU is a small MTU that's safe, absent other information.
	DefaultSafeMTU uint16 = 1280

	// Inbox
	OutConnInboxChanBuffer = 10
	SessManInboxChLen      = 32
	TrafficManInboxChLen   = 16
	RelayManInboxChLen     = 4
	DirectRouterInboxChLen = 4
	MdnsManInboxChLen      = 32

	// Frame
	SockRecvFrameChanBuffer = 256
	InConnFrameChanBuffer   = 512

	RelayManFrameChLen      = 8
	RelayManWriteChLen      = 8
	RelayRouterFrameChLen   = 4
	RelayConnSendBufferSize = 32

	DirectManWriteChLen    = 4 * 16
	DirectRouterFrameChLen = 4 * 16

	TManTickerInterval = time.Millisecond * 250

	EManTickerInterval = time.Second * 60

	EManStunTimeout = time.Second * 10

	RelayConnectionRetryInterval = time.Second * 5

	RelayConnectionIdleAfter = time.Minute * 1
)
View Source 
const HomeRelayChangeInterval = time.Minute * 5
View Source 
const PingReapTimeout = 10 * time.Minute

Variables

View Source 
var DebugSManTakeNodeAsSession = false
View Source 
var (
	MDNSPort uint16 = 5353
)

Functions

func L 

func L(a ifaces.Actor) *slog.Logger

func MakeStage 

func MakeStage(
	pCtx context.Context,

	nodePriv func() *key.NodePrivate,
	sessPriv func() *key.SessionPrivate,

	bindExt func() types.UDPConn,
	bindLocal func(peer key.NodePublic) types.UDPConn,
	controlSession ifaces.ControlInterface,

	dialRelayFunc relayhttp.RelayDialFunc,

	wgIf *net.Interface,
) ifaces.Stage

func SendMessage 

func SendMessage(ch chan<- msgactor.ActorMessage, msg msgactor.ActorMessage)

SendMessage is a convenience function to allow for "go SendMessage()"

Types

type ActorCommon 

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

func MakeCommon 

func MakeCommon(pCtx context.Context, chLen int) *ActorCommon

func (*ActorCommon) Cancel 

func (ac *ActorCommon) Cancel()

func (*ActorCommon) Ctx 

func (ac *ActorCommon) Ctx() context.Context

func (*ActorCommon) Inbox 

func (ac *ActorCommon) Inbox() chan<- msgactor.ActorMessage

type DirectManager 

type DirectManager struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*DirectManager) Close 

func (dm *DirectManager) Close()

func (*DirectManager) Run 

func (dm *DirectManager) Run()

func (*DirectManager) WriteTo 

func (dm *DirectManager) WriteTo(pkt []byte, addr netip.AddrPort)

WriteTo queues a UDP write request to a certain addr-port pair.

Will be called by other actors.

If the Packet is larger than the current MTU, it will be broken up.

type DirectRouter 

type DirectRouter struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*DirectRouter) Close 

func (dr *DirectRouter) Close()

func (*DirectRouter) Push 

func (dr *DirectRouter) Push(frame ifaces.DirectedPeerFrame)

func (*DirectRouter) Run 

func (dr *DirectRouter) Run()

type EndpointManager 

type EndpointManager struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*EndpointManager) Close 

func (em *EndpointManager) Close()

func (*EndpointManager) Run 

func (em *EndpointManager) Run()

type InConn 

type InConn struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func MakeInConn 

func MakeInConn(udp types.UDPConn, peer key.NodePublic, s *Stage) *InConn

func (*InConn) Bump 

func (ic *InConn) Bump()

Bump the activity timer.

func (*InConn) Close 

func (ic *InConn) Close()

func (*InConn) Ctx 

func (ic *InConn) Ctx() context.Context

func (*InConn) ForwardPacket 

func (ic *InConn) ForwardPacket(pkt []byte)

ForwardPacket does a non-blocking packet forward.

This prevents routers from blocking when the conn is shutting down, or if its blocked otherwise.

func (*InConn) Run 

func (ic *InConn) Run()

func (*InConn) SendActivity 

func (ic *InConn) SendActivity(isActive bool)

func (*InConn) UnBump 

func (ic *InConn) UnBump()

UnBump is called when the activity timer fires in the main loop

type InConnActor 

type InConnActor interface {
	ifaces.Actor

	ForwardPacket(pkt []byte)
}

type MDNSManager 

type MDNSManager struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*MDNSManager) Close 

func (mm *MDNSManager) Close()

func (*MDNSManager) Run 

func (mm *MDNSManager) Run()

type OutConn 

type OutConn struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func MakeOutConn 

func MakeOutConn(udp types.UDPConn, peer key.NodePublic, homeRelay int64, s *Stage) *OutConn

func (*OutConn) Bump 

func (oc *OutConn) Bump()

Bump the activity timer.

func (*OutConn) Close 

func (oc *OutConn) Close()

func (*OutConn) Ctx 

func (oc *OutConn) Ctx() context.Context

func (*OutConn) Inbox 

func (oc *OutConn) Inbox() chan<- msgactor.ActorMessage

func (*OutConn) Run 

func (oc *OutConn) Run()

func (*OutConn) SendActivity 

func (oc *OutConn) SendActivity(isActive bool)

func (*OutConn) UnBump 

func (oc *OutConn) UnBump()

UnBump is called when the activity timer fires in the main loop

type OutConnActor 

type OutConnActor interface {
	ifaces.Actor
}

type RecvFrame 

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

type RelayConnActor 

type RelayConnActor interface {
	ifaces.Actor

	Queue(pkt []byte, peer key.NodePublic)
	Update(info relay.Information)
	StayConnected(bool)
	IsConnected() bool
	Config() *relay.Information
}

type RelayManager 

type RelayManager struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*RelayManager) Close 

func (rm *RelayManager) Close()

func (*RelayManager) Run 

func (rm *RelayManager) Run()

func (*RelayManager) WriteTo 

func (rm *RelayManager) WriteTo(pkt []byte, relay int64, dst key.NodePublic)

WriteTo queues a packet relay request to a relay ID, for a certain public key.

Will be called by other actors.

type RelayRouter 

type RelayRouter struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*RelayRouter) Close 

func (rr *RelayRouter) Close()

func (*RelayRouter) Push 

func (rr *RelayRouter) Push(frame ifaces.RelayedPeerFrame)

func (*RelayRouter) Run 

func (rr *RelayRouter) Run()

type RestartableRelayConn 

type RestartableRelayConn struct {
	*ActorCommon
	// contains filtered or unexported fields
}

RestartableRelayConn is a Relay connection that will automatically reconnect, as long as there are pending packets.

func (*RestartableRelayConn) Close 

func (c *RestartableRelayConn) Close()

func (*RestartableRelayConn) Config 

func (c *RestartableRelayConn) Config() *relay.Information

func (*RestartableRelayConn) IsConnected 

func (c *RestartableRelayConn) IsConnected() bool

func (*RestartableRelayConn) L 

func (c *RestartableRelayConn) L() *slog.Logger

func (*RestartableRelayConn) Poke 

func (c *RestartableRelayConn) Poke()

func (*RestartableRelayConn) Queue 

func (c *RestartableRelayConn) Queue(pkt []byte, dst key.NodePublic)

Queue queues the pkt for dst in a non-blocking fashion

func (*RestartableRelayConn) Run 

func (c *RestartableRelayConn) Run()

func (*RestartableRelayConn) StayConnected 

func (c *RestartableRelayConn) StayConnected(stay bool)

func (*RestartableRelayConn) Update 

func (c *RestartableRelayConn) Update(info relay.Information)

type RunCheck 

type RunCheck struct {
	*atomic.Bool
}

RunCheck ensures that only one instance of the actor is running at all times.

func MakeRunCheck 

func MakeRunCheck() RunCheck

func (*RunCheck) CheckOrMark 

func (rc *RunCheck) CheckOrMark() bool

CheckOrMark atomically checks if its already running, else marks as running, returns a false value if the instance is already running.

type SessionManager 

type SessionManager struct {
	*ActorCommon
	// contains filtered or unexported fields
}

SessionManager receives frames from routers and decrypts them, and forwards the resulting messages to the traffic manager.

It also receives messages from the traffic manager, encrypts them, and forwards them to the direct/relay managers.

func (*SessionManager) Close 

func (sm *SessionManager) Close()

func (*SessionManager) Handle 

func (sm *SessionManager) Handle(msg msgactor.ActorMessage)

func (*SessionManager) Pack 

func (sm *SessionManager) Pack(sMsg msgsess.SessionMessage, toSession key.SessionPublic) []byte

func (*SessionManager) Run 

func (sm *SessionManager) Run()

func (*SessionManager) Session 

func (sm *SessionManager) Session() key.SessionPublic

func (*SessionManager) Unpack 

func (sm *SessionManager) Unpack(frameWithMagic []byte) (*msgsess.ClearMessage, error)

type SockRecv 

type SockRecv struct {
	*ActorCommon

	Conn types.UDPConn
	// contains filtered or unexported fields
}

func MakeSockRecv 

func MakeSockRecv(ctx context.Context, udp types.UDPConn) *SockRecv

func (*SockRecv) Close 

func (r *SockRecv) Close()

func (*SockRecv) Run 

func (r *SockRecv) Run()

type Stage 

type Stage struct {
	// The parent context of the stage that all actors must parent
	Ctx context.Context

	// The DirectManager
	DMan ifaces.DirectManagerActor
	// The DirectRouter
	DRouter ifaces.DirectRouterActor

	// The RelayManager
	RMan ifaces.RelayManagerActor
	// The RelayRouter
	RRouter ifaces.RelayRouterActor

	// The TrafficManager
	TMan ifaces.TrafficManagerActor
	// The SessionManager
	SMan ifaces.SessionManagerActor
	// The EndpointManager
	EMan ifaces.EndpointManagerActor
	// The MDNSManager
	MMan ifaces.MDNSManagerActor
	// contains filtered or unexported fields
}

Stage for the Actors

func (*Stage) AddPeer 

func (s *Stage) AddPeer(peer key.NodePublic, homeRelay int64, endpoints []netip.AddrPort, session key.SessionPublic, ip4, ip6 netip.Addr, prop msgcontrol.Properties) error

func (*Stage) Close 

func (s *Stage) Close()

func (*Stage) Context 

func (s *Stage) Context() context.Context

func (*Stage) ControlSTUN 

func (s *Stage) ControlSTUN() []netip.AddrPort

ControlSTUN returns a set of endpoints pertaining to Control's STUN addrpairs

func (*Stage) GetEndpoints 

func (s *Stage) GetEndpoints() []netip.AddrPort

func (*Stage) GetPeerInfo 

func (s *Stage) GetPeerInfo(peer key.NodePublic) *stage.PeerInfo

GetPeerInfo gets a copy of the peerinfo for peer

func (*Stage) GetPeersWhere 

func (s *Stage) GetPeersWhere(f func(key.NodePublic, *stage.PeerInfo) bool) []key.NodePublic

func (*Stage) InConnFor 

func (s *Stage) InConnFor(peer key.NodePublic) InConnActor

InConnFor Looks up the InConn for a peer. Returns nil if it doesn't exist.

func (*Stage) OutConnFor 

func (s *Stage) OutConnFor(peer key.NodePublic) OutConnActor

OutConnFor Looks up the OutConn for a peer. Returns nil if it doesn't exist.

func (*Stage) RemovePeer 

func (s *Stage) RemovePeer(peer key.NodePublic) error

func (*Stage) SetEndpoints 

func (s *Stage) SetEndpoints(peer key.NodePublic, endpoints []netip.AddrPort) error

SetEndpoints set the known public addresses for a particular peer.

func (*Stage) Start 

func (s *Stage) Start()

Start kicks off goroutines for the stage and returns

func (*Stage) UpdateHomeRelay 

func (s *Stage) UpdateHomeRelay(peer key.NodePublic, relay int64) error

func (*Stage) UpdatePeer 

func (s *Stage) UpdatePeer(peer key.NodePublic, homeRelay *int64, endpoints []netip.AddrPort, session *key.SessionPublic, prop *msgcontrol.Properties) error

func (*Stage) UpdateRelays 

func (s *Stage) UpdateRelays(relays []relay.Information) error

func (*Stage) UpdateSessionKey 

func (s *Stage) UpdateSessionKey(peer key.NodePublic, session key.SessionPublic) error

UpdateSessionKey updates the known session key for a particular peer.

func (*Stage) Watchdog 

func (s *Stage) Watchdog()

Watchdog will be run to constantly check for faults on the stage and repair them.

type StateForState 

type StateForState func(state peerstate.PeerState) peerstate.PeerState

type TrafficManager 

type TrafficManager struct {
	*ActorCommon
	// contains filtered or unexported fields
}

func (*TrafficManager) ActiveIn 

func (tm *TrafficManager) ActiveIn() map[key.NodePublic]bool

func (*TrafficManager) ActiveOut 

func (tm *TrafficManager) ActiveOut() map[key.NodePublic]bool

func (*TrafficManager) Close 

func (tm *TrafficManager) Close()

func (*TrafficManager) DManClearAKA 

func (tm *TrafficManager) DManClearAKA(peer key.NodePublic)

func (*TrafficManager) DManSetAKA 

func (tm *TrafficManager) DManSetAKA(peer key.NodePublic, ap netip.AddrPort)

func (*TrafficManager) DoStateTick 

func (tm *TrafficManager) DoStateTick()

func (*TrafficManager) Handle 

func (tm *TrafficManager) Handle(m msgactor.ActorMessage)

func (*TrafficManager) NodeForSess 

func (tm *TrafficManager) NodeForSess(sess key.SessionPublic) *key.NodePublic

func (*TrafficManager) OutConnTrackHome 

func (tm *TrafficManager) OutConnTrackHome(peer key.NodePublic)

func (*TrafficManager) OutConnUseAddrPort 

func (tm *TrafficManager) OutConnUseAddrPort(peer key.NodePublic, ap netip.AddrPort)

func (*TrafficManager) OutConnUseRelay 

func (tm *TrafficManager) OutConnUseRelay(peer key.NodePublic, relay int64)

func (*TrafficManager) Pings 

func (tm *TrafficManager) Pings() map[msgsess.TxID]*stage.SentPing

func (*TrafficManager) Poke 

func (tm *TrafficManager) Poke()

Poke is a convenience method to have TMan poke OnTick for states ASAP (after message queues get cleared).

func (*TrafficManager) Run 

func (tm *TrafficManager) Run()

func (*TrafficManager) SendMsgToDirect 

func (tm *TrafficManager) SendMsgToDirect(ap netip.AddrPort, sess key.SessionPublic, m msgsess.SessionMessage)

func (*TrafficManager) SendMsgToRelay 

func (tm *TrafficManager) SendMsgToRelay(relay int64, peer key.NodePublic, sess key.SessionPublic, m msgsess.SessionMessage)

func (*TrafficManager) SendPingDirect 

func (tm *TrafficManager) SendPingDirect(endpoint netip.AddrPort, peer key.NodePublic, session key.SessionPublic)

func (*TrafficManager) SendPingDirectWithID 

func (tm *TrafficManager) SendPingDirectWithID(endpoint netip.AddrPort, peer key.NodePublic, session key.SessionPublic, txid msgsess.TxID)

func (*TrafficManager) SendPingRelay 

func (tm *TrafficManager) SendPingRelay(relay int64, peer key.NodePublic, session key.SessionPublic)

func (*TrafficManager) Stage 

func (tm *TrafficManager) Stage() ifaces.Stage

func (*TrafficManager) ValidKeys 

func (tm *TrafficManager) ValidKeys(peer key.NodePublic, session key.SessionPublic) bool

Source Files

View all Source files

Directories

Path Synopsis
Package peer_state contains a state machine that tries to drive a direct connection with another peer to establishment.
 Package peer_state contains a state machine that tries to drive a direct connection with another peer to establishment.

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.