@mark1russell7/harness 0.14.2 → 0.14.4

package/image/kafka/Dockerfile

@@ -0,0 +1,23 @@
+# The harness's client of Apache Kafka: kafka-clients 4.3.2 on Temurin 21.0.12.1. It runs as a
+# container in the client's network namespace, as the harness's own TCP client does. It prints the
+# same JSON lines. AdminKafka is the admin of a lab: it makes each topic, reads the state of a
+# partition, and reads the whole partition after a run.
+# lab.ts stages the build context: this folder, under harness/image/kafka. The build gets each jar
+# from Maven Central and checks its SHA-256 (jars.sha256), thus a build cannot get another jar. The
+# jars are kafka-clients and each runtime dependency of its POM.
+FROM eclipse-temurin:21.0.12.1_1-jdk-alpine@sha256:0bfc69a4758a86710e5c474032d28400a8bd00874766f9e8b1642ac2fd293159 AS build
+WORKDIR /build
+COPY harness/image/kafka/jars.sha256 ./
+RUN wget -q https://repo1.maven.org/maven2/org/apache/kafka/kafka-clients/4.3.2/kafka-clients-4.3.2.jar \
+ && wget -q https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.36/slf4j-api-1.7.36.jar \
+ && wget -q https://repo1.maven.org/maven2/com/github/luben/zstd-jni/1.5.6-10/zstd-jni-1.5.6-10.jar \
+ && wget -q https://repo1.maven.org/maven2/at/yawk/lz4/lz4-java/1.11.4/lz4-java-1.11.4.jar \
+ && wget -q https://repo1.maven.org/maven2/org/xerial/snappy/snappy-java/1.1.10.11/snappy-java-1.1.10.11.jar \
+ && sha256sum -c jars.sha256
+COPY harness/image/kafka/ClientKafka.java harness/image/kafka/AdminKafka.java ./
+RUN javac --release 21 -cp "kafka-clients-4.3.2.jar:slf4j-api-1.7.36.jar" -d classes ClientKafka.java AdminKafka.java
+
+FROM eclipse-temurin:21.0.12.1_1-jre-alpine@sha256:51ab5e3302e7141ce665ca3ea85e8b5cd648eafbc3c0c90dd79d6537684e4555
+WORKDIR /opt/harness/kafka
+COPY --from=build /build/kafka-clients-4.3.2.jar /build/slf4j-api-1.7.36.jar /build/zstd-jni-1.5.6-10.jar /build/lz4-java-1.11.4.jar /build/snappy-java-1.1.10.11.jar ./lib/
+COPY --from=build /build/classes ./classes

package/image/kafka/jars.sha256

@@ -0,0 +1,5 @@
+edaf0818414a61a98d1d2e58d6966be8c9f780cef6ded2ffbab10dd841b2bfb8  kafka-clients-4.3.2.jar
+d3ef575e3e4979678dc01bf1dcce51021493b4d11fb7f1be8ad982877c16a1c0  slf4j-api-1.7.36.jar
+b6c3237e24b8252a5a9c3a0e1ae30ef8f323412e74bd358548b7a9e527d676df  zstd-jni-1.5.6-10.jar
+58c8e0b813960d2a248e050c353baea73139b48a2ffc55382d42c69707e17325  lz4-java-1.11.4.jar
+58d245ec749fc608ecb175e934a16f2840442c5742aed91002cfd4cb9c6c7aee  snappy-java-1.1.10.11.jar

package/image/mongo/client-mongo.mjs

@@ -1,5 +1,5 @@
 // client-mongo HOST PORT --mode idle|inflight|stream [--hosts H:P,H:P] [--set NAME] [--op write|read-long]
-//              [--interval-ms N] [--max-s N] [--go PATH] [--w majority|1] [--before] [--options JSON]
+//              [--interval-ms N] [--max-s N] [--go PATH] [--w majority|1] [--before] [--from N] [--options JSON]
 //
 // The client of a MongoDB cell: the driver mongodb 7.7.0 on Node 24.21.0, against a replica set.
 // Each event is a JSON line with `ev` and `t`, the time on CLOCK_MONOTONIC in nanoseconds
