Fix issue with reading large files and error being returned if 0 packets were read

Author: dbcfd

src/packet/future.rs

@@ -144,40 +144,46 @@ async fn dispatch(args: DispatchArgs) -> Result<DispatchResult, Error> {
                 error!("Error encountered when calling pcap_dispatch: {}", err);
                 return Err(err);
             }
-            0 if args.live_capture => {
-                trace!("No packets in buffer");
-                if should_return_packets(packets.len()) {
-                    debug!(
-                        "Capture loop returning with {} packets",
-                        args.max_packets_read
-                    );
-                    return Ok(DispatchResult {
-                        args: args,
-                        result: Some(packets.into_inner()),
-                    });
-                } else {
-                    let timeout = if packets.is_empty() {
-                        None
-                    } else {
-                        args.buffer_for
-                            .checked_sub(Instant::now().duration_since(started_at))
-                    };
-                    if let InterfaceReady::No = args.poll(timeout).await? {
+            0 => {
+                if args.live_capture {
+                    trace!("No packets in buffer");
+                    if should_return_packets(packets.len()) {
+                        debug!(
+                            "Capture loop returning with {} packets",
+                            args.max_packets_read
+                        );
                         return Ok(DispatchResult {
                             args: args,
                             result: Some(packets.into_inner()),
                         });
+                    } else {
+                        let timeout = if packets.is_empty() {
+                            None
+                        } else {
+                            args.buffer_for
+                                .checked_sub(Instant::now().duration_since(started_at))
+                        };
+                        if let InterfaceReady::No = args.poll(timeout).await? {
+                            return Ok(DispatchResult {
+                                args: args,
+                                result: Some(packets.into_inner()),
+                            });
+                        }
                     }
+                } else {
+                    debug!("Not live capture and no packets, calling breakloop");
+                    unsafe { pcap_sys::pcap_breakloop(args.pcap_handle.as_mut_ptr()) }
+                    let res = if packets.is_empty() {
+                        None
+                    } else {
+                        Some(packets.into_inner())
+                    };
+                    return Ok(DispatchResult {
+                        args: args,
+                        result: res,
+                    });
                 }
             }
-            0 if !packets.is_empty() => {
-                debug!("Not live capture and no packets, calling breakloop");
-                unsafe { pcap_sys::pcap_breakloop(args.pcap_handle.as_mut_ptr()) }
-                return Ok(DispatchResult {
-                    args: args,
-                    result: Some(packets.into_inner()),
-                });
-            }
             x if x > 0 => {
                 trace!("Capture loop captured {} packets", x);
                 if should_return_packets(packets.len()) {

src/stream.rs

@@ -155,6 +155,39 @@ mod tests {
         assert_eq!(actual_length, 54);
     }
 
+    #[test]
+    fn packets_from_large_file() {
+        let _ = env_logger::try_init();
+
+        let pcap_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("resources")
+            .join("4SICS-GeekLounge-151020.pcap");
+
+        info!("Testing against {:?}", pcap_path);
+
+        let handle = Handle::file_capture(pcap_path.to_str().expect("No path found"))
+            .expect("No handle created");
+
+        let packets = smol::run(async move {
+            let packet_provider =
+                PacketStream::new(Config::default(), Arc::clone(&handle)).expect("Failed to build");
+            let fut_packets = packet_provider.collect::<Vec<_>>();
+            let packets: Vec<_> = fut_packets
+                .await
+                .into_iter()
+                .flatten()
+                .flatten()
+                .filter(|p| p.data().len() == p.actual_length() as usize)
+                .collect();
+
+            handle.interrupt();
+
+            packets
+        });
+
+        assert_eq!(packets.len(), 246137);
+    }
+
     #[test]
     fn packets_from_file_next() {
         let _ = env_logger::try_init();