Struct Mib 

pub struct Mib {

    pub itsGnLocalGnAddr: GNAddress,
    pub itsGnLocalGnAddrConfMethod: LocalGnAddrConfMethod,
    pub itsGnProtocolVersion: u8,
    pub itsGnIsMobile: GnIsMobile,
    pub itsGnIfType: GnIfType,
    pub itsGnMinUpdateFrequencyEPV: u16,
    pub itsGnPaiInterval: u8,
    pub itsGnMaxSduSize: u16,
    pub itsGnMaxGeoNetworkingHeaderSize: u16,
    pub itsGnLifetimeLocTE: u16,
    pub itsGnSecurity: GnSecurity,
    pub itsGnSnDecapResultHandling: SnDecapResultHandling,
    pub itsGnLocationServiceMaxRetrans: u8,
    pub itsGnLocationServiceRetransmitTimer: u16,
    pub itsGnLocationServicePacketBufferSize: u16,
    pub itsGnBeaconServiceRetransmitTimer: u16,
    pub itsGnBeaconServiceMaxJitter: u16,
    pub itsGnDefaultHopLimit: u8,
    pub itsGnDPLLength: u8,
    pub itsGnMaxPacketLifetime: u16,
    pub itsGnDefaultPacketLifetime: u8,
    pub itsGnMaxPacketDataRate: u32,
    pub itsGnMaxPacketDataRateEmaBeta: u8,
    pub itsGnMaxGeoAreaSize: u16,
    pub itsGnMinPacketRepetitionInterval: u16,
    pub itsGnNonAreaForwardingAlgorithm: NonAreaForwardingAlgorithm,
    pub itsGnAreaForwardingAlgorithm: AreaForwardingAlgorithm,
    pub itsGnCbfMinTime: u16,
    pub itsGnCbfMaxTime: u16,
    pub itsGnDefaultMaxCommunicationRange: u16,
    pub itsGnBroadcastCBFDefSectorAngle: u8,
    pub itsGnUcForwardingPacketBufferSize: u16,
    pub itsGnBcForwardingPacketBufferSize: u16,
    pub itsGnCbfPacketBufferSize: u16,
    pub itsGnDefaultTrafficClass: u8,
}

Fields

itsGnLocalGnAddr: GNAddress

itsGnLocalGnAddrConfMethod: LocalGnAddrConfMethod

itsGnProtocolVersion: u8

itsGnIsMobile: GnIsMobile

itsGnIfType: GnIfType

itsGnMinUpdateFrequencyEPV: u16

itsGnPaiInterval: u8

itsGnMaxSduSize: u16

itsGnMaxGeoNetworkingHeaderSize: u16

itsGnLifetimeLocTE: u16

itsGnSecurity: GnSecurity

itsGnSnDecapResultHandling: SnDecapResultHandling

itsGnLocationServiceMaxRetrans: u8

itsGnLocationServiceRetransmitTimer: u16

itsGnLocationServicePacketBufferSize: u16

itsGnBeaconServiceRetransmitTimer: u16

itsGnBeaconServiceMaxJitter: u16

itsGnDefaultHopLimit: u8

itsGnDPLLength: u8

itsGnMaxPacketLifetime: u16

itsGnDefaultPacketLifetime: u8

itsGnMaxPacketDataRate: u32

itsGnMaxPacketDataRateEmaBeta: u8

itsGnMaxGeoAreaSize: u16

itsGnMinPacketRepetitionInterval: u16

itsGnNonAreaForwardingAlgorithm: NonAreaForwardingAlgorithm

itsGnAreaForwardingAlgorithm: AreaForwardingAlgorithm

itsGnCbfMinTime: u16

itsGnCbfMaxTime: u16

itsGnDefaultMaxCommunicationRange: u16

itsGnBroadcastCBFDefSectorAngle: u8

itsGnUcForwardingPacketBufferSize: u16

itsGnBcForwardingPacketBufferSize: u16

itsGnCbfPacketBufferSize: u16

itsGnDefaultTrafficClass: u8

Implementations

impl Mib

pub fn new() -> Self

Examples found in repository

examples/bench_cam_tx.rs (line 57)