@@ -28,7 +28,8 @@
 // write, waits for the file --go, sends one more operation into the fault, and holds the
 // connections after its end. stream sends a write each --interval-ms after the reply before, until
 // --max-s or SIGTERM. --before starts the client into a fault that holds already: its first
-// selection meets it.
+// selection meets it. --from starts the numbers of a stream at N: a recovery drill starts a second
+// client after a restore, and its numbers follow the numbers of the first client.
 
 import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
@@ -57,6 +58,7 @@ const max = Number(flag("--max-s") ?? 120) * 1000;
 const go = flag("--go") ?? "/tmp/go";
 const w = flag("--w") === "1" ? 1 : "majority";
 const before = argv.includes("--before");
+const start = Number(flag("--from") ?? 1);
 const options = JSON.parse(flag("--options") ?? "{}");
 
 // ---- the two clocks: the wall clock of a log line of mongod goes onto the monotonic clock by them
@@ -242,7 +244,7 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 if (mode === "stream") {
   emit("ready", { at: first });
-  for (let n = 1; !stopped; n += 1) {
+  for (let n = start; !stopped; n += 1) {
     await operate(n);
     await sleep(interval);
   }

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

@@ -39,6 +39,9 @@
 //! - `resp ADDR:PORT ARG...`: one command to a Redis-protocol server, for example
 //!   `SENTINEL FAILOVER mymaster` to a Sentinel. The stamps bracket the write of the command and
 //!   the first line of its reply, so a planned failover starts at a known instant.
+//! - `silence` / `clear-silence`: each packet of this namespace drops, in the three chains at one
+//!   commit, and no peer is named. The links stay up and ARP goes on, so a router in this namespace
+//!   goes silent, and its neighbors can detect that only by their own timers.
 //! - `query ADDR:PORT USER DATABASE SQL`: one simple query to a server of the PostgreSQL protocol
 //!   that trusts the user, for example `PAUSE` on the console of PgBouncer. The stamps bracket the
 //!   write of the query and its ReadyForQuery, after the login, so the end of a PAUSE is known.
@@ -88,6 +91,30 @@ fn until(at: u64) -> Result<(), Box<dyn Error>> {
     }
 }
 
+/// The rules of a namespace that goes silent, or of the end of the silence.
+fn silence(action: &str) -> String {
+    let op = if action == "silence" { "-I" } else { "-D" };
+    ["INPUT", "OUTPUT", "FORWARD"].map(|chain| format!("{op} {chain} -j DROP\n")).concat()
+}
+
+/// Commits rules in one iptables-restore at an instant, between two stamps.
+fn commit(body: &str, at: Option<u64>) -> Result<(u64, u64), Box<dyn Error>> {
+    let script = format!("*filter\n{body}COMMIT\n");
+    if let Some(at) = at {
+        until(at)?;
+    }
+    let t0 = monotonic_ns();
+    let mut child =
+        Command::new("iptables-restore").arg("--noflush").stdin(Stdio::piped()).spawn()?;
+    child.stdin.take().ok_or("iptables-restore took no stdin")?.write_all(script.as_bytes())?;
+    let status = child.wait()?;
+    let t1 = monotonic_ns();
+    if !status.success() {
+        return Err(format!("iptables-restore exited {status}").into());
+    }
+    Ok((t0, t1))
+}
+
 /// The options after the positional arguments: `--at NS`, `--direction D`, `--code C`, `--above N`,
 /// `--via DEV`.
 #[derive(Default)]
@@ -559,6 +586,12 @@ fn run() -> Result<(), Box<dyn Error>> {
             println!("{}", json!({ "action": action, "device": dev, "spec": spec, "t0": t0, "t1": t1 }));
             Ok(())
         }
+        "silence" | "clear-silence" => {
+            let opts = options(&args[1..])?;
+            let (t0, t1) = commit(&silence(action), opts.at)?;
+            println!("{}", json!({ "action": action, "t0": t0, "t1": t1 }));
+            Ok(())
+        }
         _ => {
             // parsed, never pasted: only addresses reach the rules
             let list = peers(args.get(1).ok_or("and the peer's address")?)?;
@@ -567,19 +600,7 @@ fn run() -> Result<(), Box<dyn Error>> {
             for peer in &list {
                 body.push_str(&rules(action, *peer, &opts)?);
             }
-            let script = format!("*filter\n{body}COMMIT\n");
-            if let Some(at) = opts.at {
-                until(at)?;
-            }
-            let t0 = monotonic_ns();
-            let mut child =
-                Command::new("iptables-restore").arg("--noflush").stdin(Stdio::piped()).spawn()?;
-            child.stdin.take().ok_or("iptables-restore took no stdin")?.write_all(script.as_bytes())?;
-            let status = child.wait()?;
-            let t1 = monotonic_ns();
-            if !status.success() {
-                return Err(format!("iptables-restore exited {status}").into());
-            }
+            let (t0, t1) = commit(&body, opts.at)?;
             let named: Vec<String> = list.iter().map(ToString::to_string).collect();
             println!("{}", json!({ "action": action, "peer": named.join(","), "t0": t0, "t1": t1 }));
             Ok(())
@@ -624,6 +645,12 @@ mod tests {
         assert!(rules("reject", peer, &Options::default()).is_err());
     }
 
+    #[test]
+    fn a_silence_drops_each_chain_and_its_end_takes_the_rules_out() {
+        assert_eq!(silence("silence"), "-I INPUT -j DROP\n-I OUTPUT -j DROP\n-I FORWARD -j DROP\n");
+        assert_eq!(silence("clear-silence"), "-D INPUT -j DROP\n-D OUTPUT -j DROP\n-D FORWARD -j DROP\n");
+    }
+
     #[test]
     fn a_router_gets_forward_rules_that_face_one_device() {
         let peer: Ipv4Addr = "10.0.0.2".parse().unwrap();

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

@@ -0,0 +1,374 @@
+//! ports target PORT
+//! ports client [--rounds N] [--close reset|client|target] [--destinations N] [--settle-ms N]
+//!              [--retry-ms N] [--wait-s N] HOST PORT [--mode M] [--max-s N]
+//!
+//! This program is the two ends of the port range cells: a target that accepts each connection,
+//! and a client that connects until its range has no port. Each line is JSON with an `ev` and a `t`
+//! on CLOCK_MONOTONIC.
+//!
+//! The target listens on PORT and on PORT + 2, the two destinations of a cell. It serves one command
+//! on PORT + 1, its control port: `close COUNT` waits until it holds COUNT connections, and closes them.
+//!
+//! The client does these steps in each round:
+//!
+//! 1. It connects to each destination until a connect fails, and it holds each connection. A `round`
+//!    line gives the ports of each destination, the errno of the failed connect and its time.
+//! 2. `--close reset` closes each connection with a reset. The target then closes its sockets.
+//! 3. `--close client` closes each connection with a FIN, and it waits `--settle-ms`. The target
+//!    then closes its sockets, between the lines `closing` and `closed`. The client connects again
+//!    each `--retry-ms`, until it holds each port or `--wait-s` passes. A `freed` line gives each port.
+//!    It then closes those connections with a reset, so that the next run finds each port free.
+//! 4. `--close target` makes the target close first. The client reads the FIN of each connection,
+//!    closes it, and waits `--settle-ms`.
+//!
+//! The control connection takes a port of the range. Its destination is not a destination of the
+//! search, thus it does not change a count. It has SO_LINGER 0 from its connect, so that its close is a
+//! reset and holds no port. A FIN at the exit of the client holds that port in TIME_WAIT for 60 s. A
+//! range of 3 has only 2 ports for a search. Thus the third run of an environment had no control port.
+
+use prober::{errno_name, monotonic_ns};
+use serde_json::{json, Value};
+use std::error::Error;
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::{Ipv4Addr, SocketAddrV4, TcpListener, TcpStream};
+use std::os::fd::AsRawFd;
+use std::sync::{Arc, Mutex, MutexGuard};
+use std::time::Duration;
+
+/// the most connections that one search holds: a guard for a range that the harness did not set
+const LIMIT: usize = 256;
+/// how long `close COUNT` waits for the accept of the last connection, in milliseconds
+const ACCEPT_WAIT_MS: u64 = 2_000;
+
+fn emit(event: &str, fields: Value) {
+    let mut line = json!({ "ev": event, "t": monotonic_ns() });
+    if let (Some(line), Value::Object(fields)) = (line.as_object_mut(), fields) {
+        line.extend(fields);
+    }
+    println!("{line}");
+}
+
+fn locked(held: &Mutex<Vec<TcpStream>>) -> MutexGuard<'_, Vec<TcpStream>> {
+    held.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+/// Accepts each connection of a port on its own thread.
+fn listen(port: u16, held: &Arc<Mutex<Vec<TcpStream>>>) -> std::io::Result<()> {
+    let listener = TcpListener::bind((Ipv4Addr::UNSPECIFIED, port))?;
+    let held = Arc::clone(held);
+    std::thread::spawn(move || {
+        for stream in listener.incoming().flatten() {
+            locked(&held).push(stream);
+        }
+    });
+    Ok(())
+}
+
+/// Waits until the target holds `count` connections, and closes each one. It gives the count it closed.
+fn close_held(held: &Mutex<Vec<TcpStream>>, count: usize) -> usize {
+    for _ in 0..ACCEPT_WAIT_MS {
+        if locked(held).len() >= count {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(1));
+    }
+    let mut held = locked(held);
+    let closed = held.len();
+    held.clear();
+    closed
+}
+
+fn serve(stream: TcpStream, held: &Mutex<Vec<TcpStream>>) -> Result<(), Box<dyn Error>> {
+    stream.set_nodelay(true)?;
+    let mut writer = stream.try_clone()?;
+    for line in BufReader::new(stream).lines() {
+        let line = line?;
+        let mut words = line.split_whitespace();
+        let reply = match (words.next(), words.next().and_then(|word| word.parse::<usize>().ok())) {
+            (Some("close"), Some(count)) => json!({ "closed": close_held(held, count) }),
+            _ => json!({ "refused": line }),
+        };
+        writeln!(writer, "{reply}")?;
+    }
+    Ok(())
+}
+
+fn target(args: &[String]) -> Result<(), Box<dyn Error>> {
+    let port: u16 = args.first().ok_or("ports target PORT")?.parse()?;
+    let held = Arc::new(Mutex::new(Vec::new()));
+    listen(port, &held)?;
+    listen(port + 2, &held)?;
+    let control = TcpListener::bind((Ipv4Addr::UNSPECIFIED, port + 1))?;
+    emit("listening", json!({ "control": port + 1 }));
+    for stream in control.incoming() {
+        if let Err(error) = serve(stream?, &held) {
+            emit("control-error", json!({ "error": error.to_string() }));
+        }
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Close {
+    Reset,
+    Client,
+    Target,
+}
+
+#[derive(Debug)]
+struct Plan {
+    host: String,
+    port: u16,
+    rounds: u32,
+    close: Close,
+    destinations: u16,
+    settle_ms: u64,
+    retry_ms: u64,
+    wait_s: u64,
+}
+
+fn plan_of(args: &[String]) -> Result<Plan, Box<dyn Error>> {
+    let mut plan = Plan {
+        host: String::new(),
+        port: 0,
+        rounds: 1,
+        close: Close::Reset,
+        destinations: 1,
+        settle_ms: 50,
+        retry_ms: 10,
+        wait_s: 80,
+    };
+    let mut places = Vec::new();
+    let mut rest = args.iter();
+    while let Some(arg) = rest.next() {
+        let mut value = || rest.next().ok_or_else(|| format!("{arg} needs a value"));
+        match arg.as_str() {
+            "--rounds" => plan.rounds = value()?.parse()?,
+            "--close" => {
+                plan.close = match value()?.as_str() {
+                    "reset" => Close::Reset,
+                    "client" => Close::Client,
+                    "target" => Close::Target,
+                    other => return Err(format!("no way to close named {other}").into()),
+                }
+            }
+            "--destinations" => plan.destinations = value()?.parse()?,
+            "--settle-ms" => plan.settle_ms = value()?.parse()?,
+            "--retry-ms" => plan.retry_ms = value()?.parse()?,
+            "--wait-s" => plan.wait_s = value()?.parse()?,
+            // the harness gives these flags to each client, and the plan does not read them
+            "--mode" | "--max-s" => {
+                value()?;
+            }
+            other if other.starts_with("--") => return Err(format!("no flag {other}").into()),
+            other => places.push(other.to_string()),
+        }
+    }
+    if let [host, port] = places.as_slice() {
+        plan.host = host.clone();
+        plan.port = port.parse()?;
+        return Ok(plan);
+    }
+    Err("ports client [flags] HOST PORT".into())
+}
+
+/// the control connection of the client
+struct Control {
+    reader: BufReader<TcpStream>,
+    writer: TcpStream,
+}
+
+impl Control {
+    fn ask(&mut self, command: &str) -> Result<Value, Box<dyn Error>> {
+        writeln!(self.writer, "{command}")?;
+        let mut line = String::new();
+        self.reader.read_line(&mut line)?;
+        Ok(serde_json::from_str(&line)?)
+    }
+}
+
+/// Closes a connection with a reset: SO_LINGER with a time of 0, then close(2).
+fn reset(stream: TcpStream) -> std::io::Result<()> {
+    abortive(&stream)
+}
+
+/// Sets SO_LINGER with a time of 0, so that each later close of the socket is a reset.
+fn abortive(stream: &TcpStream) -> std::io::Result<()> {
+    let linger = libc::linger { l_onoff: 1, l_linger: 0 };
+    // SAFETY: the option value is on this stack, passed with its exact size
+    let status = unsafe {
+        libc::setsockopt(
+            stream.as_raw_fd(),
+            libc::SOL_SOCKET,
+            libc::SO_LINGER,
+            (&linger as *const libc::linger).cast(),
+            std::mem::size_of::<libc::linger>() as libc::socklen_t,
+        )
+    };
+    if status == 0 { Ok(()) } else { Err(std::io::Error::last_os_error()) }
+}
+
+fn errno_of(error: &std::io::Error) -> String {
+    error.raw_os_error().map_or_else(|| error.to_string(), errno_name)
+}
+
+/// Connects to one destination until a connect fails, and writes the `round` line.
+fn search(index: u32, destination: SocketAddrV4, held: &mut Vec<TcpStream>) -> Result<(), Box<dyn Error>> {
+    let mut ports = Vec::new();
+    let (errno, refusal) = loop {
+        if ports.len() == LIMIT {
+            break ("none".to_string(), 0);
+        }
+        let before = monotonic_ns();
+        match TcpStream::connect(destination) {
+            Ok(stream) => {
+                ports.push(stream.local_addr()?.port());
+                held.push(stream);
+            }
+            Err(error) => break (errno_of(&error), monotonic_ns() - before),
+        }
+    };
+    emit(
+        "round",
+        json!({ "index": index, "destination": destination.port(), "ports": ports, "errno": errno, "refusal": refusal }),
+    );
+    Ok(())
+}
+
+/// Connects again each `retry_ms` until the client holds `count` ports, or the wait ends.
+fn reclaim(plan: &Plan, destination: SocketAddrV4, count: usize) -> Result<Vec<TcpStream>, Box<dyn Error>> {
+    let mut again = Vec::new();
+    let mut tries = 0u32;
+    let end = monotonic_ns() + plan.wait_s * 1_000_000_000;
+    while again.len() < count && monotonic_ns() < end {
+        match TcpStream::connect(destination) {
+            Ok(stream) => {
+                emit("freed", json!({ "port": stream.local_addr()?.port(), "tries": tries }));
+                again.push(stream);
+            }
+            Err(error) if error.raw_os_error() == Some(libc::EADDRNOTAVAIL) => {
+                tries += 1;
+                std::thread::sleep(Duration::from_millis(plan.retry_ms));
+            }
+            Err(error) => {
+                emit("failed", json!({ "errno": errno_of(&error) }));
+                break;
+            }
+        }
+    }
+    Ok(again)
+}
+
+fn close_round(plan: &Plan, first: SocketAddrV4, control: &mut Control, held: Vec<TcpStream>) -> Result<(), Box<dyn Error>> {
+    let count = held.len();
+    let settle = Duration::from_millis(plan.settle_ms);
+    match plan.close {
+        Close::Reset => {
+            for stream in held {
+                reset(stream)?;
+            }
+            control.ask(&format!("close {count}"))?;
+        }
+        Close::Client => {
+            drop(held);
+            std::thread::sleep(settle);
+            emit("closing", json!({}));
+            let reply = control.ask(&format!("close {count}"))?;
+            emit("closed", reply);
+            let again = reclaim(plan, first, count)?;
+            let reclaimed = again.len();
+            for stream in again {
+                reset(stream)?;
+            }
+            control.ask(&format!("close {reclaimed}"))?;
+        }
+        Close::Target => {
+            control.ask(&format!("close {count}"))?;
+            for mut stream in held {
+                let mut sink = [0u8; 16];
+                // the read ends at the FIN of the target, and the close of the stream sends the FIN of the client
+                stream.read(&mut sink)?;
+            }
+            std::thread::sleep(settle);
+        }
+    }
+    Ok(())
+}
+
+fn client(args: &[String]) -> Result<(), Box<dyn Error>> {
+    let plan = plan_of(args)?;
+    let ip: Ipv4Addr = plan.host.parse()?;
+    let stream = TcpStream::connect((ip, plan.port + 1))?;
+    // a reset at each close, the exit included: the port of this connection is free for the next run
+    abortive(&stream)?;
+    stream.set_nodelay(true)?;
+    let mut control = Control { reader: BufReader::new(stream.try_clone()?), writer: stream };
+    let destinations: Vec<SocketAddrV4> = (0..plan.destinations).map(|at| SocketAddrV4::new(ip, plan.port + 2 * at)).collect();
+    emit("ready", json!({}));
+    for index in 0..plan.rounds {
+        let mut held = Vec::new();
+        for destination in &destinations {
+            search(index, *destination, &mut held)?;
+        }
+        close_round(&plan, destinations[0], &mut control, held)?;
+    }
+    emit("done", json!({}));
+    Ok(())
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    match args.first().map(String::as_str) {
+        Some("target") => target(&args[1..]),
+        Some("client") => client(&args[1..]),
+        _ => Err("ports target PORT | ports client [flags] HOST PORT".into()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_plan_reads_its_flags_and_skips_the_flags_of_the_harness() {
+        let args: Vec<String> = ["--rounds", "50", "--close", "client", "--destinations", "2", "10.0.0.2", "6392", "--mode", "idle", "--max-s", "90"]
+            .iter()
+            .map(|each| each.to_string())
+            .collect();
+        let plan = plan_of(&args).expect("a plan");
+        assert_eq!(plan.host, "10.0.0.2");
+        assert_eq!(plan.port, 6392);
+        assert_eq!(plan.rounds, 50);
+        assert_eq!(plan.close, Close::Client);
+        assert_eq!(plan.destinations, 2);
+        assert_eq!(plan.retry_ms, 10);
+        assert!(plan_of(&["--no-such".to_string()]).is_err());
+        assert!(plan_of(&["--close".to_string(), "soon".to_string(), "h".to_string(), "1".to_string()]).is_err());
+    }
+
+    #[test]
+    fn a_range_with_no_free_port_is_refused_with_its_name() {
+        assert_eq!(errno_of(&std::io::Error::from_raw_os_error(libc::EADDRNOTAVAIL)), "EADDRNOTAVAIL");
+    }
+
+    #[test]
+    fn the_control_connection_closes_with_a_reset_and_holds_no_port() {
+        let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).expect("a listener");
+        let stream = TcpStream::connect(listener.local_addr().expect("an address")).expect("a connect");
+        abortive(&stream).expect("SO_LINGER");
+        let mut linger = libc::linger { l_onoff: 0, l_linger: -1 };
+        let mut size = std::mem::size_of::<libc::linger>() as libc::socklen_t;
+        // SAFETY: the buffer is on this stack, passed with its exact size
+        let status = unsafe {
+            libc::getsockopt(
+                stream.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_LINGER,
+                (&mut linger as *mut libc::linger).cast(),
+                &mut size,
+            )
+        };
+        assert_eq!(status, 0);
+        assert_eq!((linger.l_onoff, linger.l_linger), (1, 0));
+    }
+}