Struct UtpSocket

pub struct UtpSocket {
    pub max_retransmission_retries: u32,
    /* private fields */
}

A structure that represents a uTP (Micro Transport Protocol) connection between a local socket and a remote socket.

The socket will be closed when the value is dropped (either explicitly or when it goes out of scope).

The default maximum retransmission retries is 5, which translates to about 16 seconds. It can be changed by assigning the desired maximum retransmission retries to a socket’s max_retransmission_retries field. Notice that the initial congestion timeout is 500 ms and doubles with each timeout.

Examples

use async_std_utp::UtpSocket;

let mut socket = UtpSocket::bind("127.0.0.1:1234").await.expect("Error binding socket");

let mut buf = vec![0; 1000];
let (amt, _src) = socket.recv_from(&mut buf).await.expect("Error receiving");

let mut buf = &mut buf[..amt];
buf.reverse();
let _ = socket.send_to(buf).await.expect("Error sending");

// Close the socket. You can either call `close` on the socket,
// explicitly drop it or just let it go out of scope.
socket.close().await;
}); }

Fields

max_retransmission_retries: u32

Maximum retransmission retries

Implementations

impl UtpSocket

pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<UtpSocket>

Creates a new UTP socket from the given address.

The address type can be any implementer of the ToSocketAddr trait. See its documentation for concrete examples.

If more than one valid address is specified, only the first will be used.

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the socket address that this socket was created from.

pub fn peer_addr(&self) -> Result<SocketAddr>

Returns the socket address of the remote peer of this UTP connection.

pub async fn connect<A: ToSocketAddrs>(other: A) -> Result<UtpSocket>

Opens a connection to a remote host by hostname or IP address.

The address type can be any implementer of the ToSocketAddr trait. See its documentation for concrete examples.

If more than one valid address is specified, only the first will be used.

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

Gracefully closes connection to peer.

This method allows both peers to receive all packets still in flight.

pub async fn recv_from(&mut self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>

Receives data from socket.

On success, returns the number of bytes read and the sender’s address. Returns 0 bytes read after receiving a FIN packet when the remaining in-flight packets are consumed.

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

Sends data on the socket to the remote peer. On success, returns the number of bytes written.

pub async fn flush(&mut self) -> Result<()>

Consumes acknowledgements for every pending packet.

Trait Implementations

impl Debug for UtpSocket

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

Formats the value using the given formatter.

impl Drop for UtpSocket

fn drop(&mut self)

Executes the destructor for this type.

impl From<UtpSocket> for UtpStream

fn from(socket: UtpSocket) -> Self

Converts to this type from the input type.