fn main() {
    let iface = env::args().nth(1).unwrap_or_else(|| "lo".to_string());
    let duration_s = env::args()
        .nth(2)
        .and_then(|s| s.parse::<u64>().ok())
        .unwrap_or(10);

    println!("=== Benchmark: Maximum CAM TX throughput ===");
    println!("Interface : {iface}");
    println!("Duration  : {duration_s} s\n");

    // ── MAC / MIB ─────────────────────────────────────────────────────────────
    let mac = random_mac();
    let mut mib = Mib::new();
    mib.itsGnLocalGnAddr = GNAddress::new(M::GnMulticast, ST::PassengerCar, MID::new(mac));
    mib.itsGnBeaconServiceRetransmitTimer = 0;

    // ── Routers + link layer ──────────────────────────────────────────────────
    let (gn_handle, gn_to_ll_rx, gn_to_btp_rx) = GNRouter::spawn(mib, None, None, None);
    let (btp_handle, btp_to_gn_rx) = BTPRouter::spawn(mib);

    let (ll_to_gn_tx, ll_to_gn_rx) = mpsc::channel::<Vec<u8>>();
    RawLinkLayer::new(ll_to_gn_tx, gn_to_ll_rx, &iface, mac).start();
    wire_routers(
        &gn_handle,
        &btp_handle,
        ll_to_gn_rx,
        gn_to_btp_rx,
        btp_to_gn_rx,
    );

    // Seed GN position vector so packets are accepted downstream.
    let mut epv = LongPositionVector::decode([0u8; 24]);
    epv.update_from_gps(41.552, 2.134, 0.0, 0.0, true);
    gn_handle.update_position_vector(epv);
    thread::sleep(Duration::from_millis(50));

    // ── Coder + template CAM ──────────────────────────────────────────────────
    let station_id = u32::from_be_bytes([mac[2], mac[3], mac[4], mac[5]]);
    let coder = CamCoder::new();
    let template = make_cam(station_id);

    // ── Benchmark loop ────────────────────────────────────────────────────────
    println!("Sending CAMs as fast as possible…\n");
    println!(
        "{:>7}  {:>10}  {:>12}  {:>12}",
        "time(s)", "total_sent", "rate(pkt/s)", "avg_enc(µs)"
    );

    let mut total_sent: u64 = 0;
    let mut total_enc_us: u128 = 0;
    let bench_start = Instant::now();
    let bench_end = bench_start + Duration::from_secs(duration_s);
    let mut win_start = Instant::now();
    let mut win_sent: u64 = 0;

    while Instant::now() < bench_end {
        let t0 = Instant::now();
        let data = match coder.encode(&template) {
            Ok(d) => d,
            Err(e) => {
                eprintln!("[TX] Encode error: {e}");
                continue;
            }
        };
        let enc_us = t0.elapsed().as_micros();

        btp_handle.send_btp_data_request(cam_btp_request(data));

        total_sent += 1;
        total_enc_us += enc_us;
        win_sent += 1;

        let win_elapsed = win_start.elapsed();
        if win_elapsed >= Duration::from_secs(1) {
            let pps = win_sent as f64 / win_elapsed.as_secs_f64();
            let avg_enc = total_enc_us / total_sent.max(1) as u128;
            println!(
                "{:>7.1}  {:>10}  {:>12.1}  {:>12}",
                bench_start.elapsed().as_secs_f64(),
                total_sent,
                pps,
                avg_enc
            );
            win_start = Instant::now();
            win_sent = 0;
        }
    }

    // ── Summary ───────────────────────────────────────────────────────────────
    let elapsed = bench_start.elapsed().as_secs_f64();
    let avg_rate = total_sent as f64 / elapsed;
    let avg_encode = total_enc_us / total_sent.max(1) as u128;

    println!();
    println!("=== CAM TX Results ===");
    println!("  Total sent      : {total_sent}");
    println!("  Elapsed         : {elapsed:.3} s");
    println!("  Average rate    : {avg_rate:.1} pkt/s");
    println!("  Avg encode time : {avg_encode} µs");
}

examples/bench_cam_rx.rs (line 46)

