Struct TcpSocketHalf

pub struct TcpSocketHalf { /* private fields */ }

Implementations

impl TcpSocketHalf

pub fn channel( max_buffer_size: usize, addr1: SocketAddr, addr2: SocketAddr, ) -> (TcpSocketHalf, TcpSocketHalf)

pub fn is_active(&self) -> bool

pub fn close(&self) -> Result<()>

impl TcpSocketHalf

pub fn split(self) -> (TcpSocketHalfTx, TcpSocketHalfRx)

pub fn combine(tx: TcpSocketHalfTx, rx: TcpSocketHalfRx) -> Self

Trait Implementations

impl Debug for TcpSocketHalf

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

Formats the value using the given formatter.

impl VirtualConnectedSocket for TcpSocketHalf

fn set_linger(&mut self, _linger: Option<Duration>) -> Result<()>

Determines how long the socket will remain in a TIME_WAIT after it disconnects (only the one that initiates the close will be in a TIME_WAIT state thus the clients should always do this rather than the server)

fn linger(&self) -> Result<Option<Duration>>

Returns how long the socket will remain in a TIME_WAIT after it disconnects

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

Tries to send out a datagram or stream of bytes on this socket

fn try_flush(&mut self) -> Result<()>

fn close(&mut self) -> Result<()>

Closes the socket

fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>

Tries to read a packet from the socket

impl VirtualIoSource for TcpSocketHalf

fn remove_handler(&mut self)

Removes a previously registered waker using a token

fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<usize>>

Polls the source to see if there is data waiting

fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<usize>>

Polls the source to see if data can be sent

impl VirtualSocket for TcpSocketHalf

fn set_ttl(&mut self, ttl: u32) -> Result<()>

Sets how many network hops the packets are permitted for new connections

fn ttl(&self) -> Result<u32>

Returns the maximum number of network hops before packets are dropped

fn addr_local(&self) -> Result<SocketAddr>

Returns the local address for this socket

fn status(&self) -> Result<SocketStatus>

Returns the status/state of the socket

fn set_handler( &mut self, handler: Box<dyn InterestHandler + Send + Sync>, ) -> Result<()>

Registers a waker for when this connection is ready to receive more data. Uses a stack machine which means more than one waker can be registered

impl VirtualTcpSocket for TcpSocketHalf

fn set_recv_buf_size(&mut self, size: usize) -> Result<()>

Sets the receive buffer size which acts as a trottle for how much data is buffered on this side of the pipe

fn recv_buf_size(&self) -> Result<usize>

Size of the receive buffer that holds all data that has not yet been read

fn set_send_buf_size(&mut self, size: usize) -> Result<()>

Sets the size of the send buffer which will hold the bytes of data while they are being sent over to the peer

fn send_buf_size(&self) -> Result<usize>

Size of the send buffer that holds all data that is currently being transmitted.

fn set_nodelay(&mut self, _reuse: bool) -> Result<()>

When NO_DELAY is set the data that needs to be transmitted to the peer is sent immediately rather than waiting for a bigger batch of data, this reduces latency but increases encapsulation overhead.

fn nodelay(&self) -> Result<bool>

Indicates if the NO_DELAY flag is set which means that data is immediately sent to the peer without waiting. This reduces latency but increases encapsulation overhead.

fn set_keepalive(&mut self, _keepalive: bool) -> Result<()>

When KEEP_ALIVE is set the connection will periodically send an empty data packet to the server to make sure the connection stays alive.

fn keepalive(&self) -> Result<bool>

Indicates if the KEEP_ALIVE flag is set which means that the socket will periodically send an empty data packet to keep the connection alive.

fn set_dontroute(&mut self, _keepalive: bool) -> Result<()>

When DONT_ROUTE is set the packet will be sent directly to the interface without passing through the routing logic.

fn dontroute(&self) -> Result<bool>

Indicates if the packet will pass straight through to the interface bypassing the routing logic.

fn addr_peer(&self) -> Result<SocketAddr>

Returns the address (IP and Port) of the peer socket that this is conencted to

fn shutdown(&mut self, how: Shutdown) -> Result<()>

Shuts down either the READER or WRITER sides of the socket connection.

fn is_closed(&self) -> bool

Return true if the socket is closed