Struct DataPlane 

pub struct DataPlane {
    pub wireguard: Endpoint,
    pub or_out: Router,
    pub ur_out: Router,
    pub src_filter_in: Arc<Table<PeerId>>,
    pub or_in: Router,
    pub packet_filter: Arc<dyn Filter + Send + Sync>,
    pub active_peers: HashMap<PeerId, Instant>,
    pub events: Scheduler<Subsystem>,
    pub wg_next: Option<Handle<Subsystem>>,
    pub peer_gc_next: Option<Handle<Subsystem>>,
}

Transforms packets to make tailscale happen.

Fields

wireguard: Endpoint

Wireguard encryption/decryption.

or_out: Router

Outbound overlay router.

ur_out: Router

Outbound underlay router.

src_filter_in: Arc<Table<PeerId>>

Inbound source filter.

or_in: Router

Inbound overlay router.

packet_filter: Arc<dyn Filter + Send + Sync>

The packet filter.

active_peers: HashMap<PeerId, Instant>

Per-peer timestamps of last outgoing data packets.

Used to determine whether we should be running path discovery for this peer.

events: Scheduler<Subsystem>

Events queued for future processing.

wg_next: Option<Handle<Subsystem>>

Next event for the wireguard subsystem.

peer_gc_next: Option<Handle<Subsystem>>

Next event for the peer gc subsystem.

Implementations

impl DataPlane

pub fn new(my_key: NodeKeyPair) -> Self

Creates a new data plane for a wireguard node key.

pub fn process_outbound(&mut self, packets: Vec<PacketMut>) -> OutboundResult

Processes packets originating from the local device.

pub fn process_inbound( &mut self, packets: impl IntoIterator<Item = PacketMut>, ) -> InboundResult

Processes packets received from elsewhere.

pub fn next_event(&self) -> Option<Instant>

Return the next time at which DataPlane::process_events must be called.

DataPlane::process_outbound, DataPlane::process_inbound and DataPlane::process_events may all update the next event time. Callers should prefer calling next_event as needed to get a correct result, rather than store the returned value.

pub fn process_events(&mut self) -> Result

Process all queued events that are due for processing.

Must be called at least as often as dictated by DataPlane::next_event for the data plane to function correctly. It is harmless to call it more frequently.