fn main() {
    let iface = env::args().nth(1).unwrap_or_else(|| "lo".to_string());
    let duration_s = env::args()
        .nth(2)
        .and_then(|s| s.parse::<u64>().ok())
        .unwrap_or(30);

    println!("=== Benchmark: Maximum CAM RX throughput ===");
    println!("Interface : {iface}");
    println!("Duration  : {duration_s} s\n");

    // ── MAC / MIB ─────────────────────────────────────────────────────────────
    let mac = random_mac();
    let mut mib = Mib::new();
    mib.itsGnLocalGnAddr = GNAddress::new(M::GnMulticast, ST::PassengerCar, MID::new(mac));
    mib.itsGnBeaconServiceRetransmitTimer = 0;

    // ── Routers + link layer ──────────────────────────────────────────────────
    let (gn_handle, gn_to_ll_rx, gn_to_btp_rx) = GNRouter::spawn(mib, None, None, None);
    let (btp_handle, btp_to_gn_rx) = BTPRouter::spawn(mib);

    let (ll_to_gn_tx, ll_to_gn_rx) = mpsc::channel::<Vec<u8>>();
    RawLinkLayer::new(ll_to_gn_tx, gn_to_ll_rx, &iface, mac).start();
    wire_routers(
        &gn_handle,
        &btp_handle,
        ll_to_gn_rx,
        gn_to_btp_rx,
        btp_to_gn_rx,
    );

    // Seed position vector.
    let mut epv = LongPositionVector::decode([0u8; 24]);
    epv.update_from_gps(41.552, 2.134, 0.0, 0.0, true);
    gn_handle.update_position_vector(epv);
    thread::sleep(Duration::from_millis(50));

    // ── Register on BTP port 2001 ─────────────────────────────────────────────
    let (ind_tx, ind_rx) = mpsc::channel::<BTPDataIndication>();
    btp_handle.register_port(2001, ind_tx);

    // ── Benchmark loop ────────────────────────────────────────────────────────
    println!("Waiting for CAMs on port 2001…\n");
    println!(
        "{:>7}  {:>10}  {:>12}  {:>12}  {:>10}",
        "time(s)", "total_recv", "rate(pkt/s)", "avg_dec(µs)", "errors"
    );

    let coder = CamCoder::new();
    let mut total_recv: u64 = 0;
    let mut total_errors: u64 = 0;
    let mut total_dec_us: u128 = 0;
    let bench_start = Instant::now();
    let bench_end = bench_start + Duration::from_secs(duration_s);
    let mut win_start = Instant::now();
    let mut win_recv: u64 = 0;

    loop {
        let now = Instant::now();
        if now >= bench_end {
            break;
        }

        let timeout = (bench_end - now).min(Duration::from_millis(500));
        match ind_rx.recv_timeout(timeout) {
            Ok(ind) => {
                let t0 = Instant::now();
                match coder.decode(&ind.data) {
                    Ok(_) => {}
                    Err(e) => {
                        total_errors += 1;
                        eprintln!("[RX] Decode error: {e}");
                    }
                }
                let dec_us = t0.elapsed().as_micros();
                total_recv += 1;
                total_dec_us += dec_us;
                win_recv += 1;
            }
            Err(mpsc::RecvTimeoutError::Timeout) => {}
            Err(mpsc::RecvTimeoutError::Disconnected) => break,
        }

        let win_elapsed = win_start.elapsed();
        if win_elapsed >= Duration::from_secs(1) {
            let pps = win_recv as f64 / win_elapsed.as_secs_f64();
            let avg_dec = if total_recv > 0 {
                total_dec_us / total_recv as u128
            } else {
                0
            };
            println!(
                "{:>7.1}  {:>10}  {:>12.1}  {:>12}  {:>10}",
                bench_start.elapsed().as_secs_f64(),
                total_recv,
                pps,
                avg_dec,
                total_errors
            );
            win_start = Instant::now();
            win_recv = 0;
        }
    }

    // ── Summary ───────────────────────────────────────────────────────────────
    let elapsed = bench_start.elapsed().as_secs_f64();
    let avg_rate = total_recv as f64 / elapsed;
    let avg_decode = if total_recv > 0 {
        total_dec_us / total_recv as u128
    } else {
        0
    };

    println!();
    println!("=== CAM RX Results ===");
    println!("  Total received  : {total_recv}");
    println!("  Decode errors   : {total_errors}");
    println!("  Elapsed         : {elapsed:.3} s");
    println!("  Average rate    : {avg_rate:.1} pkt/s");
    println!("  Avg decode time : {avg_decode} µs");
}

examples/vam_sender_receiver.rs (line 72)

fn main() {
    // ── Parse optional interface argument ─────────────────────────────────────
    let iface = env::args().nth(1).unwrap_or_else(|| "lo".to_string());

    println!("=== VAM Sender/Receiver Example (VRU Awareness Service) ===");
    println!("Interface: {}", iface);

    // ── Generate a random locally-administered MAC ────────────────────────────
    let mac = {
        use std::time::{SystemTime, UNIX_EPOCH};
        let seed = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .subsec_nanos();
        [
            0x02u8,
            (seed >> 24) as u8,
            (seed >> 16) as u8,
            (seed >> 8) as u8,
            seed as u8,
            0xBB,
        ]
    };
    println!(
        "MAC: {:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
    );

    // ── MIB ───────────────────────────────────────────────────────────────────
    let mut mib = Mib::new();
    mib.itsGnLocalGnAddr = GNAddress::new(M::GnMulticast, ST::Cyclist, MID::new(mac));
    mib.itsGnBeaconServiceRetransmitTimer = 0;

    // ── Location Service ──────────────────────────────────────────────────────
    //
    // A single LocationService publishes GPS fixes to multiple subscribers.
    // We subscribe twice: once for the GN router's position vector, and once
    // for the VRU Awareness Service VAM generation.
    let mut loc_svc = LocationService::new();
    let gn_gps_rx = loc_svc.subscribe(); // → GN position vector updates
    let vru_gps_rx = loc_svc.subscribe(); // → VAM transmission

    // ── Spawn GeoNetworking router ────────────────────────────────────────────
    let (gn_handle, gn_to_ll_rx, gn_to_btp_rx) = GNRouter::spawn(mib, None, None, None);

    // ── Spawn BTP router ──────────────────────────────────────────────────────
    let (btp_handle, btp_to_gn_rx) = BTPRouter::spawn(mib);

    // ── Wire RawLinkLayer ─────────────────────────────────────────────────────
    let (ll_to_gn_tx, ll_to_gn_rx) = mpsc::channel::<Vec<u8>>();
    let raw_ll = RawLinkLayer::new(ll_to_gn_tx, gn_to_ll_rx, &iface, mac);
    raw_ll.start();

    // ── Wire threads ──────────────────────────────────────────────────────────

    // LL → GN
    let gn_h1 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(pkt) = ll_to_gn_rx.recv() {
            gn_h1.send_incoming_packet(pkt);
        }
    });

    // GN → BTP
    let btp_h1 = btp_handle.clone();
    thread::spawn(move || {
        while let Ok(ind) = gn_to_btp_rx.recv() {
            btp_h1.send_gn_data_indication(ind);
        }
    });

    // BTP → GN
    let gn_h2 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(req) = btp_to_gn_rx.recv() {
            gn_h2.send_gn_data_request(req);
        }
    });

    // ── Bridge: LocationService → GN router position vector ───────────────────
    //
    // Converts each GpsFix into a LongPositionVector and pushes it into the
    // GeoNetworking router so the EPV in every outgoing GN header is current.
    let gn_h3 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(fix) = gn_gps_rx.recv() {
            let mut epv = LongPositionVector::decode([0u8; 24]);
            epv.update_from_gps(
                fix.latitude,
                fix.longitude,
                fix.speed_mps,
                fix.heading_deg,
                fix.pai,
            );
            gn_h3.update_position_vector(epv);
        }
    });

    // ── VRU Awareness Service ─────────────────────────────────────────────────
    //
    // DeviceData carries static VRU metadata that goes into every VAM.
    // station_id is derived from the MAC bytes; station_type 2 = cyclist.
    let station_id = u32::from_be_bytes([mac[2], mac[3], mac[4], mac[5]]);
    let device_data = DeviceData {
        station_id,
        station_type: 2, // cyclist
    };

    // VruAwarenessService::new returns the service handle plus a
    // Receiver<Vam> on which decoded incoming VAMs arrive.
    let (vru_svc, vam_rx) = VruAwarenessService::new(btp_handle.clone(), device_data);

    // start() consumes the service handle and spawns the TX + RX threads.
    vru_svc.start(vru_gps_rx);

    // ── Decoded VAM printer ───────────────────────────────────────────────────
    thread::spawn(move || {
        while let Ok(vam) = vam_rx.recv() {
            let lat = vam
                .vam
                .vam_parameters
                .basic_container
                .reference_position
                .latitude
                .0 as f64
                / 1e7;
            let lon = vam
                .vam
                .vam_parameters
                .basic_container
                .reference_position
                .longitude
                .0 as f64
                / 1e7;
            println!(
                "[VAM RX] station={:>10}  lat={:.5}  lon={:.5}",
                vam.header.0.station_id.0, lat, lon,
            );
        }
    });

    // ── GPS publisher (simulates a real GNSS sensor at 1 Hz) ──────────────────
    //
    // In a real application this thread would read from gpsd or a serial port.
    // Wait briefly for the routers to finish initialising.
    thread::sleep(Duration::from_millis(100));
    println!("Publishing GPS fixes @ 10 Hz — Ctrl+C to stop\n");

    loop {
        thread::sleep(Duration::from_millis(100));
        // 41.552°N  2.134°E — Parc Tecnològic del Vallès
        loc_svc.publish(GpsFix {
            latitude: 41.552,
            longitude: 2.134,
            altitude_m: 120.0,
            speed_mps: 1.5,
            heading_deg: 90.0,
            pai: true,
        });
    }
}

