rename crate "bittorrent_udp" to "aquatic_udp_protocol"

aquatic_udp_protocol/src/converters/common.rs

@@ -0,0 +1,23 @@
+use crate::types::AnnounceEvent;
+
+
+#[inline]
+pub fn event_from_i32(i: i32) -> AnnounceEvent {
+    match i {
+        1 => AnnounceEvent::Completed,
+        2 => AnnounceEvent::Started,
+        3 => AnnounceEvent::Stopped,
+        _ => AnnounceEvent::None
+    }
+}
+
+
+#[inline]
+pub fn event_to_i32(event: AnnounceEvent) -> i32 {
+    match event {
+        AnnounceEvent::None => 0,
+        AnnounceEvent::Completed => 1,
+        AnnounceEvent::Started => 2,
+        AnnounceEvent::Stopped => 3
+    }
+}

aquatic_udp_protocol/src/converters/mod.rs

@@ -0,0 +1,6 @@
+pub mod common;
+pub mod requests;
+pub mod responses;
+
+pub use self::requests::*;
+pub use self::responses::*;

aquatic_udp_protocol/src/converters/requests.rs

@@ -0,0 +1,241 @@
+use byteorder::{ReadBytesExt, WriteBytesExt, NetworkEndian};
+
+use std::convert::TryInto;
+use std::io::{self, Cursor, Read, Write};
+use std::net::Ipv4Addr;
+
+use crate::types::*;
+
+use super::common::*;
+
+
+const PROTOCOL_IDENTIFIER: i64 = 4_497_486_125_440;
+
+
+#[derive(Debug)]
+pub struct RequestParseError {
+    pub transaction_id: Option<TransactionId>,
+    pub message: Option<String>,
+    pub error: Option<io::Error>,
+}
+
+
+impl RequestParseError {
+    pub fn new(err: io::Error, transaction_id: i32) -> Self {
+        Self {
+            transaction_id: Some(TransactionId(transaction_id)),
+            message: None,
+            error: Some(err)
+        }
+    }
+    pub fn io(err: io::Error) -> Self {
+        Self {
+            transaction_id: None,
+            message: None,
+            error: Some(err)
+        }
+    }
+    pub fn text(transaction_id: i32, message: &str) -> Self {
+        Self {
+            transaction_id: Some(TransactionId(transaction_id)),
+            message: Some(message.to_string()),
+            error: None,
+        }
+    }
+}
+
+
+#[inline]
+pub fn request_to_bytes(
+    bytes: &mut impl Write,
+    request: Request
+) -> Result<(), io::Error> {
+    match request {
+        Request::Connect(r) => {
+            bytes.write_i64::<NetworkEndian>(PROTOCOL_IDENTIFIER)?;
+            bytes.write_i32::<NetworkEndian>(0)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+        },
+
+        Request::Announce(r) => {
+            bytes.write_i64::<NetworkEndian>(r.connection_id.0)?;
+            bytes.write_i32::<NetworkEndian>(1)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+
+            bytes.write_all(&r.info_hash.0)?;
+            bytes.write_all(&r.peer_id.0)?;
+
+            bytes.write_i64::<NetworkEndian>(r.bytes_downloaded.0)?;
+            bytes.write_i64::<NetworkEndian>(r.bytes_left.0)?;
+            bytes.write_i64::<NetworkEndian>(r.bytes_uploaded.0)?;
+
+            bytes.write_i32::<NetworkEndian>(event_to_i32(r.event))?;
+
+            bytes.write_all(&r.ip_address.map_or(
+                [0; 4],
+                |ip| ip.octets()
+            ))?;
+
+            bytes.write_u32::<NetworkEndian>(r.key.0)?;
+            bytes.write_i32::<NetworkEndian>(r.peers_wanted.0)?;
+            bytes.write_u16::<NetworkEndian>(r.port.0)?;
+        },
+
+        Request::Scrape(r) => {
+            bytes.write_i64::<NetworkEndian>(r.connection_id.0)?;
+            bytes.write_i32::<NetworkEndian>(2)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+
+            for info_hash in r.info_hashes {
+                bytes.write_all(&info_hash.0)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+
+#[inline]
+pub fn request_from_bytes(
+    bytes: &[u8],
+    max_scrape_torrents: u8,
+) -> Result<Request, RequestParseError> {
+    let mut cursor = Cursor::new(bytes);
+
+    let connection_id = cursor.read_i64::<NetworkEndian>()
+        .map_err(RequestParseError::io)?;
+    let action = cursor.read_i32::<NetworkEndian>()
+        .map_err(RequestParseError::io)?;
+    let transaction_id = cursor.read_i32::<NetworkEndian>()
+        .map_err(RequestParseError::io)?;
+
+    match action {
+        // Connect
+        0 => {
+            if connection_id == PROTOCOL_IDENTIFIER {
+                Ok((ConnectRequest {
+                    transaction_id: TransactionId(transaction_id)
+                }).into())
+            } else {
+                Err(RequestParseError::text(
+                    transaction_id,
+                    "Protocol identifier missing"
+                ))
+            }
+        },
+
+        // Announce
+        1 => {
+            let mut info_hash = [0; 20];
+            let mut peer_id = [0; 20];
+            let mut ip = [0; 4];
+
+            cursor.read_exact(&mut info_hash)
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+            cursor.read_exact(&mut peer_id)
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+
+            let bytes_downloaded = cursor.read_i64::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+            let bytes_left = cursor.read_i64::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+            let bytes_uploaded = cursor.read_i64::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+            let event = cursor.read_i32::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+
+            cursor.read_exact(&mut ip)
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+
+            let key = cursor.read_u32::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+            let peers_wanted = cursor.read_i32::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+            let port = cursor.read_u16::<NetworkEndian>()
+                .map_err(|err| RequestParseError::new(err, transaction_id))?;
+
+            let opt_ip = if ip == [0; 4] {
+                None
+            } else {
+                Some(Ipv4Addr::from(ip))
+            };
+
+            Ok((AnnounceRequest {
+                connection_id: ConnectionId(connection_id),
+                transaction_id: TransactionId(transaction_id),
+                info_hash: InfoHash(info_hash),
+                peer_id: PeerId(peer_id),
+                bytes_downloaded: NumberOfBytes(bytes_downloaded),
+                bytes_uploaded: NumberOfBytes(bytes_uploaded),
+                bytes_left: NumberOfBytes(bytes_left),
+                event: event_from_i32(event),
+                ip_address: opt_ip,
+                key: PeerKey(key),
+                peers_wanted: NumberOfPeers(peers_wanted),
+                port: Port(port)
+            }).into())
+        },
+
+        // Scrape
+        2 => {
+            let position = cursor.position() as usize;
+            let inner = cursor.into_inner();
+
+            let info_hashes = (&inner[position..]).chunks_exact(20)
+                .take(max_scrape_torrents as usize)
+                .map(|chunk| InfoHash(chunk.try_into().unwrap()))
+                .collect();
+
+            Ok((ScrapeRequest {
+                connection_id: ConnectionId(connection_id),
+                transaction_id: TransactionId(transaction_id),
+                info_hashes
+            }).into())
+        }
+
+        _ => Err(RequestParseError::text(transaction_id, "Invalid action"))
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn same_after_conversion(request: Request) -> bool {
+        let mut buf = Vec::new();
+
+        request_to_bytes(&mut buf, request.clone()).unwrap();
+        let r2 = request_from_bytes(&buf[..], ::std::u8::MAX).unwrap();
+
+        let success = request == r2;
+
+        if !success {
+            println!("before: {:#?}\nafter: {:#?}", request, r2);
+        }
+
+        success
+    }
+
+    #[quickcheck]
+    fn test_connect_request_convert_identity(
+        request: ConnectRequest
+    ) -> bool {
+        same_after_conversion(request.into())
+    }   
+
+    #[quickcheck]
+    fn test_announce_request_convert_identity(
+        request: AnnounceRequest
+    ) -> bool {
+        same_after_conversion(request.into())
+    }   
+
+    #[quickcheck]
+    fn test_scrape_request_convert_identity(
+        request: ScrapeRequest
+    ) -> bool {
+        same_after_conversion(request.into())
+    }   
+}

aquatic_udp_protocol/src/converters/responses.rs

@@ -0,0 +1,225 @@
+use std::convert::TryInto;
+use std::io::{self, Cursor, Write};
+use std::net::{IpAddr, Ipv6Addr, Ipv4Addr};
+
+use byteorder::{ReadBytesExt, WriteBytesExt, NetworkEndian};
+
+use crate::types::*;
+
+
+#[inline]
+pub fn response_to_bytes(
+    bytes: &mut impl Write,
+    response: Response,
+    ip_version: IpVersion
+) -> Result<(), io::Error> {
+    match response {
+        Response::Connect(r) => {
+            bytes.write_i32::<NetworkEndian>(0)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+            bytes.write_i64::<NetworkEndian>(r.connection_id.0)?;
+        },
+        Response::Announce(r) => {
+            bytes.write_i32::<NetworkEndian>(1)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+            bytes.write_i32::<NetworkEndian>(r.announce_interval.0)?;
+            bytes.write_i32::<NetworkEndian>(r.leechers.0)?;
+            bytes.write_i32::<NetworkEndian>(r.seeders.0)?;
+
+            // Write peer IPs and ports. Silently ignore peers with wrong
+            // IP version
+            if ip_version == IpVersion::IPv4 {
+                for peer in r.peers {
+                    if let IpAddr::V4(ip) = peer.ip_address {
+                        bytes.write_all(&ip.octets())?;
+                        bytes.write_u16::<NetworkEndian>(peer.port.0)?;
+                    }
+                }
+            } else {
+                for peer in r.peers {
+                    if let IpAddr::V6(ip) = peer.ip_address {
+                        bytes.write_all(&ip.octets())?;
+                        bytes.write_u16::<NetworkEndian>(peer.port.0)?;
+                    }
+                }
+            }
+        },
+        Response::Scrape(r) => {
+            bytes.write_i32::<NetworkEndian>(2)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+
+            for torrent_stat in r.torrent_stats {
+                bytes.write_i32::<NetworkEndian>(torrent_stat.seeders.0)?;
+                bytes.write_i32::<NetworkEndian>(torrent_stat.completed.0)?;
+                bytes.write_i32::<NetworkEndian>(torrent_stat.leechers.0)?;
+            }
+        },
+        Response::Error(r) => {
+            bytes.write_i32::<NetworkEndian>(3)?;
+            bytes.write_i32::<NetworkEndian>(r.transaction_id.0)?;
+
+            bytes.write_all(r.message.as_bytes())?;
+        },
+    }
+
+    Ok(())
+}
+
+
+#[inline]
+pub fn response_from_bytes(
+    bytes: &[u8],
+    ip_version: IpVersion,
+) -> Result<Response, io::Error> {
+    let mut cursor = Cursor::new(bytes);
+
+    let action = cursor.read_i32::<NetworkEndian>()?;
+    let transaction_id = cursor.read_i32::<NetworkEndian>()?;
+
+    match action {
+        // Connect
+        0 => {
+            let connection_id = cursor.read_i64::<NetworkEndian>()?;
+
+            Ok((ConnectResponse {
+                connection_id: ConnectionId(connection_id),
+                transaction_id: TransactionId(transaction_id)
+            }).into())
+        },
+        // Announce
+        1 => {
+            let announce_interval = cursor.read_i32::<NetworkEndian>()?;
+            let leechers = cursor.read_i32::<NetworkEndian>()?;
+            let seeders = cursor.read_i32::<NetworkEndian>()?;
+
+            let position = cursor.position() as usize;
+            let inner = cursor.into_inner();
+
+            let peers = if ip_version == IpVersion::IPv4 {
+                inner[position..].chunks_exact(6).map(|chunk| {
+                    let ip_bytes: [u8; 4] = (&chunk[..4]).try_into().unwrap();
+                    let ip_address = IpAddr::V4(Ipv4Addr::from(ip_bytes));
+                    let port = (&chunk[4..]).read_u16::<NetworkEndian>().unwrap();
+
+                    ResponsePeer {
+                        ip_address,
+                        port: Port(port),
+                    }
+                }).collect()
+            } else {
+                inner[position..].chunks_exact(18).map(|chunk| {
+                    let ip_bytes: [u8; 16] = (&chunk[..16]).try_into().unwrap();
+                    let ip_address = IpAddr::V6(Ipv6Addr::from(ip_bytes));
+                    let port = (&chunk[16..]).read_u16::<NetworkEndian>().unwrap();
+
+                    ResponsePeer {
+                        ip_address,
+                        port: Port(port),
+                    }
+                }).collect()
+            };
+
+            Ok((AnnounceResponse {
+                transaction_id: TransactionId(transaction_id),
+                announce_interval: AnnounceInterval(announce_interval),
+                leechers: NumberOfPeers(leechers),
+                seeders: NumberOfPeers(seeders),
+                peers
+            }).into())
+
+        },
+        // Scrape
+        2 => {
+            let position = cursor.position() as usize;
+            let inner = cursor.into_inner();
+
+            let stats = inner[position..].chunks_exact(12).map(|chunk| {
+                let mut cursor: Cursor<&[u8]> = Cursor::new(&chunk[..]);
+
+                let seeders = cursor.read_i32::<NetworkEndian>().unwrap();
+                let downloads = cursor.read_i32::<NetworkEndian>().unwrap();
+                let leechers = cursor.read_i32::<NetworkEndian>().unwrap();
+
+                TorrentScrapeStatistics {
+                    seeders: NumberOfPeers(seeders),
+                    completed: NumberOfDownloads(downloads),
+                    leechers:NumberOfPeers(leechers)
+                }
+            }).collect();
+
+            Ok((ScrapeResponse {
+                transaction_id: TransactionId(transaction_id),
+                torrent_stats: stats
+            }).into())
+        },
+        // Error
+        3 => {
+            let position = cursor.position() as usize;
+            let inner = cursor.into_inner();
+
+            Ok((ErrorResponse {
+                transaction_id: TransactionId(transaction_id),
+                message: String::from_utf8_lossy(&inner[position..]).into()
+            }).into())
+        },
+        _ => {
+            Ok((ErrorResponse {
+                transaction_id: TransactionId(transaction_id),
+                message: "Invalid action".to_string()
+            }).into())
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn same_after_conversion(
+        response: Response,
+        ip_version: IpVersion
+    ) -> bool {
+        let mut buf = Vec::new();
+
+        response_to_bytes(&mut buf, response.clone(), ip_version).unwrap();
+        let r2 = response_from_bytes(&buf[..], ip_version).unwrap();
+
+        let success = response == r2;
+
+        if !success {
+            println!("before: {:#?}\nafter: {:#?}", response, r2);
+        }
+
+        success
+    }
+
+    #[quickcheck]
+    fn test_connect_response_convert_identity(
+        response: ConnectResponse
+    ) -> bool {
+        same_after_conversion(response.into(), IpVersion::IPv4)
+    }   
+
+    #[quickcheck]
+    fn test_announce_response_convert_identity(
+        data: (AnnounceResponse, IpVersion)
+    ) -> bool {
+        let mut r = data.0;
+
+        if data.1 == IpVersion::IPv4 {
+            r.peers.retain(|peer| peer.ip_address.is_ipv4());
+        } else {
+            r.peers.retain(|peer| peer.ip_address.is_ipv6());
+        }
+
+        same_after_conversion(r.into(), data.1)
+    }   
+
+    #[quickcheck]
+    fn test_scrape_response_convert_identity(
+        response: ScrapeResponse
+    ) -> bool {
+        same_after_conversion(response.into(), IpVersion::IPv4)
+    }   
+}