catch + resume unwinds out of the handler function

Author: saethlin

src/lib.rs

@@ -59,6 +59,7 @@
 //! ```
 
 use bitflags::bitflags;
+use std::any::Any;
 use std::borrow::Borrow;
 use std::convert::TryFrom;
 use std::ffi::{self, CStr, CString};
@@ -69,6 +70,7 @@ use std::net::IpAddr;
 use std::ops::Deref;
 #[cfg(not(windows))]
 use std::os::unix::io::{AsRawFd, RawFd};
+use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe};
 use std::path::Path;
 use std::ptr::{self, NonNull};
 use std::slice;
@@ -841,11 +843,13 @@ impl<T: State + ?Sized> From<NonNull<raw::pcap_t>> for Capture<T> {
 // pointer and the right data pointer to pcap_loop.
 struct Handler<F> {
     func: F,
+    panic_payload: Option<Box<dyn Any + Send>>,
+    handle: NonNull<raw::pcap_t>,
 }
 
 impl<F> Handler<F>
 where
-    F: FnMut(Packet),
+    F: FnMut(Packet) + RefUnwindSafe,
 {
     extern "C" fn callback(
         slf: *mut libc::c_uchar,
@@ -859,25 +863,39 @@ where
             );
 
             let slf = slf as *mut Self;
-            ((*slf).func)(packet)
+            let func = std::ptr::addr_of_mut!((*slf).func);
+            // If our handler function panics, we need to prevent it from unwinding across the
+            // FFI boundary. If the handler panics we catch the unwind here, break out of
+            // pcap_loop, and resume the unwind outside.
+            if let Err(e) = catch_unwind(|| (*func)(packet)) {
+                (*slf).panic_payload = Some(e);
+                raw::pcap_breakloop((*slf).handle.as_ptr());
+            }
         }
     }
 }
 
 impl<T: State + ?Sized> Capture<T> {
-    pub fn pcap_loop<F>(&mut self, handler: F)
+    pub fn for_each<F>(&mut self, handler: F)
     where
-        F: FnMut(Packet),
+        F: FnMut(Packet) + RefUnwindSafe,
     {
-        let mut handler = Handler { func: handler };
+        let mut handler = Handler {
+            func: handler,
+            panic_payload: None,
+            handle: self.handle,
+        };
         unsafe {
             raw::pcap_loop(
                 self.handle.as_ptr(),
-                0,
+                -1,
                 Handler::<F>::callback,
                 ptr::addr_of_mut!(handler).cast(),
             )
         };
+        if let Some(e) = handler.panic_payload {
+            resume_unwind(e);
+        }
     }
 
     fn new_raw<F>(path: Option<&str>, func: F) -> Result<Capture<T>, Error>

src/raw.rs

@@ -101,7 +101,7 @@ pub struct pcap_send_queue {
 
 // This is not Option<fn>, pcap functions do not check if the handler is null.
 pub type pcap_handler =
-    extern "C" fn(arg1: *mut c_uchar, arg2: *const pcap_pkthdr, arg3: *const c_uchar) -> ();
+    extern "C" fn(user: *mut c_uchar, h: *const pcap_pkthdr, bytes: *const c_uchar) -> ();
 
 extern "C" {
     // [OBSOLETE] pub fn pcap_lookupdev(arg1: *mut c_char) -> *mut c_char;
@@ -134,7 +134,7 @@ extern "C" {
         arg2: *mut *mut pcap_pkthdr,
         arg3: *mut *const c_uchar,
     ) -> c_int;
-    // pub fn pcap_breakloop(arg1: *mut pcap_t);
+    pub fn pcap_breakloop(arg1: *mut pcap_t);
     pub fn pcap_stats(arg1: *mut pcap_t, arg2: *mut pcap_stat) -> c_int;
     pub fn pcap_setfilter(arg1: *mut pcap_t, arg2: *mut bpf_program) -> c_int;
     pub fn pcap_setdirection(arg1: *mut pcap_t, arg2: pcap_direction_t) -> c_int;