examples/denm_sender_receiver.rs (line 77)

fn main() {
    // ── Parse optional interface argument ─────────────────────────────────────
    let iface = env::args().nth(1).unwrap_or_else(|| "lo".to_string());

    println!("=== DENM Sender/Receiver Example (DEN Service) ===");
    println!("Interface: {}", iface);

    // ── Generate a random locally-administered MAC ────────────────────────────
    let mac = {
        use std::time::{SystemTime, UNIX_EPOCH};
        let seed = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .subsec_nanos();
        [
            0x02u8,
            (seed >> 24) as u8,
            (seed >> 16) as u8,
            (seed >> 8) as u8,
            seed as u8,
            0xCC,
        ]
    };
    println!(
        "MAC: {:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
    );

    // ── MIB ───────────────────────────────────────────────────────────────────
    let mut mib = Mib::new();
    mib.itsGnLocalGnAddr = GNAddress::new(M::GnMulticast, ST::PassengerCar, MID::new(mac));
    mib.itsGnBeaconServiceRetransmitTimer = 0;

    // ── Location Service ──────────────────────────────────────────────────────
    //
    // A single LocationService publishes GPS fixes.  We subscribe once for the
    // GN router's position vector updates.
    let mut loc_svc = LocationService::new();
    let gn_gps_rx = loc_svc.subscribe();

    // ── Spawn GeoNetworking router ────────────────────────────────────────────
    let (gn_handle, gn_to_ll_rx, gn_to_btp_rx) = GNRouter::spawn(mib, None, None, None);

    // ── Spawn BTP router ──────────────────────────────────────────────────────
    let (btp_handle, btp_to_gn_rx) = BTPRouter::spawn(mib);

    // ── Wire RawLinkLayer ─────────────────────────────────────────────────────
    let (ll_to_gn_tx, ll_to_gn_rx) = mpsc::channel::<Vec<u8>>();
    let raw_ll = RawLinkLayer::new(ll_to_gn_tx, gn_to_ll_rx, &iface, mac);
    raw_ll.start();

    // ── Wire threads ──────────────────────────────────────────────────────────

    // LL → GN
    let gn_h1 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(pkt) = ll_to_gn_rx.recv() {
            gn_h1.send_incoming_packet(pkt);
        }
    });

    // GN → BTP
    let btp_h1 = btp_handle.clone();
    thread::spawn(move || {
        while let Ok(ind) = gn_to_btp_rx.recv() {
            btp_h1.send_gn_data_indication(ind);
        }
    });

    // BTP → GN
    let gn_h2 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(req) = btp_to_gn_rx.recv() {
            gn_h2.send_gn_data_request(req);
        }
    });

    // ── Bridge: LocationService → GN router position vector ───────────────────
    let gn_h3 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(fix) = gn_gps_rx.recv() {
            let mut epv = LongPositionVector::decode([0u8; 24]);
            epv.update_from_gps(
                fix.latitude,
                fix.longitude,
                fix.speed_mps,
                fix.heading_deg,
                fix.pai,
            );
            gn_h3.update_position_vector(epv);
        }
    });

    // ── DEN Service ───────────────────────────────────────────────────────────
    let station_id = u32::from_be_bytes([mac[2], mac[3], mac[4], mac[5]]);
    let vehicle_data = VehicleData {
        station_id,
        station_type: 5, // passengerCar
    };

    // DecentralizedEnvironmentalNotificationService::new returns the service
    // handle plus a Receiver<Denm> on which decoded incoming DENMs arrive.
    // The reception thread is started immediately (registers BTP port 2002).
    let (den_svc, denm_rx) =
        DecentralizedEnvironmentalNotificationService::new(btp_handle.clone(), vehicle_data);

    // ── Decoded DENM printer ──────────────────────────────────────────────────
    thread::spawn(move || {
        while let Ok(denm) = denm_rx.recv() {
            let lat = denm.denm.management.event_position.latitude.0 as f64 / 1e7;
            let lon = denm.denm.management.event_position.longitude.0 as f64 / 1e7;
            let seq = denm.denm.management.action_id.sequence_number.0;
            println!(
                "[DENM RX] station={:>10}  seq={:>5}  event_lat={:.5}  event_lon={:.5}",
                denm.header.station_id.0, seq, lat, lon,
            );
        }
    });

    // ── Publish initial GPS fix to initialise the GN router ───────────────────
    thread::sleep(Duration::from_millis(100));

    // Publish position fixes to keep the GN position vector up to date.
    let gps_fix = GpsFix {
        latitude: 41.552,
        longitude: 2.134,
        altitude_m: 120.0,
        speed_mps: 14.0, // ~50 km/h
        heading_deg: 90.0,
        pai: true,
    };
    loc_svc.publish(gps_fix);

    // ── Trigger DENM: Road Hazard (accident) at current position ──────────────
    //
    // Send 1 DENM/s for 30 s, 1 000 m geo-broadcast circle.
    println!("Triggering road-hazard DENM (accident) for 30 s @ 1 Hz");
    den_svc.trigger_denm(DENRequest {
        event_latitude: gps_fix.latitude,
        event_longitude: gps_fix.longitude,
        event_altitude_m: gps_fix.altitude_m,
        cause_code: CauseCodeChoice::accident2(AccidentSubCauseCode(0)),
        information_quality: 4,
        event_speed_raw: (gps_fix.speed_mps * 100.0) as u16,
        event_heading_raw: (gps_fix.heading_deg * 10.0) as u16,
        denm_interval_ms: 1_000,
        time_period_ms: 30_000,
        relevance_radius_m: 1_000,
    });

    // ── GPS publisher loop ────────────────────────────────────────────────────
    println!("Publishing GPS fixes @ 1 Hz — Ctrl+C to stop\n");
    loop {
        thread::sleep(Duration::from_secs(1));
        loc_svc.publish(gps_fix);
    }
}

