Struct utp::UtpSocket

pub struct UtpSocket {
    pub max_retransmission_retries: u32,
    // some fields omitted
}

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

Methods

impl UtpSocket

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

Creates a new UTP socket from the given UDP socket.

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.

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

Returns the socket address that this socket was created from.

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

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

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.

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).

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

Gracefully closes connection to peer.

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

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.

fn set_read_timeout(&mut self, user_timeout: Option<u64>)

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

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.

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

Consumes acknowledgements for every pending packet.

fn send_keepalive(&mut self)

Send a keepalive packet on the stream.

Trait Implementations

impl Drop for UtpSocket

fn drop(&mut self)

A method called when the value goes out of scope.

impl Into<UtpStream> for UtpSocket

fn into(self) -> UtpStream

Performs the conversion.