Struct riot_wrappers::socket_embedded_nal_tcp::ListenStack

pub struct ListenStack<const QUEUELEN: usize> { /* private fields */ }

Available on riot_module_sock_tcp and crate feature with_embedded_nal only.

A view on the RIOT socket stack that is prepared for a single listening socket that can accept QUEUELEN connections simultaneously.

Note that unless CONFIG_GNRC_TCP_RCV_BUFFERS is overridden, QUEUELEN is limited to 1, anything more makes it fail at setup time.

To use it as an implementation of TcpFullStack, it needs to be pinned, eg. by pin_utils::pin_mut!(stack), and later passed as mutable refernce to the pinned item.

Note that while it would be perfectly feasible to count the number of open connection and allow this to be dropped when all connections are closed, this will only be implemented once there is any case that needs it (as most RIOT servers are up indefinitely).

Trait Implementations

impl<const QUEUELEN: usize> Default for ListenStack<QUEUELEN>

fn default() -> Self

Returns the “default value” for a type.

impl<const QUEUELEN: usize> Drop for ListenStack<QUEUELEN>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, const QUEUELEN: usize> TcpClientStack for Pin<&'a mut ListenStack<QUEUELEN>>

type TcpSocket = Socket<'a>

The type returned when we create a new TCP socket

type Error = NumericError

The type returned when we have an error

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

Open a socket for usage as a TCP client.

fn connect( &mut self, _sock: &mut Self::TcpSocket, _addr: SocketAddr ) -> Result<(), Error<Self::Error>>

Connect to the given remote host and port.

fn is_connected(&mut self, sock: &Self::TcpSocket) -> Result<bool, Self::Error>

Check if this socket is connected

fn send( &mut self, sock: &mut Self::TcpSocket, buf: &[u8] ) -> Result<usize, Error<Self::Error>>

Write to the stream.

fn receive( &mut self, sock: &mut Self::TcpSocket, buf: &mut [u8] ) -> Result<usize, Error<Self::Error>>

Receive data from the stream.

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

Close an existing TCP socket.

impl<'a, const QUEUELEN: usize> TcpExactStack for Pin<&'a mut ListenStack<QUEUELEN>>

const RECVBUFLEN: usize = 1_152usize

Capacity of the connection’s TCP buffer.

const SENDBUFLEN: usize = 1_152usize

Capacity of the connection’s TCP send buffer.

fn receive_exact( &mut self, sock: &mut Self::TcpSocket, buf: &mut [u8] ) -> Result<(), Error<Self::Error>>

Receive data from the stream.

fn send_all( &mut self, sock: &mut Self::TcpSocket, buf: &[u8] ) -> Result<(), Error<Self::Error>>

Send all this data to the stream.

impl<'a, const QUEUELEN: usize> TcpFullStack for Pin<&'a mut ListenStack<QUEUELEN>>

fn bind( &mut self, sock: &mut Self::TcpSocket, port: u16 ) -> Result<(), Self::Error>

Create a new TCP socket and bind it to the specified local port.

fn listen(&mut self, _sock: &mut Self::TcpSocket) -> Result<(), Self::Error>

Begin listening for connection requests on a previously-bound socket.

fn accept( &mut self, _sock: &mut Self::TcpSocket ) -> Result<(Self::TcpSocket, SocketAddr), Error<Self::Error>>

Accept an active connection request on a listening socket.