Struct IcmpSocket

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

An ICMP socket.

Implementations

impl<'a> IcmpSocket<'a>

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

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

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

where T: Into<IcmpEndpoint>,

Bind the socket to the given endpoint.

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, IpAddress), 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, IpAddress), 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>(&self, f: F) -> Result<R, RecvError>

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

Dequeue a packet received from a remote endpoint and calls the provided function with the slice of the packet and the remote endpoint address and returns Poll::Ready with the function’s returned value.

Note: when the size of the provided buffer is smaller than the size of the payload, the packet is dropped and a RecvError::Truncated error is returned.

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<IpAddress>,

Send a datagram to the specified remote endpoint.

This method will wait until the datagram has been sent.

If the socket’s send buffer is too small to fit buf, this method will return Err(SendError::PacketTooLarge)

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<IpAddress>,

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.

If the socket’s send buffer is too small to fit buf, this method will return Poll::Ready(Err(SendError::PacketTooLarge))

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<IpAddress>, F: FnOnce(&mut [u8]) -> R,

Enqueue a packet to be sent to a given remote address 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.

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

Flush the socket.

This method will wait until the socket is flushed.

pub fn is_open(&self) -> bool

Check whether the socket is open.

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 hop_limit(&self) -> Option<u8>

Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.

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 IcmpSocket<'_>

fn drop(&mut self)

Executes the destructor for this type.