simulcrypt 0.2.2

DVB SimulCrypt (ETSI TS 103 197) head-end protocol: ECMG client, EMMG server, control words
Documentation
use std::{
    sync::{
        Arc,
        atomic::{
            AtomicU64,
            Ordering,
        },
    },
    time::Duration,
};

use simulcrypt::{
    CasConfig,
    EcmgConfig,
    Event,
    ServiceCas,
    ServiceConfig,
    Simulcrypt,
};

fn env_or(name: &str, default: &str) -> String {
    std::env::var(name).unwrap_or_else(|_| default.to_string())
}

fn env_parse<T: std::str::FromStr>(name: &str, default: T) -> T {
    std::env::var(name)
        .ok()
        .and_then(|value| value.parse().ok())
        .unwrap_or(default)
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    let host: std::net::IpAddr = env_parse("ECMG_HOST", [127, 0, 0, 1].into());
    let port: u16 = env_parse("ECMG_PORT", 2222);
    let channel_id: u16 = env_parse("ECMG_CHANNEL_ID", 1);
    let super_cas_id =
        u32::from_str_radix(&env_or("SUPER_CAS_ID", "0b000001"), 16).expect("invalid SUPER_CAS_ID");
    let crypto_period_secs: u64 = env_parse("CRYPTO_PERIOD_SECS", 10);

    let simulcrypt = Simulcrypt::new();

    let lease = simulcrypt
        .acquire_cas(CasConfig {
            id: "cas-1".into(),
            name: "monitored-cas".into(),
            super_cas_id,
            first_stream_id: 0,
            ecmg: EcmgConfig::new(channel_id, std::net::SocketAddr::new(host, port)),
            emmg: None,
        })
        .expect("acquire_cas failed");

    let mut service = simulcrypt
        .open_service(&ServiceConfig {
            name: "monitor-demo".into(),
            crypto_period: Duration::from_secs(crypto_period_secs),
            cas: vec![ServiceCas {
                cas: lease.cas(),
                ecm_pid: 100,
                access_criteria: vec![],
            }],
        })
        .expect("open_service failed");

    // Service events are not inspected in detail - the monitor only cares that they arrive and
    // about `Simulcrypt::status()`, which reflects the ECMG connection state.
    let ecm_count = Arc::new(AtomicU64::new(0));
    let counter = Arc::clone(&ecm_count);
    tokio::spawn(async move {
        while let Some(event) = service.recv().await {
            if matches!(event, Event::Ecm { .. }) {
                counter.fetch_add(1, Ordering::Relaxed);
            }
        }
    });

    let mut interval = tokio::time::interval(Duration::from_secs(2));
    loop {
        interval.tick().await;

        println!("--- status ---");
        for status in simulcrypt.status() {
            println!(
                "{:?} name={} state={:?}",
                status.cas, status.name, status.state
            );
        }
        println!("ecm received so far: {}", ecm_count.load(Ordering::Relaxed));
    }
}