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 utp::UtpSocket;

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

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

let mut buf = &mut buf[..amt];
buf.reverse();
let _ = socket.send_to(buf).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();

Fields

max_retransmission_retries: u32

Maximum retransmission retries

Implementations

impl UtpSocket

pub fn bind_with_udp_socket(socket: UdpSocket) -> Result<UtpSocket>

Creates a new UTP socket from the given UDP socket.

pub 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 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 fn rendezvous_connect<A: ToSocketAddrs>( udp_socket: UdpSocket, other: A, ) -> Result<UtpSocket>

If you have already prepared UDP sockets at each end (e.g. you’re doing hole punching), then the rendezvous connection setup is your choice.

Rendezvous connection will only use the specified socket and addresses, but each end must call rendezvous_connect itself.

This is an unofficial extension to the uTP protocol. Both peers will try to act as initiator and acceptor sockets. Then, the connection id which is numerically lower decides which end will assume which role (initiator or acceptor).

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

Gracefully closes connection to peer.

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

pub 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 fn set_read_timeout(&mut self, user_timeout: Option<u64>)

Changes read operations to block for at most the specified number of milliseconds.

pub 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 fn flush(&mut self) -> Result<()>

Consumes acknowledgements for every pending packet.

pub fn send_keepalive(&mut self)

Send a keepalive packet on the stream.

Trait Implementations

impl Drop for UtpSocket

fn drop(&mut self)

Executes the destructor for this type.

impl Into<UtpStream> for UtpSocket

fn into(self) -> UtpStream

Converts this type into the (usually inferred) input type.