Add function

Author: malt03

README.md

@@ -42,6 +42,8 @@ fn main() -> std::io::Result<()> {
 }
 ```
 
+Need to detect Ctrl-C more than once? See [`examples/multi_ctrlc.rs`](https://github.com/malt03/ctrlc-tiny/blob/main/examples/multi_ctrlc.rs).
+
 ## 🔍 Why not use `ctrlc`?
 
 [`ctrlc`](https://crates.io/crates/ctrlc) provides a flexible way to handle signals using closures and shared state.
@@ -55,6 +57,7 @@ No threads, no handlers, no extra logic.
 
 - Internally uses a `volatile sig_atomic_t` flag — safe in POSIX signal handlers.
 - No heap, no threads — fully signal-safe by design.
+- The flag can be reset via `reset_ctrlc_received()`, but may race with the signal handler if SIGINT is received at the same time.
 
 ## 🛠️ Platform Support
 

build.rs

@@ -31,6 +31,7 @@ fn main() -> Result<(), Error> {
         .header("c_src/sigint.h")
         .allowlist_function("init_sigint_handler")
         .allowlist_function("get_is_sigint_received")
+        .allowlist_function("reset_is_sigint_received")
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
         .generate()?;
 

c_src/sigint.c

@@ -23,3 +23,8 @@ sig_atomic_t get_is_sigint_received()
 {
     return is_sigint_received;
 }
+
+void reset_is_sigint_received()
+{
+    is_sigint_received = 0;
+}

c_src/sigint.h

@@ -5,5 +5,6 @@
 
 int init_sigint_handler(void);
 sig_atomic_t get_is_sigint_received(void);
+void reset_is_sigint_received(void);
 
 #endif

examples/ctrlc_probe.rs

@@ -2,18 +2,21 @@ use std::io::{stdout, Write};
 use std::{thread, time::Duration};
 
 fn main() -> std::io::Result<()> {
+    ctrlc_tiny::init_ctrlc()?;
+
     println!("probe started");
     stdout().flush()?;
 
-    // Initialize the Ctrl-C handler
-    ctrlc_tiny::init_ctrlc()?;
-
-    // Poll until SIGINT is received
+    let mut count = 0;
     loop {
         if ctrlc_tiny::is_ctrlc_received() {
-            println!("Ctrl-C detected");
+            count += 1;
+            println!("Ctrl-C detected: {}", count);
             stdout().flush()?;
-            break;
+            if count == 2 {
+                break;
+            }
+            ctrlc_tiny::reset_ctrlc_received();
         }
         thread::sleep(Duration::from_millis(50));
     }

examples/multi_ctrlc.rs

@@ -0,0 +1,26 @@
+//! Example: detecting multiple Ctrl-C presses
+//!
+//! This example demonstrates how to detect Ctrl-C multiple times
+//! by resetting the internal flag after each detection.
+
+fn main() -> std::io::Result<()> {
+    ctrlc_tiny::init_ctrlc()?;
+
+    let mut count = 0;
+    loop {
+        if ctrlc_tiny::is_ctrlc_received() {
+            ctrlc_tiny::reset_ctrlc_received();
+
+            count += 1;
+            println!("SIGINT received {} time(s)", count);
+
+            if count == 10 {
+                break;
+            }
+        }
+
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+
+    Ok(())
+}

src/lib.rs

@@ -68,6 +68,39 @@ pub fn is_ctrlc_received() -> bool {
     unsafe { bindings::get_is_sigint_received() != 0 }
 }
 
+/// Resets the internal Ctrl-C received flag to `false`.
+///
+/// This can be useful if you want to detect multiple Ctrl-C presses
+/// independently (e.g. "exit on second Ctrl-C").
+///
+/// # Safety
+///
+/// Internally, this clears a `sig_atomic_t` flag that may be concurrently
+/// modified by the signal handler. This is safe but may cause a signal
+/// received during the reset to be missed.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// ctrlc_tiny::init_ctrlc()?;
+/// let mut count = 0;
+/// loop {
+///     if ctrlc_tiny::is_ctrlc_received() {
+///         ctrlc_tiny::reset_ctrlc_received();
+///         count += 1;
+///         if count == 2 {
+///             break;
+///         }
+///     }
+/// }
+/// # Ok::<_, std::io::Error>(())
+/// ```
+pub fn reset_ctrlc_received() {
+    unsafe {
+        bindings::reset_is_sigint_received();
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -81,5 +114,7 @@ mod tests {
     #[test]
     fn is_ctrlc_received_initially_false() {
         assert!(!is_ctrlc_received());
+        reset_ctrlc_received();
+        assert!(!is_ctrlc_received());
     }
 }

tests/e2e.rs

@@ -11,17 +11,21 @@ fn e2e_test() {
     let child_id = child.id();
     let stdout = child.stdout.expect("failed to capture stdout");
     let mut reader = std::io::BufReader::new(stdout);
-    let mut last_line: String = String::new();
+    let mut lines = Vec::new();
+    let mut started = false;
 
     loop {
         let mut line = String::new();
         if reader.read_line(&mut line).expect("failed to read line") == 0 {
             break;
         }
         let line = line.trim();
-        last_line = line.to_string();
-        if line == "probe started" {
-            thread::sleep(Duration::from_millis(50));
+        if started {
+            lines.push(line.to_string());
+        } else if line == "probe started" {
+            started = true;
+        }
+        if started {
             unsafe {
                 libc::kill(child_id as i32, libc::SIGINT);
             }
@@ -30,8 +34,8 @@ fn e2e_test() {
     }
 
     assert_eq!(
-        last_line.trim(),
-        "Ctrl-C detected",
+        lines,
+        vec!["Ctrl-C detected: 1", "Ctrl-C detected: 2",],
         "Expected Ctrl-C detection in child output"
     );
 }