examples/cam_sender_receiver.rs (line 76)

fn main() {
    // ── Parse optional interface argument ────────────────────────────────────
    let iface = env::args().nth(1).unwrap_or_else(|| "lo".to_string());

    println!("=== CAM Sender/Receiver Example (CA Basic Service) ===");
    println!("Interface: {}", iface);

    // ── Generate a random locally-administered MAC ────────────────────────
    let mac = {
        use std::time::{SystemTime, UNIX_EPOCH};
        let seed = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .subsec_nanos();
        [
            0x02u8,
            (seed >> 24) as u8,
            (seed >> 16) as u8,
            (seed >> 8) as u8,
            seed as u8,
            0xAA,
        ]
    };
    println!(
        "MAC: {:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
    );

    // ── MIB ──────────────────────────────────────────────────────────────────
    let mut mib = Mib::new();
    mib.itsGnLocalGnAddr = GNAddress::new(M::GnMulticast, ST::PassengerCar, MID::new(mac));
    mib.itsGnBeaconServiceRetransmitTimer = 0;

    // ── Location Service ─────────────────────────────────────────────────────
    //
    // A single LocationService publishes GPS fixes to multiple subscribers.
    // We subscribe twice: once for the GN router's position vector, and once
    // for the CA Basic Service CAM generation.
    let mut loc_svc = LocationService::new();
    let gn_gps_rx = loc_svc.subscribe(); // → GN position vector updates
    let ca_gps_rx = loc_svc.subscribe(); // → CAM transmission

    // ── Spawn GeoNetworking router ────────────────────────────────────────────
    let (gn_handle, gn_to_ll_rx, gn_to_btp_rx) = GNRouter::spawn(mib, None, None, None);

    // ── Spawn BTP router ─────────────────────────────────────────────────────
    let (btp_handle, btp_to_gn_rx) = BTPRouter::spawn(mib);

    // ── Wire RawLinkLayer ────────────────────────────────────────────────────
    let (ll_to_gn_tx, ll_to_gn_rx) = mpsc::channel::<Vec<u8>>();
    let raw_ll = RawLinkLayer::new(ll_to_gn_tx, gn_to_ll_rx, &iface, mac);
    raw_ll.start();

    // ── Wire threads ─────────────────────────────────────────────────────────

    // LL → GN
    let gn_h1 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(pkt) = ll_to_gn_rx.recv() {
            gn_h1.send_incoming_packet(pkt);
        }
    });

    // GN → BTP
    let btp_h1 = btp_handle.clone();
    thread::spawn(move || {
        while let Ok(ind) = gn_to_btp_rx.recv() {
            btp_h1.send_gn_data_indication(ind);
        }
    });

    // BTP → GN
    let gn_h2 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(req) = btp_to_gn_rx.recv() {
            gn_h2.send_gn_data_request(req);
        }
    });

    // ── Bridge: LocationService → GN router position vector ──────────────────
    //
    // Converts each GpsFix into a LongPositionVector and pushes it into the
    // GeoNetworking router so the EPV in every outgoing GN header is current.
    let gn_h3 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(fix) = gn_gps_rx.recv() {
            let mut epv = LongPositionVector::decode([0u8; 24]);
            epv.update_from_gps(
                fix.latitude,
                fix.longitude,
                fix.speed_mps,
                fix.heading_deg,
                fix.pai,
            );
            gn_h3.update_position_vector(epv);
        }
    });

    // ── Local Dynamic Map ─────────────────────────────────────────────────────
    //
    // Create the LDM centred on the simulated GPS position with a 5 km radius.
    // Parc Tecnològic del Vallès: 41.552°N 2.134°E → ETSI integers × 1e7.
    let ldm = LdmFacility::new(415_520_000, 21_340_000, 5_000.0);

    // Register this node as a CAM data provider and consumer.
    ldm.if_ldm_3
        .register_data_provider(RegisterDataProviderReq {
            application_id: ITS_AID_CAM,
        });
    ldm.if_ldm_4
        .register_data_consumer(RegisterDataConsumerReq {
            application_id: ITS_AID_CAM,
        });

    // ── CA Basic Service ─────────────────────────────────────────────────────
    //
    // VehicleData carries static vehicle metadata that goes into every CAM.
    // station_id should match the GN address mid bytes in a real deployment.
    let station_id = u32::from_be_bytes([mac[2], mac[3], mac[4], mac[5]]);
    let vehicle_data = VehicleData {
        station_id,
        ..VehicleData::default() // PassengerCar, unavailable lengths
    };

    // Pass Some(ldm) so every received CAM is stored in the LDM before being
    // forwarded.  The _cam_rx channel is still available for direct consumers
    // but in this example we read via IF.LDM.4 instead.
    let (ca_svc, _cam_rx) =
        CooperativeAwarenessBasicService::new(btp_handle.clone(), vehicle_data, Some(ldm.clone()));

    // start() consumes the service handle and spawns the TX + RX threads.
    ca_svc.start(ca_gps_rx);

    // ── LDM query printer ─────────────────────────────────────────────────────
    //
    // Every second, query the LDM for all CAM records and print them.
    // This uses the ETSI IF.LDM.4 interface and confirms that received CAMs
    // are correctly stored and retrievable.
    let ldm_reader = ldm.clone();
    thread::spawn(move || loop {
        thread::sleep(Duration::from_secs(1));
        let resp = ldm_reader
            .if_ldm_4
            .request_data_objects(RequestDataObjectsReq {
                application_id: ITS_AID_CAM,
                data_object_types: vec![ITS_AID_CAM],
                filter: None,
                order: None,
                max_results: None,
            });
        if resp.data_objects.is_empty() {
            println!("[LDM] No CAM records in store");
        } else {
            println!("[LDM] {} CAM record(s):", resp.data_objects.len());
            for entry in &resp.data_objects {
                if let ItsDataObject::Cam(cam) = &entry.data_object {
                    let lat = cam
                        .cam
                        .cam_parameters
                        .basic_container
                        .reference_position
                        .latitude
                        .0 as f64
                        / 1e7;
                    let lon = cam
                        .cam
                        .cam_parameters
                        .basic_container
                        .reference_position
                        .longitude
                        .0 as f64
                        / 1e7;
                    println!(
                        "  [LDM CAM] record={:>5} station={:>10}  lat={:.5}  lon={:.5}",
                        entry.record_id, cam.header.station_id.0, lat, lon,
                    );
                }
            }
        }
    });

    // ── GPS publisher (simulates a real GNSS sensor at 1 Hz) ─────────────────
    //
    // In a real application this thread would read from gpsd or a serial port.
    // Wait briefly for the routers to finish initialising.
    thread::sleep(Duration::from_millis(100));
    println!("Publishing GPS fixes @ 10 Hz — Ctrl+C to stop\n");

    loop {
        thread::sleep(Duration::from_millis(100));
        // 41.552°N  2.134°E — Parc Tecnològic del Vallès
        loc_svc.publish(GpsFix {
            latitude: 41.552,
            longitude: 2.134,
            altitude_m: 120.0,
            speed_mps: 0.0,
            heading_deg: 0.0,
            pai: true,
        });
    }
}

