//! Bytes from the kernel's routing socket. The kernel is trusted, but what
//! it sends is read with code of ours, and a daemon that dies on an
//! unusual route stops routing.
#![no_main]

use bgp_fib::netlink::{Change, Message, decode, route_request};
use bytes::BytesMut;
use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    let mut rest = data;
    // As the daemon reads: one message after another until one is wrong.
    while !rest.is_empty() {
        let Ok((_, message, used)) = decode(rest) else {
            return;
        };
        assert!(used > 0 && used <= rest.len());
        rest = &rest[used..];
        let _ = format!("{message:?}");
        // A route that was read can be asked for, and what is asked for
        // reads back as itself.
        if let Message::Route { present, route } = message {
            let change = if present {
                Change::Replace
            } else {
                Change::Remove
            };
            let mut out = BytesMut::new();
            route_request(&mut out, 1, change, false, &route);
            let (_, again, _) = decode(&out).expect("what is written can be read");
            assert_eq!(again, Message::Route { present, route });
        }
    }
});