utp 0.2.0

A µTP (Micro/uTorrent Transport Library) library implemented in Rust

docs.rs failed to build utp-0.2.0
Please check the build logs for more information.
See Builds for ideas on how to fix a failed build, or Metadata for how to configure docs.rs builds.
If you believe this is docs.rs' fault, open an issue.

Visit the last successful build: utp-0.7.0

rust-utp

A Micro Transport Protocol library implemented in Rust.

The Micro Transport Protocol is a reliable protocol with ordered delivery built over UDP. Its congestion control algorithm is LEDBAT, which tries to use as much unused bandwidth as it can but readily yields to competing flows, making it useful for bulk transfers without introducing congestion in the network.

The current implementation is somewhat incomplete, lacking a complete implementation of congestion control. However, it does support packet loss detection (except by timeout) the Selective Acknowledgment extension, handles unordered and duplicate packets and presents a stream interface (UtpStream).

Building

git clone https://github.com/meqif/rust-utp.git
cd rust-utp
cargo test
cargo build --release

Note that non-release builds are much slower.

Usage

Check the examples directory. The simplest example would be:

extern crate utp;

use utp::UtpStream;
use std::io::{Read, Write};

fn main() {
    // Connect to an hypothetical local server running on port 8080
    let addr = "127.0.0.1:8080";
    let mut stream = match UtpStream::connect(addr) {
        Ok(stream) => stream,
        Err(e) => panic!("{}", e),
    };

    // Send a string
    match stream.write("Hi there!".as_bytes()) {
        Ok(_) => (),
        Err(e) => println!("Write failed with {}", e)
    }

    // Close the stream
    match stream.close() {
        Ok(()) => println!("Connection closed"),
        Err(e) => println!("{}", e)
    }
}

To implement

congestion control
proper connection closing
- handle both RST and FIN
- send FIN on close
- automatically send FIN (or should it be RST?) on drop if not already closed
sending RST on mismatch
setters and getters that hide header field endianness conversion
SACK extension
handle packet loss
- send triple-ACK to re-request lost packet (fast resend request)
- rewind send window and resend in reply to triple-ACK (fast resend)
- resend packet on ACK timeout
stream interface
handle unordered packets
path MTU discovery
duplicate packet handling

License

This library is distributed under similar terms to Rust: dual licensed under the MIT license and the Apache license (version 2.0).