examples/secured_vam_sender_receiver.rs (line 186)

fn main() {
    // ── Parse arguments ──────────────────────────────────────────────────
    let args: Vec<String> = env::args().collect();
    let mut at_index: usize = 1;
    let mut iface = "lo".to_string();

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--at" => {
                i += 1;
                at_index = args[i].parse::<usize>().expect("--at must be 1 or 2");
                assert!(at_index == 1 || at_index == 2, "--at must be 1 or 2");
            }
            "--iface" | "-i" => {
                i += 1;
                iface = args[i].clone();
            }
            other => {
                // Positional argument: interface name
                iface = other.to_string();
            }
        }
        i += 1;
    }

    println!("=== Secured VAM Sender/Receiver (VRU Awareness Service) ===");
    println!("AT index: {}", at_index);
    println!("Interface: {}", iface);

    // ── Build security stack ─────────────────────────────────────────────
    let sign_service = build_security_stack(at_index);
    println!(
        "Security stack loaded. Own AT HashedId8: {:02x?}",
        sign_service
            .cert_library
            .own_certificates
            .keys()
            .next()
            .unwrap()
    );

    // Wrap in Arc<Mutex> so it can be shared between threads
    let sign_service = Arc::new(Mutex::new(sign_service));

    // ── Generate a random locally-administered MAC ───────────────────────
    let mac = {
        use std::time::{SystemTime, UNIX_EPOCH};
        let seed = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .subsec_nanos()
            ^ (at_index as u32 * 0x1234_5678); // different seed per AT
        [
            0x02u8,
            (seed >> 24) as u8,
            (seed >> 16) as u8,
            (seed >> 8) as u8,
            seed as u8,
            at_index as u8,
        ]
    };
    println!(
        "MAC: {:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
    );

    // ── MIB ──────────────────────────────────────────────────────────────
    let mut mib = Mib::new();
    mib.itsGnLocalGnAddr = GNAddress::new(M::GnMulticast, ST::Cyclist, MID::new(mac));
    mib.itsGnBeaconServiceRetransmitTimer = 0;

    // ── Location Service ─────────────────────────────────────────────────
    let mut loc_svc = LocationService::new();
    let gn_gps_rx = loc_svc.subscribe();
    let vru_gps_rx = loc_svc.subscribe();

    // ── Spawn GN router and BTP router ───────────────────────────────────
    let (gn_handle, gn_to_ll_rx, gn_to_btp_rx) = GNRouter::spawn(mib, None, None, None);
    let (btp_handle, btp_to_gn_rx) = BTPRouter::spawn(mib);

    // ── Wire RawLinkLayer ────────────────────────────────────────────────
    let (ll_to_gn_tx, ll_to_gn_rx) = mpsc::channel::<Vec<u8>>();

    // ── Security middleware: TX path ─────────────────────────────────────
    //
    // Intercept packets from GN router → link layer.
    // Sign the payload (CommonHeader + extended header + data) and wrap
    // in a secured GN packet with BasicNH::SecuredPacket.
    let (secured_ll_tx, secured_ll_rx) = mpsc::channel::<Vec<u8>>();
    let sign_svc_tx = Arc::clone(&sign_service);
    thread::spawn(move || {
        while let Ok(packet) = gn_to_ll_rx.recv() {
            if packet.len() < 4 {
                let _ = secured_ll_tx.send(packet);
                continue;
            }
            let bh_bytes: [u8; 4] = packet[0..4].try_into().unwrap();
            let bh = BasicHeader::decode(bh_bytes);

            match bh.nh {
                BasicNH::CommonHeader if packet.len() > 4 => {
                    let inner_payload = &packet[4..];

                    let request = SNSignRequest {
                        tbs_message: inner_payload.to_vec(),
                        its_aid: ITS_AID_VAM,
                        permissions: vec![],
                        generation_location: None,
                    };

                    let sec_message = {
                        let mut svc = sign_svc_tx.lock().unwrap();
                        svc.sign_request(&request).sec_message
                    };

                    // Build new packet: BasicHeader(nh=SecuredPacket) + sec_message
                    let mut new_bh = bh;
                    new_bh.nh = BasicNH::SecuredPacket;
                    let secured_packet: Vec<u8> = new_bh
                        .encode()
                        .iter()
                        .copied()
                        .chain(sec_message.iter().copied())
                        .collect();
                    let _ = secured_ll_tx.send(secured_packet);
                }
                _ => {
                    // Pass through (e.g. beacons)
                    let _ = secured_ll_tx.send(packet);
                }
            }
        }
    });

    // The link layer reads from secured_ll_rx (post-signing)
    let raw_ll = RawLinkLayer::new(ll_to_gn_tx, secured_ll_rx, &iface, mac);
    raw_ll.start();

    // ── Security middleware: RX path ─────────────────────────────────────
    //
    // Intercept packets from link layer → GN router.
    // If BasicNH::SecuredPacket, verify and extract, then forward
    // with BasicNH::CommonHeader.
    let gn_h_rx = gn_handle.clone();
    let sign_svc_rx = Arc::clone(&sign_service);
    thread::spawn(move || {
        while let Ok(packet) = ll_to_gn_rx.recv() {
            if packet.len() < 4 {
                gn_h_rx.send_incoming_packet(packet);
                continue;
            }
            let bh_bytes: [u8; 4] = packet[0..4].try_into().unwrap();
            let bh = BasicHeader::decode(bh_bytes);

            match bh.nh {
                BasicNH::SecuredPacket if packet.len() > 4 => {
                    let sec_message = &packet[4..];
                    let request = SNVerifyRequest {
                        message: sec_message.to_vec(),
                    };

                    let (confirm, _events) = {
                        let mut svc = sign_svc_rx.lock().unwrap();
                        let svc = &mut *svc;
                        let result = verify_message(&request, &svc.backend, &mut svc.cert_library);
                        // Process VerifyEvents for P2PCD
                        for event in &result.1 {
                            match event {
                                VerifyEvent::UnknownAt(h8) => {
                                    svc.notify_unknown_at(h8);
                                }
                                VerifyEvent::InlineP2pcdRequest(h3s) => {
                                    svc.notify_inline_p2pcd_request(h3s);
                                }
                                VerifyEvent::ReceivedCaCertificate(cert) => {
                                    svc.notify_received_ca_certificate(cert.as_ref().clone());
                                }
                            }
                        }
                        result
                    };

                    if confirm.report == ReportVerify::Success {
                        println!(
                            "[SEC RX] Verified OK — ITS-AID={}, cert={:02x?}",
                            confirm.its_aid,
                            &confirm.certificate_id[..],
                        );
                        // Rebuild the packet: BasicHeader(nh=CommonHeader) + plain_message
                        let mut new_bh = bh;
                        new_bh.nh = BasicNH::CommonHeader;
                        let plain_packet: Vec<u8> = new_bh
                            .encode()
                            .iter()
                            .copied()
                            .chain(confirm.plain_message.iter().copied())
                            .collect();
                        gn_h_rx.send_incoming_packet(plain_packet);
                    } else {
                        eprintln!("[SEC RX] Verification failed: {:?}", confirm.report);
                    }
                }
                _ => {
                    // Non-secured packet — forward directly
                    gn_h_rx.send_incoming_packet(packet);
                }
            }
        }
    });

    // ── GN → BTP ─────────────────────────────────────────────────────────
    let btp_h1 = btp_handle.clone();
    thread::spawn(move || {
        while let Ok(ind) = gn_to_btp_rx.recv() {
            btp_h1.send_gn_data_indication(ind);
        }
    });

    // ── BTP → GN ─────────────────────────────────────────────────────────
    let gn_h2 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(req) = btp_to_gn_rx.recv() {
            gn_h2.send_gn_data_request(req);
        }
    });

    // ── LocationService → GN position vector ─────────────────────────────
    let gn_h3 = gn_handle.clone();
    thread::spawn(move || {
        while let Ok(fix) = gn_gps_rx.recv() {
            let mut epv = LongPositionVector::decode([0u8; 24]);
            epv.update_from_gps(
                fix.latitude,
                fix.longitude,
                fix.speed_mps,
                fix.heading_deg,
                fix.pai,
            );
            gn_h3.update_position_vector(epv);
        }
    });

    // ── VRU Awareness Service ────────────────────────────────────────────
    let station_id = u32::from_be_bytes([mac[2], mac[3], mac[4], mac[5]]);
    let device_data = DeviceData {
        station_id,
        station_type: 2, // cyclist
    };

    let (vru_svc, vam_rx) = VruAwarenessService::new(btp_handle.clone(), device_data);
    vru_svc.start(vru_gps_rx);

    // ── Decoded VAM printer ──────────────────────────────────────────────
    thread::spawn(move || {
        while let Ok(vam) = vam_rx.recv() {
            let lat = vam
                .vam
                .vam_parameters
                .basic_container
                .reference_position
                .latitude
                .0 as f64
                / 1e7;
            let lon = vam
                .vam
                .vam_parameters
                .basic_container
                .reference_position
                .longitude
                .0 as f64
                / 1e7;
            println!(
                "[VAM RX] station={:>10}  lat={:.5}  lon={:.5}",
                vam.header.0.station_id.0, lat, lon,
            );
        }
    });

    // ── GPS publisher (simulates a VRU GNSS sensor at 10 Hz) ─────────────
    thread::sleep(Duration::from_millis(100));
    println!("Publishing GPS fixes @ 10 Hz — Ctrl+C to stop\n");

    loop {
        thread::sleep(Duration::from_millis(100));
        // 41.552°N  2.134°E — Parc Tecnològic del Vallès
        loc_svc.publish(GpsFix {
            latitude: 41.552,
            longitude: 2.134,
            altitude_m: 120.0,
            speed_mps: 1.5,
            heading_deg: 90.0,
            pai: true,
        });
    }
}

Additional examples can be found in:

• examples/bench_congestion.rs
• examples/secured_cam_sender_receiver.rs

Trait Implementations

impl Clone for Mib

fn clone(&self) -> Mib

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Mib

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Mib

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Mib

fn eq(&self, other: &Mib) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Mib

impl StructuralPartialEq for Mib