Fix potential div by zero

Author: DanglingPointer

mtorrent-cli/tests/test_complete_torrent.rs

@@ -342,7 +342,7 @@ fn get_piece_info(metainfo: &Metainfo) -> data::PieceInfo {
         .or_else(|| metainfo.files().map(|it| it.map(|(len, _path)| len).sum()))
         .unwrap();
 
-    data::PieceInfo::new(metainfo.pieces().unwrap(), metainfo.piece_length().unwrap(), total_length)
+    data::PieceInfo::new(metainfo.pieces(), metainfo.piece_length().unwrap(), total_length).unwrap()
 }
 
 impl Peer for Seeder {

mtorrent-core/src/data/block_accountant.rs

@@ -201,7 +201,7 @@ mod tests {
     use std::iter;
 
     fn piece_info() -> Rc<PieceInfo> {
-        Rc::new(PieceInfo::new(iter::empty(), 3, 256))
+        Rc::new(PieceInfo::new(iter::repeat_n(&[0u8; 20], 86), 3, 256).unwrap())
     }
 
     #[test]

mtorrent-core/src/data/piece_info.rs

@@ -1,4 +1,5 @@
 use crate::data::Error;
+use std::io;
 
 /// Helper for obtaining various information about pieces of a torrent.
 #[derive(Debug)]
@@ -11,21 +12,32 @@ pub struct PieceInfo {
 impl PieceInfo {
     /// Create new [`PieceInfo`] from an iterator over 20-bytes slices representing SHA-1 hashes of
     /// the pieces of a torrent.
-    pub fn new<'a, I: Iterator<Item = &'a [u8]>>(
+    pub fn new<'a, I: Iterator<Item = &'a [u8; 20]>>(
         piece_it: I,
         piece_length: usize,
         total_length: usize,
-    ) -> Self {
-        fn to_20_byte_array(slice: &[u8]) -> [u8; 20] {
-            let mut ret = [0u8; 20];
-            ret.copy_from_slice(slice);
-            ret
+    ) -> Result<Self, Error> {
+        if piece_length == 0 {
+            return Err(
+                io::Error::new(io::ErrorKind::InvalidInput, "piece length cannot be zero").into()
+            );
         }
-        PieceInfo {
-            pieces: piece_it.map(to_20_byte_array).collect(),
+        if total_length == 0 {
+            return Err(
+                io::Error::new(io::ErrorKind::InvalidInput, "total length cannot be zero").into()
+            );
+        }
+        let pieces: Vec<[u8; 20]> = piece_it.cloned().collect();
+        if pieces.len() != total_length.div_ceil(piece_length) {
+            return Err(
+                io::Error::new(io::ErrorKind::InvalidInput, "unexpected number of pieces").into()
+            );
+        }
+        Ok(PieceInfo {
+            pieces,
             piece_length,
             total_length,
-        }
+        })
     }
 
     /// Get global offset relative to the start of the entire torrent (a single entity possibly
@@ -78,7 +90,7 @@ mod tests {
 
     #[test]
     fn last_incomplete_piece_is_handled_correctly() {
-        let p = PieceInfo::new(std::iter::repeat_n([0u8; 20].as_slice(), 3), 5, 12);
+        let p = PieceInfo::new(std::iter::repeat_n(&[0u8; 20], 3), 5, 12).unwrap();
         assert_eq!(3, p.piece_count());
         assert_eq!(5, p.piece_len(0));
         assert_eq!(5, p.piece_len(1));

mtorrent-core/src/input/metainfo.rs

@@ -105,12 +105,11 @@ impl Metainfo {
     }
 
     /// 20-byte SHA-1 hash values, one per piece.
-    pub fn pieces(&self) -> Option<impl Iterator<Item = &[u8]>> {
-        if let Some(benc::Element::ByteString(data)) = self.info.get("pieces") {
-            Some(data.chunks_exact(20))
-        } else {
-            None
-        }
+    pub fn pieces(&self) -> impl Iterator<Item = &[u8; 20]> {
+        self.info.get("pieces").into_iter().flat_map(|e| match e {
+            benc::Element::ByteString(data) => data.as_chunks::<20>().0,
+            _ => &[],
+        })
     }
 
     /// Length of the file in bytes for single file torrents.
@@ -223,7 +222,7 @@ mod tests {
         let piece_length = info.piece_length().unwrap();
         assert_eq!(2_097_152, piece_length, "piece length: {piece_length}");
 
-        let piece_count = info.pieces().unwrap().count();
+        let piece_count = info.pieces().count();
         assert_eq!(/* 13360 / 20 */ 668, piece_count);
 
         let length = info.length();
@@ -411,7 +410,7 @@ mod tests {
             info.name().unwrap()
         );
         assert_eq!(1048576, info.piece_length().unwrap());
-        assert_eq!(28040 / 20, info.pieces().unwrap().count());
+        assert_eq!(28040 / 20, info.pieces().count());
         assert_eq!(data.len(), info.size());
 
         assert!(info.files().is_none());

mtorrent-utils/src/connect_throttle.rs

@@ -43,7 +43,8 @@ pub struct ConnectThrottle {
 impl ConnectThrottle {
     /// Create new throttle that allows up to `max_connections` concurrent permits, and keeps track
     /// of `remembered_peers` last addresses that have been issued a permit (regardless of whether
-    /// the permit is still alive or not).
+    /// the permit is still alive or not). Both `max_connections` and `remembered_peers` must be
+    /// non-zero.
     pub fn new(max_connections: usize, remembered_peers: usize) -> Self {
         Self {
             connected_peers: Rc::new(sealed::Set::with_capacity(max_connections)),

mtorrent-utils/src/net.rs

@@ -165,11 +165,7 @@ pub fn bind_to_interface<'s>(socket: impl Into<SockRef<'s>>, interface: &str) ->
     let interface = std::ffi::CString::new(interface)?;
     let idx = unsafe { libc::if_nametoindex(interface.as_ptr()) };
     let Some(idx) = std::num::NonZeroU32::new(idx) else {
-        // If the index is 0, check errno and return an I/O error.
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidInput,
-            "error converting interface name to index",
-        ));
+        return Err(io::Error::new(io::ErrorKind::NotFound, "interface not found"));
     };
 
     let Ok(local_addr) = socket.local_addr() else {
@@ -295,23 +291,6 @@ mod tests {
         assert_eq!(SocketAddrV6BytesIter(&data).collect::<Vec<_>>(), addrs);
     }
 
-    #[cfg(not(windows))]
-    #[test]
-    fn test_network_interfaces() {
-        for i in 0..10 {
-            let mut name_buf = [0u8; 128];
-            let name = unsafe { libc::if_indextoname(i, name_buf.as_mut_ptr() as *mut i8) };
-            if name.is_null() {
-                continue;
-            }
-            let name = unsafe { std::ffi::CStr::from_ptr(name) }.to_string_lossy();
-            println!("Interface {}: {}", i, name);
-
-            let idx = unsafe { libc::if_nametoindex(name_buf.as_ptr() as *const i8) };
-            assert_eq!(idx, i);
-        }
-    }
-
     #[test]
     fn test_get_bind_addr() {
         let iface = if cfg!(target_os = "windows") {

mtorrent/src/ops/ctx.rs

@@ -150,13 +150,13 @@ impl MainCtx {
             move || io::Error::new(io::ErrorKind::InvalidData, s)
         }
         let pieces = Rc::new(data::PieceInfo::new(
-            metainfo.pieces().ok_or_else(make_error("no pieces in metainfo"))?,
+            metainfo.pieces(),
             metainfo.piece_length().ok_or_else(make_error("no piece length in metainfo"))?,
             metainfo
                 .length()
                 .or_else(|| metainfo.files().map(|it| it.map(|(len, _path)| len).sum()))
                 .ok_or_else(make_error("no total length in metainfo"))?,
-        ));
+        )?);
         let accountant = data::BlockAccountant::new(pieces.clone());
         let piece_tracker = data::PieceTracker::new(pieces.piece_count());
         let ctx = Self {

mtorrent/src/ops/peer/tests.rs

@@ -129,7 +129,7 @@ async fn run_listening_seeder(
         join!(content_storage_server.run(), meta_storage_server.run());
     });
 
-    let piece_count = metainfo.pieces().unwrap().count();
+    let piece_count = metainfo.pieces().count();
     let mut local_id = [0u8; 20];
     local_id[..6].copy_from_slice("seeder".as_bytes());