Struct smoltcp::socket::RawSocket

pub struct RawSocket<'a> { /* fields omitted */ }

A raw IP socket.

A raw socket is bound to a specific IP protocol, and owns transmit and receive packet buffers.

Implementations

impl<'a> RawSocket<'a>

pub fn new(
    ip_version: IpVersion,
    ip_protocol: IpProtocol,
    rx_buffer: RawSocketBuffer<'a>,
    tx_buffer: RawSocketBuffer<'a>
) -> RawSocket<'a>

Create a raw IP socket bound to the given IP version and datagram protocol, with the given buffers.

pub fn register_recv_waker(&mut self, waker: &Waker)

Register a waker for receive operations.

The waker is woken on state changes that might affect the return value of recv method calls, such as receiving data, or the socket closing.

Notes:

• Only one waker can be registered at a time. If another waker was previously registered, it is overwritten and will no longer be woken.
• The Waker is woken only once. Once woken, you must register it again to receive more wakes.
• "Spurious wakes" are allowed: a wake doesn't guarantee the result of recv has necessarily changed.

pub fn register_send_waker(&mut self, waker: &Waker)

Register a waker for send operations.

The waker is woken on state changes that might affect the return value of send method calls, such as space becoming available in the transmit buffer, or the socket closing.

Notes:

• Only one waker can be registered at a time. If another waker was previously registered, it is overwritten and will no longer be woken.
• The Waker is woken only once. Once woken, you must register it again to receive more wakes.
• "Spurious wakes" are allowed: a wake doesn't guarantee the result of send has necessarily changed.

pub fn handle(&self) -> SocketHandle

Return the socket handle.

pub fn ip_version(&self) -> IpVersion

Return the IP version the socket is bound to.

pub fn ip_protocol(&self) -> IpProtocol

Return the IP protocol the socket is bound to.

pub fn can_send(&self) -> bool

Check whether the transmit buffer is full.

pub fn can_recv(&self) -> bool

Check whether the receive buffer is not empty.

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 transmit.

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 send(&mut self, size: usize) -> Result<&mut [u8]>

Enqueue a packet to send, and return a pointer to its payload.

This function returns Err(Error::Exhausted) if the transmit buffer is full, and Err(Error::Truncated) if there is not enough transmit buffer capacity to ever send this packet.

If the buffer is filled in a way that does not match the socket's IP version or protocol, the packet will be silently dropped.

Note: The IP header is parsed and reserialized, and may not match the header actually transmitted bit for bit.

pub fn send_slice(&mut self, data: &[u8]) -> Result<()>

Enqueue a packet to send, and fill it from a slice.

See also send.

pub fn recv(&mut self) -> Result<&[u8]>

Dequeue a packet, and return a pointer to the payload.

This function returns Err(Error::Exhausted) if the receive buffer is empty.

Note: The IP header is parsed and reserialized, and may not match the header actually received bit for bit.

pub fn recv_slice(&mut self, data: &mut [u8]) -> Result<usize>

Dequeue a packet, and copy the payload into the given slice.

See also recv.

Trait Implementations

impl<'a> AnySocket<'a> for RawSocket<'a>

pub fn downcast<'c>(
    ref_: SocketRef<'c, Socket<'a>>
) -> Option<SocketRef<'c, Self>>

impl<'a> Debug for RawSocket<'a>

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

Formats the value using the given formatter.

impl<'a> Into<Socket<'a>> for RawSocket<'a>

pub fn into(self) -> Socket<'a>

Performs the conversion.