From 29cc80f40568106b3df981e27c007cfea0abde0b Mon Sep 17 00:00:00 2001
From: stickynotememo <samk26633@gmail.com>
Date: Tue, 30 Dec 2025 11:17:19 +1100
Subject: [PATCH] add write()

---
 src/lib.rs | 33 +++++++++++----------------------
 1 file changed, 11 insertions(+), 22 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 26c9916..e3166bb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,5 @@
 use bitvec::prelude::*;
 use std::io::{self, Read, Write};
-use std::os::unix::process;
 
 use signal_hook::consts::*;
 use signal_hook::iterator::Signals;
@@ -21,48 +20,41 @@ impl Read for SignalStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let mut n = 0;
 
-        dbg!(std::process::id());
-
         let pending = self.signals.forever();
         let mut bitlist = bitvec![];
         for signal in pending {
-            dbg!(&signal);
             n += 1;
             bitlist.push(match signal {
                 SIGUSR1 => false,
                 SIGUSR2 => true,
                 _ => {
+                    // This should be impossible, as only the SIGUSR1 and SIGUSR2 signals are
+                    // registered to begin with.
                     panic!("Program recieved an unexpected signal, despite it not being registered")
                 }
             });
+
             if n >= buf.len() * 8 {
-                dbg!("broken");
                 break;
             }
         }
 
-        dbg!(bitlist.to_string());
-
+        // Converts a bitvec to a vec of bytes, with 1/8th the length.
+        // Adapted from https://stackoverflow.com/a/72572904
         for (i, bit) in bitlist.iter().enumerate() {
             let byte = i / 8;
             let shift = 7 - i % 8;
             buf[byte] |= ((*bit) as u8) << shift
         }
 
-        // std::process::exit(1);
-        // if bytelist.len() % buf.len() != 0 {
-        // return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Could not read enough bits."));
-        // };
-
         Ok(n)
     }
 }
 
 impl Write for SignalStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        dbg!(std::process::id());
         for num in buf {
-            let bit_representation = String::from(format!("{num:b}"));
+            let bit_representation = String::from(format!("{num:08b}"));
             for bit in bit_representation.chars() {
                 let signal = match bit
                     .to_digit(2)
@@ -72,10 +64,10 @@ impl Write for SignalStream {
                     1 => SIGUSR2,
                     _ => panic!("Non-binary digit in binary representation"),
                 };
+
                 unsafe {
                     libc::kill(self.pid as i32, signal);
                 };
-                std::thread::sleep(std::time::Duration::from_millis(100));
             }
         }
         Ok(0)
@@ -92,11 +84,8 @@ mod tests {
     use std::{process::Command, thread::sleep, time::Duration};
 
     #[test]
-    fn read_test() {
-        let mut sigstream = SignalStream::new(std::process::id());
-        // sigstream.write(&[4]).unwrap();
-        let mut buf = [0; 3];
-        dbg!(sigstream.read(&mut buf).unwrap());
-        dbg!(buf);
-    }
+    fn read_test() {}
+
+    #[test]
+    fn write_test() {}
 }