Struct Client 

pub struct Client { /* private fields */ }

Client is a STUN client

Implementations

impl Client

pub fn new(config: ClientConfig) -> Result<Self>

new returns a new Client instance. listeningAddress is the address and port to listen on, default “0.0.0.0:0”

pub fn relay(&mut self, relayed_addr: SocketAddr) -> Result<Relay<'_>>

Borrows the allocation for relayed_addr so data can be sent or permissions created.

Errors

Fails if this client has no allocation for that address — it was never allocated, or has already been closed.

pub fn send_binding_request_to( &mut self, to: SocketAddr, ) -> Result<TransactionId>

send_binding_request_to sends a new STUN request to the given transport address return key to find out corresponding Event either BindingResponse or BindingRequestTimeout

pub fn send_binding_request(&mut self) -> Result<TransactionId>

send_binding_request sends a new STUN request to the STUN server return key to find out corresponding Event either BindingResponse or BindingRequestTimeout

pub fn update_credentials(&mut self, username: String, password: String)

Replaces the long-term credential used to sign subsequent requests, keeping any existing allocation.

A TURN allocation is a property of the 5-tuple, not of the credential that created it: RFC 5766 §6.2 identifies an allocation by 5-tuple, and a server’s Refresh handling looks it up the same way. So when credentials are rotated on the same server there is no need to give up the allocation and re-Allocate — which would in fact be rejected with 437 (Allocation Mismatch), since the server still holds the previous allocation for that 5-tuple. Re-signing the existing allocation is both correct and seamless: permissions and channel bindings survive.

The realm is not re-negotiated. It was learned from the server’s 401 during the first Allocate, and a credential rotation keeps the same server, so it still applies. Follow this with [Relay::refresh] so the server sees the new credential before the allocation would otherwise expire.

pub fn refresh_allocations(&mut self) -> Result<()>

Refreshes every live allocation, re-signing each with the current credential.

Each allocation is refreshed with its own current lifetime, so this extends rather than changes it. Intended to follow update_credentials.

pub fn allocate(&mut self) -> Result<TransactionId>

Allocate sends a TURN allocation request to the given transport address

Trait Implementations

impl Protocol<TransportMessage<BytesMut>, TransportMessage<BytesMut>, ()> for Client

type Rout = ()

Output read message type

type Wout = TransportMessage<BytesMut>

Output write message type

type Eout = Event

Output event type

type Error = Error

Error type for protocol operations

type Time = Instant

Time/Instant type for timeout handling

fn handle_read(&mut self, msg: TaggedBytesMut) -> Result<(), Self::Error>

Handle an incoming read message.

fn poll_read(&mut self) -> Option<Self::Rout>

Poll for a processed read message.

fn handle_write(&mut self, _msg: TaggedBytesMut) -> Result<(), Self::Error>

Handle an outgoing write message.

fn poll_write(&mut self) -> Option<Self::Wout>

Poll for a processed write message.

fn poll_event(&mut self) -> Option<Self::Eout>

Poll for a generated event.

fn handle_timeout(&mut self, now: Instant) -> Result<(), Self::Error>

Handle a timeout event.

fn poll_timeout(&mut self) -> Option<Instant>

Poll for the next timeout deadline.

fn close(&mut self) -> Result<(), Self::Error>

Close the protocol.

fn handle_event(&mut self, _evt: Ein) -> Result<(), Self::Error>

Handle a custom event.