@mark1russell7/harness 0.3.0 → 0.4.1

package/image/native/src/bin/client.rs

@@ -15,8 +15,10 @@
 //! timeout makes the server answer only when the timeout runs out, so its reply can be the one in
 //! flight when a fault lands.
 //! stream: then wait for --go, and send the request --count times, each when the reply to the one
-//! before it has come and --interval-ms has passed: a distribution of reply times, for a fault
-//! whose outcome is one (loss, reordering). It ends with a done line.
+//! before it is whole and --interval-ms has passed: a distribution of reply times, for a fault
+//! whose outcome is one (loss, reordering). A reply is whole at its CRLF, or for a bulk string
+//! after its length: so `GET big` keeps a long reply's many segments in flight, and the replied
+//! line stamps its last byte. It ends with a done line.
 
 use prober::{errno_name, monotonic_ns, quantity};
 use serde_json::{json, Value};
@@ -87,6 +89,40 @@ fn readable(fd: i32, ms: i32) -> std::io::Result<bool> {
     }
 }
 
+/// The whole length of a Redis reply from its first bytes, or None while its first line is not
+/// all there: a simple string, an error or an integer ends at its CRLF, and a bulk string after
+/// its length and one more CRLF (a null one, of length -1, at its first CRLF).
+fn reply_length(head: &[u8]) -> Option<usize> {
+    let line = head.windows(2).position(|pair| pair == b"\r\n")? + 2;
+    if head.first() != Some(&b'$') {
+        return Some(line);
+    }
+    let length: i64 = std::str::from_utf8(&head[1..line - 2]).ok()?.parse().ok()?;
+    Some(if length < 0 { line } else { line + length as usize + 2 })
+}
+
+/// The reply a stream waits for: its first bytes until its length is known, and how much came.
+#[derive(Default)]
+struct Reply {
+    head: Vec<u8>,
+    length: Option<usize>,
+    got: usize,
+}
+
+impl Reply {
+    /// Takes the bytes of one read, and says whether the reply is whole.
+    fn take(&mut self, bytes: &[u8]) -> bool {
+        self.got += bytes.len();
+        if self.length.is_none() {
+            // a bulk string's first line is its length: 64 bytes hold any
+            let room = 64usize.saturating_sub(self.head.len());
+            self.head.extend_from_slice(&bytes[..bytes.len().min(room)]);
+            self.length = reply_length(&self.head);
+        }
+        matches!(self.length, Some(length) if self.got >= length)
+    }
+}
+
 /// what in TCP_INFO is worth a line when it changes: the timers' own state, never the ages
 fn watched(info: &libc::tcp_info) -> [u32; 7] {
     [
@@ -186,6 +222,7 @@ fn run() -> Result<(), Box<dyn Error>> {
     // stream mode: requests sent, whether one waits for its reply, and when the next may go
     let mut sent: u32 = 0;
     let mut awaiting = false;
+    let mut reply = Reply::default();
     let mut next_at: u64 = 0;
     loop {
         if readable(fd, tick)? {
@@ -196,8 +233,10 @@ fn run() -> Result<(), Box<dyn Error>> {
                 }
                 Ok(n) => {
                     emit("data", json!({ "n": n, "text": String::from_utf8_lossy(&buf[..n.min(40)]) }));
-                    if awaiting {
+                    if awaiting && reply.take(&buf[..n]) {
+                        emit("replied", json!({ "n": quantity(reply.got as u32, "B") }));
                         awaiting = false;
+                        reply = Reply::default();
                         next_at = monotonic_ns() + args.interval.as_nanos() as u64;
                     }
                 }
@@ -261,3 +300,24 @@ fn main() {
         std::process::exit(1);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_reply_is_whole_at_its_crlf_or_after_its_bulk_length() {
+        assert_eq!(reply_length(b"+PONG\r\n"), Some(7));
+        assert_eq!(reply_length(b"+PON"), None);
+        assert_eq!(reply_length(b"$5\r\nhello\r\n"), Some(11));
+        assert_eq!(reply_length(b"$-1\r\n"), Some(5));
+        assert_eq!(reply_length(b"$1000000\r\nxx"), Some(1_000_012));
+        // a long reply in reads of any size: whole only at its last byte
+        let mut reply = Reply::default();
+        assert!(!reply.take(b"$10\r"));
+        assert!(!reply.take(b"\n01234"));
+        assert!(!reply.take(b"56789\r"));
+        assert!(reply.take(b"\n"));
+        assert_eq!(reply.got, 17);
+    }
+}

package/image/native/src/bin/inject.rs

@@ -30,6 +30,12 @@
 //! `--at NS` holds the commit until that instant on CLOCK_MONOTONIC, the clock every stamp is on.
 //! A stall's end is timed that way, from inside the VM: the exec only has to arrive before it, and
 //! its 190 ms never reach the stall's length.
+//!
+//! `--via DEV` puts a filter rule in the FORWARD chain, for a router: its INPUT and OUTPUT see only
+//! what the router itself sends and receives. The rule faces one side by the device toward it:
+//! what comes from the peer arrives on DEV (`-i DEV -s PEER`), and what goes to it leaves on DEV
+//! (`-o DEV -d PEER`). A REJECT then answers from the router: a reset spoofs the address the
+//! segment was going to, and an ICMP error comes from the router's own address on DEV.
 
 use prober::monotonic_ns;
 use serde_json::json;
@@ -63,13 +69,15 @@ fn until(at: u64) -> Result<(), Box<dyn Error>> {
     }
 }
 
-/// The options after the positional arguments: `--at NS`, `--direction D`, `--code C`, `--above N`.
+/// The options after the positional arguments: `--at NS`, `--direction D`, `--code C`, `--above N`,
+/// `--via DEV`.
 #[derive(Default)]
 struct Options {
     at: Option<u64>,
     direction: Option<String>,
     code: Option<String>,
     above: Option<u32>,
+    via: Option<String>,
 }
 
 fn options(args: &[String]) -> Result<Options, Box<dyn Error>> {
@@ -82,6 +90,7 @@ fn options(args: &[String]) -> Result<Options, Box<dyn Error>> {
             "--direction" => out.direction = Some(value.clone()),
             "--code" => out.code = Some(value.clone()),
             "--above" => out.above = Some(value.parse()?),
+            "--via" => out.via = Some(device(value)?.to_string()),
             other => return Err(format!("unknown option {other}").into()),
         }
     }
@@ -91,12 +100,18 @@ fn options(args: &[String]) -> Result<Options, Box<dyn Error>> {
 /// The iptables rules of an action that is a filter rule, or None for an action that is not.
 fn rules(action: &str, peer: Ipv4Addr, opts: &Options) -> Result<String, Box<dyn Error>> {
     let op = |set: &str| if action == set { "-I" } else { "-D" };
+    // what comes from the peer, and what goes to it: at an end, the INPUT and OUTPUT of its own
+    // sockets; at a router, what it forwards in and out of the device toward the peer
+    let (from, to) = match opts.via.as_deref() {
+        None => (format!("INPUT -s {peer}/32"), format!("OUTPUT -d {peer}/32")),
+        Some(dev) => (format!("FORWARD -i {dev} -s {peer}/32"), format!("FORWARD -o {dev} -d {peer}/32")),
+    };
     Ok(match action {
         "blackhole" | "clear" => {
             let op = op("blackhole");
             let direction = opts.direction.as_deref().unwrap_or("both");
-            let input = format!("{op} INPUT -s {peer}/32 -j DROP\n");
-            let output = format!("{op} OUTPUT -d {peer}/32 -j DROP\n");
+            let input = format!("{op} {from} -j DROP\n");
+            let output = format!("{op} {to} -j DROP\n");
             match direction {
                 "both" => format!("{input}{output}"),
                 "in" => input,
@@ -106,7 +121,7 @@ fn rules(action: &str, peer: Ipv4Addr, opts: &Options) -> Result<String, Box<dyn
         }
         "rst" | "clear-rst" => {
             let op = op("rst");
-            format!("{op} INPUT -s {peer}/32 -p tcp -j REJECT --reject-with tcp-reset\n")
+            format!("{op} {from} -p tcp -j REJECT --reject-with tcp-reset\n")
         }
         "reject" | "clear-reject" => {
             let op = op("reject");
@@ -117,14 +132,14 @@ fn rules(action: &str, peer: Ipv4Addr, opts: &Options) -> Result<String, Box<dyn
                 "admin" => "icmp-admin-prohibited",
                 other => return Err(format!("unknown code {other}").into()),
             };
-            format!("{op} INPUT -s {peer}/32 -p tcp -j REJECT --reject-with {with}\n")
+            format!("{op} {from} -p tcp -j REJECT --reject-with {with}\n")
         }
         // the long segments drop where they arrive: in the sender's own namespace, an OUTPUT drop
         // would fail its sends with EPERM rather than lose them on the way
         "mtu" | "clear-mtu" => {
             let op = op("mtu");
             let above = opts.above.ok_or("--above N")?;
-            format!("{op} INPUT -s {peer}/32 -p tcp -m length --length {}:65535 -j DROP\n", above + 1)
+            format!("{op} {from} -p tcp -m length --length {}:65535 -j DROP\n", above + 1)
         }
         other => return Err(format!("unknown action {other}").into()),
     })
@@ -323,6 +338,33 @@ mod tests {
         assert!(rules("reject", peer, &Options::default()).is_err());
     }
 
+    #[test]
+    fn a_router_gets_forward_rules_that_face_one_device() {
+        let peer: Ipv4Addr = "10.0.0.2".parse().unwrap();
+        let via = |direction: Option<&str>| Options {
+            direction: direction.map(Into::into),
+            via: Some("eth0".into()),
+            ..Options::default()
+        };
+        assert_eq!(
+            rules("blackhole", peer, &via(None)).unwrap(),
+            "-I FORWARD -i eth0 -s 10.0.0.2/32 -j DROP\n-I FORWARD -o eth0 -d 10.0.0.2/32 -j DROP\n"
+        );
+        assert_eq!(rules("clear", peer, &via(Some("out"))).unwrap(), "-D FORWARD -o eth0 -d 10.0.0.2/32 -j DROP\n");
+        assert_eq!(
+            rules("rst", peer, &via(None)).unwrap(),
+            "-I FORWARD -i eth0 -s 10.0.0.2/32 -p tcp -j REJECT --reject-with tcp-reset\n"
+        );
+        let host = Options { code: Some("host".into()), ..via(None) };
+        assert_eq!(
+            rules("clear-reject", peer, &host).unwrap(),
+            "-D FORWARD -i eth0 -s 10.0.0.2/32 -p tcp -j REJECT --reject-with icmp-host-unreachable\n"
+        );
+        // a device name is letters, digits, dots and dashes: nothing else reaches the rules
+        assert!(options(&["--via".into(), "eth0;x".into()]).is_err());
+        assert_eq!(options(&["--via".into(), "eth1".into()]).unwrap().via.as_deref(), Some("eth1"));
+    }
+
     #[test]
     fn http_requests_take_only_a_method_a_path_and_a_length() {
         assert!(http_path("/proxies/redis/toxics").is_ok());

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A fault-injection harness for connection timers: a cell runs a client against a stock target in Docker, through a topology of routers and proxies, injects a fault, measures the kernel's own records and judges a prediction.",
   "keywords": [
     "fault-injection",
@@ -56,8 +56,8 @@
     "node": ">=22.19"
   },
   "dependencies": {
-    "@mark1russell7/prober": "^0.1.0",
-    "@mark1russell7/quantity": "^0.1.0",
+    "@mark1russell7/prober": "^0.3.1",
+    "@mark1russell7/quantity": "^0.2.0",
     "testcontainers": "12.2.0"
   },
   "peerDependencies": {