1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
use std::io::{Read, Write, Result}; use std::net::{ToSocketAddrs, SocketAddr}; use std::ops::Deref; use socket::UtpSocket; /// A structure that represents a uTP (Micro Transport Protocol) stream between a local socket and a /// remote socket. /// /// The connection 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 calling `set_max_retransmission_retries`. Notice that the initial congestion timeout /// is 500 ms and doubles with each timeout. /// /// # Examples /// /// ```no_run /// use utp::UtpStream; /// use std::io::{Read, Write}; /// /// let mut stream = UtpStream::bind("127.0.0.1:1234").unwrap(); /// let _ = stream.write(&[1]); /// let _ = stream.read(&mut [0; 1000]); /// ``` pub struct UtpStream { socket: UtpSocket, } impl UtpStream { /// Creates a uTP stream listening on 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 bind<A: ToSocketAddrs>(addr: A) -> Result<UtpStream> { UtpSocket::bind(addr).map(|s| UtpStream { socket: s }) } /// Opens a uTP 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 connect<A: ToSocketAddrs>(dst: A) -> Result<UtpStream> { // Port 0 means the operating system gets to choose it UtpSocket::connect(dst).map(|s| UtpStream { socket: s }) } /// Gracefully closes connection to peer. /// /// This method allows both peers to receive all packets still in /// flight. pub fn close(&mut self) -> Result<()> { self.socket.close() } /// Returns the socket address of the local half of this uTP connection. pub fn local_addr(&self) -> Result<SocketAddr> { self.socket.local_addr() } /// Changes the maximum number of retransmission retries on the underlying socket. pub fn set_max_retransmission_retries(&mut self, n: u32) { self.socket.max_retransmission_retries = n; } } impl Read for UtpStream { fn read(&mut self, buf: &mut [u8]) -> Result<usize> { self.socket.recv_from(buf).map(|(read, _src)| read) } } impl Write for UtpStream { fn write(&mut self, buf: &[u8]) -> Result<usize> { self.socket.send_to(buf) } fn flush(&mut self) -> Result<()> { self.socket.flush() } } impl Into<UtpStream> for UtpSocket { fn into(self) -> UtpStream { UtpStream { socket: self } } } impl Deref for UtpStream { type Target = UtpSocket; fn deref(&self) -> &UtpSocket { &self.socket } }