Struct UdpSocket

pub struct UdpSocket<'a> { /* private fields */ }

Available on crate feature udp only.

An UDP socket.

Implementations

impl<'a> UdpSocket<'a>

pub fn new( stack: Stack<'a>, rx_meta: &'a mut [PacketMetadata<UdpMetadata>], rx_buffer: &'a mut [u8], tx_meta: &'a mut [PacketMetadata<UdpMetadata>], tx_buffer: &'a mut [u8], ) -> UdpSocket<'a>

Create a new UDP socket using the provided stack and buffers.

pub fn bind<T>(&mut self, endpoint: T) -> Result<(), BindError>

where T: Into<ListenEndpoint>,

Bind the socket to a local endpoint.

pub fn with<R>(&self, f: impl FnOnce(&Socket<'_>, &Interface) -> R) -> R

Lock the stack, provide access to the underlying smoltcp UDP socket and interface

pub fn wait_recv_ready(&self) -> impl Future<Output = ()>

Wait until the socket becomes readable.

A socket is readable when a packet has been received, or when there are queued packets in the buffer.

pub fn poll_recv_ready(&self, cx: &mut Context<'_>) -> Poll<()>

Wait until a datagram can be read.

When no datagram is readable, this method will return Poll::Pending and register the current task to be notified when a datagram is received.

When a datagram is received, this method will return Poll::Ready.

pub fn recv_from<'s>( &'s self, buf: &'s mut [u8], ) -> impl Future<Output = Result<(usize, UdpMetadata), RecvError>> + 's

Receive a datagram.

This method will wait until a datagram is received.

Returns the number of bytes received and the remote endpoint.

pub fn poll_recv_from( &self, buf: &mut [u8], cx: &mut Context<'_>, ) -> Poll<Result<(usize, UdpMetadata), RecvError>>

Receive a datagram.

When no datagram is available, this method will return Poll::Pending and register the current task to be notified when a datagram is received.

When a datagram is received, this method will return Poll::Ready with the number of bytes received and the remote endpoint.

pub async fn recv_from_with<F, R>(&mut self, f: F) -> R

where F: FnOnce(&[u8], UdpMetadata) -> R,

Receive a datagram with a zero-copy function.

When no datagram is available, this method will return Poll::Pending and register the current task to be notified when a datagram is received.

When a datagram is received, this method will call the provided function with the number of bytes received and the remote endpoint and return Poll::Ready with the function’s returned value.

pub fn wait_send_ready(&self) -> impl Future<Output = ()>

Wait until the socket becomes writable.

A socket becomes writable when there is space in the buffer, from initial memory or after dispatching datagrams on a full buffer.

pub fn poll_send_ready(&self, cx: &mut Context<'_>) -> Poll<()>

Wait until a datagram can be sent.

When no datagram can be sent (i.e. the buffer is full), this method will return Poll::Pending and register the current task to be notified when space is freed in the buffer after a datagram has been dispatched.

When a datagram can be sent, this method will return Poll::Ready.

pub async fn send_to<T>( &self, buf: &[u8], remote_endpoint: T, ) -> Result<(), SendError>

where T: Into<UdpMetadata>,

Send a datagram to the specified remote endpoint.

This method will wait until the datagram has been sent.

When the remote endpoint is not reachable, this method will return Err(SendError::NoRoute)

pub fn poll_send_to<T>( &self, buf: &[u8], remote_endpoint: T, cx: &mut Context<'_>, ) -> Poll<Result<(), SendError>>

where T: Into<UdpMetadata>,

Send a datagram to the specified remote endpoint.

When the datagram has been sent, this method will return Poll::Ready(Ok()).

When the socket’s send buffer is full, this method will return Poll::Pending and register the current task to be notified when the buffer has space available.

When the remote endpoint is not reachable, this method will return Poll::Ready(Err(Error::NoRoute)).

pub async fn send_to_with<T, F, R>( &mut self, size: usize, remote_endpoint: T, f: F, ) -> Result<R, SendError>

where T: Into<UdpMetadata> + Copy, F: FnOnce(&mut [u8]) -> R,

Send a datagram to the specified remote endpoint with a zero-copy function.

This method will wait until the buffer can fit the requested size before calling the function to fill its contents.

When the remote endpoint is not reachable, this method will return Err(SendError::NoRoute)

pub fn flush(&mut self) -> impl Future<Output = ()>

Flush the socket.

This method will wait until the socket is flushed.

pub fn endpoint(&self) -> ListenEndpoint

Returns the local endpoint of the socket.

pub fn is_open(&self) -> bool

Returns whether the socket is open.

pub fn close(&mut self)

Close the socket.

pub fn may_send(&self) -> bool

Returns whether the socket is ready to send data, i.e. it has enough buffer space to hold a packet.

pub fn may_recv(&self) -> bool

Returns whether the socket is ready to receive data, i.e. it has received a packet that’s now in the buffer.

pub fn packet_recv_capacity(&self) -> usize

Return the maximum number packets the socket can receive.

pub fn packet_send_capacity(&self) -> usize

Return the maximum number packets the socket can receive.

pub fn payload_recv_capacity(&self) -> usize

Return the maximum number of bytes inside the recv buffer.

pub fn payload_send_capacity(&self) -> usize

Return the maximum number of bytes inside the transmit buffer.

pub fn set_hop_limit(&mut self, hop_limit: Option<u8>)

Set the hop limit field in the IP header of sent packets.

Trait Implementations

impl Drop for UdpSocket<'_>

fn drop(&mut self)

Executes the destructor for this type.