fixup: tests use new connection cookie

da2ce7 · da2ce7 · commit edfd87887ec0 · 2022-10-18T16:30:01.000+02:00
diff --git a/src/tracker/peer.rs b/src/tracker/peer.rs
@@ -130,8 +130,7 @@ mod test {
         };
 
         use crate::peer::TorrentPeer;
-        use crate::protocol::utils::get_connection_id;
-
+        use crate::udp::connection_cookie::{into_connection_id, make_connection_cookie};
         // todo: duplicate functions is PR 82. Remove duplication once both PR are merged.
 
         fn sample_ipv4_remote_addr() -> SocketAddr {
@@ -153,7 +152,7 @@ mod test {
                 let info_hash_aquatic = aquatic_udp_protocol::InfoHash([0u8; 20]);
 
                 let default_request = AnnounceRequest {
-                    connection_id: get_connection_id(&sample_ipv4_remote_addr()),
+                    connection_id: into_connection_id(&make_connection_cookie(&sample_ipv4_remote_addr())),
                     transaction_id: TransactionId(0i32),
                     info_hash: info_hash_aquatic,
                     peer_id: AquaticPeerId(*b"-qB00000000000000000"),
diff --git a/src/udp/connection_cookie.rs b/src/udp/connection_cookie.rs
@@ -1,5 +1,7 @@
 use std::net::SocketAddr;
 
+use aquatic_udp_protocol::ConnectionId;
+
 use crate::protocol::clock::time_extent::{Extent, TimeExtent};
 use crate::udp::ServerError;
 
@@ -9,23 +11,37 @@ pub type SinceUnixEpochTimeExtent = TimeExtent;
 
 pub const COOKIE_LIFETIME: TimeExtent = TimeExtent::from_sec(2, &60);
 
+pub fn from_connection_id(connection_id: &ConnectionId) -> Cookie {
+    connection_id.0.to_le_bytes()
+}
+
+pub fn into_connection_id(connection_cookie: &Cookie) -> ConnectionId {
+    ConnectionId(i64::from_le_bytes(*connection_cookie))
+}
+
 pub fn make_connection_cookie(remote_address: &SocketAddr) -> Cookie {
-    let time_extent = cookie_builder::get_current_time_extent();
+    let time_extent = cookie_builder::get_last_time_extent();
 
-    cookie_builder::build(remote_address, &time_extent)
+    let cookie = cookie_builder::build(remote_address, &time_extent);
+    println!("remote_address: {remote_address:?}, time_extent: {time_extent:?}, cookie: {cookie:?}");
+    cookie
 }
 
 pub fn check_connection_cookie(
     remote_address: &SocketAddr,
     connection_cookie: &Cookie,
 ) -> Result<SinceUnixEpochTimeExtent, ServerError> {
+    let last_time_extent = cookie_builder::get_last_time_extent();
+    let cookie = cookie_builder::build(remote_address, &last_time_extent);
+    println!("remote_address: {remote_address:?}, time_extent: {last_time_extent:?}, cookie: {cookie:?}");
+
     // we loop backwards testing each time_extent until we find one that matches.
     // (or the lifetime of time_extents is exhausted)
-
     for offset in 0..=COOKIE_LIFETIME.amount {
-        let checking_time_extent = cookie_builder::get_current_time_extent().decrease(offset).unwrap();
+        let checking_time_extent = cookie_builder::get_last_time_extent().decrease(offset).unwrap();
 
         let checking_cookie = cookie_builder::build(remote_address, &checking_time_extent);
+        //println!("remote_address: {remote_address:?}, time_extent: {checking_time_extent:?}, cookie: {checking_cookie:?}");
 
         if *connection_cookie == checking_cookie {
             return Ok(checking_time_extent);
@@ -40,11 +56,15 @@ mod cookie_builder {
     use std::net::SocketAddr;
 
     use super::{Cookie, SinceUnixEpochTimeExtent, COOKIE_LIFETIME};
-    use crate::protocol::clock::time_extent::{DefaultTimeExtentMaker, MakeTimeExtent, TimeExtent};
+    use crate::protocol::clock::time_extent::{DefaultTimeExtentMaker, Extent, MakeTimeExtent, TimeExtent};
     use crate::protocol::crypto::keys::seeds::{DefaultSeed, SeedKeeper};
 
-    pub(super) fn get_current_time_extent() -> SinceUnixEpochTimeExtent {
-        DefaultTimeExtentMaker::now(&COOKIE_LIFETIME.increment).unwrap().unwrap()
+    pub(super) fn get_last_time_extent() -> SinceUnixEpochTimeExtent {
+        DefaultTimeExtentMaker::now(&COOKIE_LIFETIME.increment)
+            .unwrap()
+            .unwrap()
+            .increase(COOKIE_LIFETIME.amount)
+            .unwrap()
     }
 
     pub(super) fn build(remote_address: &SocketAddr, time_extent: &TimeExtent) -> Cookie {
@@ -66,7 +86,7 @@ mod cookie_builder {
 mod tests {
     use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 
-    use super::cookie_builder::get_current_time_extent;
+    use super::cookie_builder::get_last_time_extent;
     use crate::protocol::clock::time_extent::Extent;
     use crate::protocol::clock::{StoppedClock, StoppedTime};
     use crate::udp::connection_cookie::{check_connection_cookie, make_connection_cookie, Cookie, COOKIE_LIFETIME};
@@ -82,14 +102,14 @@ mod tests {
     /// this test is strange, the default hasher seems to make different values depending if we are running stable ot nightly
     #[test]
     fn it_should_make_a_connection_cookie() {
-        // remote_address: 127.0.0.1:8080, time_extent: 0,
+        // remote_address: 127.0.0.1:8080, time_extent: 60,
         // seed: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
         const ID_STABLE: Cookie = [223, 239, 248, 49, 67, 103, 97, 83];
-        const ID_NIGHTLY: Cookie = [88, 63, 47, 175, 63, 184, 51, 80];
+        const ID_NIGHTLY: Cookie = [45, 59, 50, 101, 97, 203, 48, 19];
 
         let test_cookie = make_test_cookie(None);
-        //println!("{test_cookie:?}");
+        println!("{test_cookie:?}");
 
         assert!((test_cookie == ID_STABLE || (test_cookie == ID_NIGHTLY)))
     }
@@ -147,9 +167,7 @@ mod tests {
     fn it_cookies_should_be_valid_for_the_last_time_extent() {
         let cookie_now = make_test_cookie(None);
 
-        let last_time_extent = get_current_time_extent().increase(COOKIE_LIFETIME.amount).unwrap();
-
-        StoppedClock::local_set(&last_time_extent.total().unwrap().unwrap());
+        StoppedClock::local_set(&COOKIE_LIFETIME.total().unwrap().unwrap());
 
         check_connection_cookie(&make_test_socket_addr(), &cookie_now).unwrap();
     }
@@ -159,7 +177,7 @@ mod tests {
     fn it_cookies_should_be_not_valid_after_their_last_time_extent() {
         let cookie_now = make_test_cookie(None);
 
-        let last_time_extent = get_current_time_extent().increase(COOKIE_LIFETIME.amount).unwrap();
+        let last_time_extent = get_last_time_extent().increase(COOKIE_LIFETIME.amount).unwrap();
 
         StoppedClock::local_set(&last_time_extent.total_next().unwrap().unwrap());
 
diff --git a/src/udp/handlers.rs b/src/udp/handlers.rs
@@ -2,12 +2,11 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::sync::Arc;
 
 use aquatic_udp_protocol::{
-    AnnounceInterval, AnnounceRequest, AnnounceResponse, ConnectRequest, ConnectResponse, ConnectionId, ErrorResponse,
-    NumberOfDownloads, NumberOfPeers, Port, Request, Response, ResponsePeer, ScrapeRequest, ScrapeResponse,
-    TorrentScrapeStatistics, TransactionId,
+    AnnounceInterval, AnnounceRequest, AnnounceResponse, ConnectRequest, ConnectResponse, ErrorResponse, NumberOfDownloads,
+    NumberOfPeers, Port, Request, Response, ResponsePeer, ScrapeRequest, ScrapeResponse, TorrentScrapeStatistics, TransactionId,
 };
 
-use super::connection_cookie::{check_connection_cookie, make_connection_cookie};
+use super::connection_cookie::{check_connection_cookie, from_connection_id, into_connection_id, make_connection_cookie};
 use crate::peer::TorrentPeer;
 use crate::tracker::statistics::TrackerStatisticsEvent;
 use crate::tracker::torrent::TorrentError;
@@ -71,7 +70,7 @@ pub async fn handle_connect(
     tracker: Arc<TorrentTracker>,
 ) -> Result<Response, ServerError> {
     let connection_cookie = make_connection_cookie(&remote_addr);
-    let connection_id = ConnectionId(i64::from_le_bytes(connection_cookie));
+    let connection_id = into_connection_id(&connection_cookie);
 
     let response = Response::from(ConnectResponse {
         transaction_id: request.transaction_id,
@@ -96,7 +95,7 @@ pub async fn handle_announce(
     announce_request: &AnnounceRequest,
     tracker: Arc<TorrentTracker>,
 ) -> Result<Response, ServerError> {
-    match check_connection_cookie(&remote_addr, &announce_request.connection_id.0.to_be_bytes()) {
+    match check_connection_cookie(&remote_addr, &from_connection_id(&announce_request.connection_id)) {
         Ok(_) => {}
         Err(e) => {
             return Err(e);
@@ -410,9 +409,9 @@ mod tests {
         use aquatic_udp_protocol::{ConnectRequest, ConnectResponse, Response, TransactionId};
 
         use super::{default_tracker_config, sample_ipv4_socket_address, sample_ipv6_remote_addr, TrackerStatsServiceMock};
-        use crate::protocol::utils::get_connection_id;
         use crate::statistics::TrackerStatisticsEvent;
         use crate::tracker::tracker::TorrentTracker;
+        use crate::udp::connection_cookie::{into_connection_id, make_connection_cookie};
         use crate::udp::handle_connect;
         use crate::udp::handlers::tests::{initialized_public_tracker, sample_ipv4_remote_addr};
 
@@ -435,7 +434,7 @@ mod tests {
             assert_eq!(
                 response,
                 Response::Connect(ConnectResponse {
-                    connection_id: get_connection_id(&sample_ipv4_remote_addr()),
+                    connection_id: into_connection_id(&make_connection_cookie(&sample_ipv4_remote_addr())),
                     transaction_id: request.transaction_id
                 })
             );
@@ -454,7 +453,7 @@ mod tests {
             assert_eq!(
                 response,
                 Response::Connect(ConnectResponse {
-                    connection_id: get_connection_id(&sample_ipv4_remote_addr()),
+                    connection_id: into_connection_id(&make_connection_cookie(&sample_ipv4_remote_addr())),
                     transaction_id: request.transaction_id
                 })
             );
@@ -494,7 +493,7 @@ mod tests {
             AnnounceEvent, AnnounceRequest, NumberOfBytes, NumberOfPeers, PeerId as AquaticPeerId, PeerKey, Port, TransactionId,
         };
 
-        use crate::protocol::utils::get_connection_id;
+        use crate::udp::connection_cookie::{into_connection_id, make_connection_cookie};
         use crate::udp::handlers::tests::sample_ipv4_remote_addr;
 
         struct AnnounceRequestBuilder {
@@ -508,7 +507,7 @@ mod tests {
                 let info_hash_aquatic = aquatic_udp_protocol::InfoHash([0u8; 20]);
 
                 let default_request = AnnounceRequest {
-                    connection_id: get_connection_id(&sample_ipv4_remote_addr()),
+                    connection_id: into_connection_id(&make_connection_cookie(&sample_ipv4_remote_addr())),
                     transaction_id: TransactionId(0i32),
                     info_hash: info_hash_aquatic,
                     peer_id: AquaticPeerId([255u8; 20]),
@@ -985,8 +984,8 @@ mod tests {
         };
 
         use super::TorrentPeerBuilder;
-        use crate::protocol::utils::get_connection_id;
         use crate::tracker::tracker::TorrentTracker;
+        use crate::udp::connection_cookie::{into_connection_id, make_connection_cookie};
         use crate::udp::handle_scrape;
         use crate::udp::handlers::tests::{initialized_public_tracker, sample_ipv4_remote_addr};
         use crate::PeerId;
@@ -1007,7 +1006,7 @@ mod tests {
             let info_hashes = vec![info_hash];
 
             let request = ScrapeRequest {
-                connection_id: get_connection_id(&remote_addr),
+                connection_id: into_connection_id(&make_connection_cookie(&remote_addr)),
                 transaction_id: TransactionId(0i32),
                 info_hashes,
             };
@@ -1045,7 +1044,7 @@ mod tests {
             let info_hashes = vec![*info_hash];
 
             ScrapeRequest {
-                connection_id: get_connection_id(remote_addr),
+                connection_id: into_connection_id(&make_connection_cookie(&remote_addr)),
                 transaction_id: TransactionId(0i32),
                 info_hashes,
             }
@@ -1190,7 +1189,7 @@ mod tests {
             let info_hashes = vec![info_hash];
 
             ScrapeRequest {
-                connection_id: get_connection_id(remote_addr),
+                connection_id: into_connection_id(&make_connection_cookie(&remote_addr)),
                 transaction_id: TransactionId(0i32),
                 info_hashes,
             }
