Struct DatagramDemux 

pub struct DatagramDemux<S> { /* private fields */ }

Available on crate features std and udp only.

Splits the datagrams of one listening socket into an association per (local, peer) address pair, each served by its own service as a DemuxedSocket: the datagram counterpart of accepting connections.

Every association is bounded: by DemuxConfig::associations, by its queue, and by its idle timeout, and all end when the demux stops serving. A reply leaves the listening socket for the association’s peer only, from the address the client sent to. A transparently redirected datagram, whose original destination is not the listening address, cannot be answered from there; it is dropped and counted rather than answered from the wrong address, unless the socket selects a reply’s whole source (DatagramCapabilities::send_source_port with send_source_ip), as a transparent proxy flow does, or the demux can bind a socket at that destination (DatagramDemux::with_reply_sockets): then every original destination is an association of its own, answered from that destination. A redirected association carries its original destination as its ConnectorTarget, which one addressed to this listener itself never has (its port and its IP, or for a wildcard listener also loopback or any of the host’s addresses), so a bridge cannot loop it back. Admission and inspection limits belong to the association’s service.

Implementations

impl<S> DatagramDemux<S>

where S: DatagramSocket,

pub fn new(socket: S, config: DemuxConfig) -> DatagramDemux<S>

pub fn with_shared_budget(self, budget: SharedQueueBudget) -> DatagramDemux<S>

Hold what this demux queues within budget too, which other demuxes may share.

pub fn with_reply_sockets<B>(self, bind: B) -> DatagramDemux<S>

where B: Service<SocketAddress, Output = S>, <B as Service<SocketAddress>>::Error: Into<Box<dyn Error + Send + Sync>>,

Answer a redirected datagram the listening socket cannot from a socket that bind binds at its original destination, as a transparent proxy must for a client that accepts replies only from where it sent to.

Associations addressed to one destination share its socket, which closes with the last of them and is read too, since redirection may deliver to it. On Linux, a UdpSocketFactory binds such sockets when its SocketOptions set ip_transparent, ip_transparent_v6 and reuse_address.

pub fn stats(&self) -> DemuxStatsHandle

Read this demux’s counters, also while it serves.

pub async fn serve<Svc>( self, exec: Executor, service: Svc, ) -> Result<(), DatagramError>

where S: Send + 'static, <S as DatagramSocket>::Sender: Clone, Svc: Service<DemuxedSocket<<S as DatagramSocket>::Sender>> + Clone, <Svc as Service<DemuxedSocket<<S as DatagramSocket>::Sender>>>::Error: Into<Box<dyn Error + Send + Sync>>,

Serve every new association with service, spawned on exec, until the listening socket fails or exec’s graceful shutdown begins.

Trait Implementations

impl<S> Debug for DatagramDemux<S>

where S: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S> Drop for DatagramDemux<S>

A demux that stops serving ends its associations too: nothing more arrives for them.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.