Struct ublox_cellular::sockets::TcpSocket

pub struct TcpSocket<CLK: Clock, const L: usize> { /* fields omitted */ }

A Transmission Control Protocol socket.

A TCP socket may passively listen for connections or actively connect to another endpoint. Note that, for listening sockets, there is no “backlog”; to be able to simultaneously accept several connections, as many sockets must be allocated, or any new connection attempts will be reset.

Implementations

impl<CLK: Clock, const L: usize> TcpSocket<CLK, L>

pub fn new(socket_id: u8) -> TcpSocket<CLK, L>

Create a socket using the given buffers.

pub fn handle(&self) -> SocketHandle

Return the socket handle.

pub fn state(&self) -> &State<CLK>

Return the connection state, in terms of the TCP state machine.

pub fn should_update_available_data(&mut self, ts: Instant<CLK>) -> bool where
    Generic<CLK::T>: TryInto<Milliseconds>, 

pub fn recycle(&self, ts: &Instant<CLK>) -> bool where
    Generic<CLK::T>: TryInto<Milliseconds>, 

pub fn closed_by_remote(&mut self, ts: Instant<CLK>) where
    Generic<CLK::T>: TryInto<Milliseconds>, 

pub fn set_available_data(&mut self, available_data: usize)

Set available data.

pub fn get_available_data(&self) -> usize

Get the number of bytes available to ingress.

pub fn is_connected(&self) -> bool

Return whether a connection is active.

This function returns true if the socket is actively exchanging packets with a remote endpoint. Note that this does not mean that it is possible to send or receive data through the socket; for that, use can_recv.

pub fn may_recv(&self) -> bool

Return whether the receive half of the full-duplex connection is open.

This function returns true if it’s possible to receive data from the remote endpoint. It will return true while there is data in the receive buffer, and if there isn’t, as long as the remote endpoint has not closed the connection.

In terms of the TCP state machine, the socket must be in the Connected, FIN-WAIT-1, or FIN-WAIT-2 state, or have data in the receive buffer instead.

pub fn can_recv(&self) -> bool

Check whether the receive half of the full-duplex connection buffer is open (see may_recv, and the receive buffer is not full.

pub fn recv<'b, F, R>(&'b mut self, f: F) -> Result<R, Error> where
    F: FnOnce(&'b mut [u8]) -> (usize, R), 

Call f with the largest contiguous slice of octets in the receive buffer, and dequeue the amount of elements returned by f.

This function returns `Err(Error::Illegal) if the receive half of the connection is not open; see may_recv.

pub fn recv_wrapping<'b, F>(&'b mut self, f: F) -> Result<usize, Error> where
    F: FnOnce(&'b [u8], Option<&'b [u8]>) -> usize, 

Call f with a slice of octets in the receive buffer, and dequeue the amount of elements returned by f.

If the buffer read wraps around, the second argument of f will be Some() with the remainder of the buffer, such that the combined slice of the two arguments, makes up the full buffer.

This function returns `Err(Error::Illegal) if the receive half of the connection is not open; see may_recv.

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

Dequeue a sequence of received octets, and fill a slice from it.

This function returns the amount of bytes actually dequeued, which is limited by the amount of free space in the transmit buffer; down to zero.

See also recv.

pub fn peek(&mut self, size: usize) -> Result<&[u8], Error>

Peek at a sequence of received octets without removing them from the receive buffer, and return a pointer to it.

This function otherwise behaves identically to recv.

pub fn rx_window(&self) -> usize

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

Peek at a sequence of received octets without removing them from the receive buffer, and fill a slice from it.

This function otherwise behaves identically to recv_slice.

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

pub fn recv_queue(&self) -> usize

Return the amount of octets queued in the receive buffer.

Note that the Berkeley sockets interface does not have an equivalent of this API.

pub fn set_state(&mut self, state: State<CLK>)

Trait Implementations

impl<CLK: Clock, const L: usize> AnySocket<CLK, L> for TcpSocket<CLK, L>

fn downcast(
    ref_: SocketRef<'_, Socket<CLK, L>>
) -> Result<SocketRef<'_, Self>, Error>

impl<CLK: Clock, const L: usize> Into<Socket<CLK, L>> for TcpSocket<CLK, L>

fn into(self) -> Socket<CLK, L>

Performs the conversion.