Struct TcpSocket

#[repr(C)]
pub struct TcpSocket<S: SocketState = Unbound, B: SocketBuffer = Vec<u8>> { /* private fields */ }

A TCP socket

Safety

This is a wrapper around a raw socket file descriptor.

The socket is closed when the struct is dropped. Closing via drop is best-effort.

Notes

The structure implements EasySocket. This allows you to interact with the socket using a simplified API. However, you are still free to use it like a normal Linux socket like you would do in C.

Using it as an easy socket allows you to use it in the following way:

use psp::net::TcpSocket;

let socket = TcpSocket::new().unwrap();
let socket_options = SocketOptions{ remote: addr };
let socket = socket.open(socket_options).unwrap();
socket.write(b"hello world").unwrap();
socket.flush().unwrap();
// no need to call close, as drop will do it

Implementations

impl TcpSocket

pub fn new() -> Result<TcpSocket<Unbound>, SocketError>

Create a TCP socket

Returns

A new TCP socket

Errors

• SocketError::ErrnoWithDescription if the socket could not be created

impl<S: SocketState> TcpSocket<S>

pub fn fd(&self) -> i32

Return the underlying socket’s file descriptor

pub fn send_flags(&self) -> SocketSendFlags

Flags used when sending data

pub fn set_send_flags(&mut self, send_flags: SocketSendFlags)

Set the flags used when sending data

pub fn recv_flags(&self) -> SocketRecvFlags

Flags used when receiving data

pub fn set_recv_flags(&mut self, recv_flags: SocketRecvFlags)

Set the flags used when receiving data

impl TcpSocket<Unbound>

pub fn connect( self, remote: SocketAddr, ) -> Result<TcpSocket<Connected>, SocketError>

Connect to a remote host

Parameters

• remote: The remote host to connect to

Returns

• Ok(()) if the connection was successful
• Err(String) if the connection was unsuccessful.

Errors

• SocketError::UnsupportedAddressFamily if the address family is not supported (only IPv4 is supported)
• Any other SocketError if the connection was unsuccessful

impl TcpSocket<Connected>

pub fn internal_read(&self, buf: &mut [u8]) -> Result<usize, SocketError>

Read from the socket

# Returns

• Ok(usize) if the read was successful. The number of bytes read
• Err(SocketError) if the read was unsuccessful.

Errors

• A SocketError if the read was unsuccessful

Notes

“Low level” read function. Read data from the socket and store it in the buffer. This should not be used if you want to use this socket EasySocket style.

pub fn internal_write(&mut self, buf: &[u8]) -> Result<usize, SocketError>

Write to the socket

Errors

• A SocketError if the write was unsuccessful

Trait Implementations

impl<S: Clone + SocketState, B: Clone + SocketBuffer> Clone for TcpSocket<S, B>

fn clone(&self) -> TcpSocket<S, B>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + SocketState, B: Debug + SocketBuffer> Debug for TcpSocket<S, B>

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

Formats the value using the given formatter.

impl<S: SocketState> ErrorType for TcpSocket<S>

type Error = SocketError

Error type of all the IO operations on this type.

impl<S: Hash + SocketState, B: Hash + SocketBuffer> Hash for TcpSocket<S, B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Open<'_, '_> for TcpSocket<Unbound>

fn open(self, options: &Self::Options<'_>) -> Result<Self::Return, Self::Error>

where Self: Sized,

Return a TCP socket connected to the remote specified in options

type Return = TcpSocket<Connected>

impl<S: SocketState> OptionType for TcpSocket<S>

type Options<'a> = SocketOptions

impl<S: PartialEq + SocketState, B: PartialEq + SocketBuffer> PartialEq for TcpSocket<S, B>

fn eq(&self, other: &TcpSocket<S, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Read for TcpSocket<Connected>

fn read<'m>(&'m mut self, buf: &'m mut [u8]) -> Result<usize, Self::Error>

Read from the socket

Parameters

• buf: The buffer where the read data will be stored

# Returns

• Ok(usize) if the read was successful. The number of bytes read
• Err(SocketError) if the read was unsuccessful.

Errors

• [SocketError::NotConnected] if the socket is not connected
• A SocketError if the read was unsuccessful

fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl Write for TcpSocket<Connected>

fn write<'m>(&'m mut self, buf: &'m [u8]) -> Result<usize, Self::Error>

Write to the socket

Errors

• [SocketError::NotConnected] if the socket is not connected
• A SocketError if the write was unsuccessful

fn flush(&mut self) -> Result<(), SocketError>

Flush the socket

Errors

• A SocketError if the flush was unsuccessful

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

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.

impl EasySocket for TcpSocket<Connected>

impl<S: Eq + SocketState, B: Eq + SocketBuffer> Eq for TcpSocket<S, B>

impl<S: SocketState, B: SocketBuffer> StructuralPartialEq for TcpSocket<S, B>