simulcrypt 0.2.2

DVB SimulCrypt (ETSI TS 103 197) head-end protocol: ECMG client, EMMG server, control words
Documentation
use std::{
    fmt::Write as _,
    time::Duration,
};

use simulcrypt::{
    CasConfig,
    EcmgConfig,
    EmmgConfig,
    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)
}

fn hex(bytes: &[u8]) -> String {
    bytes.iter().fold(String::new(), |mut out, byte| {
        let _ = write!(out, "{byte:02x}");
        out
    })
}

#[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 ecm_pid: u16 = env_parse("ECM_PID", 100);
    let crypto_period_secs: u64 = env_parse("CRYPTO_PERIOD_SECS", 10);
    let emmg_port: Option<u16> = std::env::var("EMMG_PORT")
        .ok()
        .and_then(|value| value.parse().ok());

    let simulcrypt = Simulcrypt::new();

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

    tracing::info!(
        "connecting to ECMG {}:{} channel_id={} (EMMG port: {:?})",
        host,
        port,
        channel_id,
        emmg_port
    );

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

    tracing::info!(
        "service opened, stream_id={}",
        service.streams()[0].stream_id
    );

    while let Some(event) = service.recv().await {
        match event {
            Event::State { cas, state } => {
                tracing::info!("CAS {:?} state changed: {:?}", cas, state);
            }
            Event::Cw {
                cp_number,
                parity,
                cw,
            } => {
                println!("Cw  cp={cp_number} parity={parity:?} cw={}", hex(&cw));
            }
            Event::Ecm {
                cas,
                stream_id,
                cp_number,
                format,
                data,
            } => {
                println!(
                    "Ecm cas={cas:?} stream_id={stream_id} cp={cp_number:?} format={format:?} len={}",
                    data.len()
                );
            }
            Event::Emm {
                cas,
                stream_id,
                data_id,
                data_type,
                format,
                data,
            } => {
                println!(
                    "Emm cas={cas:?} stream_id={stream_id} data_id={data_id} data_type={data_type} format={format:?} len={}",
                    data.len()
                );
            }
            Event::Ts(packets) => println!("Ts  {} packets", packets.len()),
        }
    }

    tracing::warn!("service event stream closed");
}