use std::{
fmt::Write as _,
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)
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().fold(String::new(), |mut out, byte| {
let _ = write!(out, "{byte:02x}");
out
})
}
fn cas_config_from_env(prefix: &str, id: &str, default_port: u16) -> CasConfig {
let host: std::net::IpAddr = env_parse(&format!("{prefix}_HOST"), [127, 0, 0, 1].into());
let port: u16 = env_parse(&format!("{prefix}_PORT"), default_port);
let channel_id: u16 = env_parse(&format!("{prefix}_CHANNEL_ID"), 1);
let super_cas_id =
u32::from_str_radix(&env_or(&format!("{prefix}_SUPER_CAS_ID"), "0b000001"), 16)
.unwrap_or_else(|_| panic!("invalid {prefix}_SUPER_CAS_ID"));
CasConfig {
id: id.into(),
name: id.into(),
super_cas_id,
first_stream_id: 0,
ecmg: EcmgConfig::new(channel_id, std::net::SocketAddr::new(host, port)),
emmg: None,
}
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let simulcrypt = Simulcrypt::new();
let cas_a = simulcrypt
.acquire_cas(cas_config_from_env("CAS_A", "cas-a", 2222))
.expect("acquire_cas failed for CAS A");
let cas_b = simulcrypt
.acquire_cas(cas_config_from_env("CAS_B", "cas-b", 2223))
.expect("acquire_cas failed for CAS B");
let ecm_pid: u16 = env_parse("ECM_PID", 100);
let crypto_period_secs: u64 = env_parse("CRYPTO_PERIOD_SECS", 10);
let mut service = simulcrypt
.open_service(&ServiceConfig {
name: "multi-cas-demo".into(),
crypto_period: Duration::from_secs(crypto_period_secs),
cas: vec![
ServiceCas {
cas: cas_a.cas(),
ecm_pid,
access_criteria: vec![],
},
ServiceCas {
cas: cas_b.cas(),
ecm_pid,
access_criteria: vec![],
},
],
})
.expect("open_service failed");
for stream in service.streams() {
tracing::info!(
"stream registered: cas={:?} ecm_pid={} stream_id={}",
stream.cas,
stream.ecm_pid,
stream.stream_id
);
}
while let Some(event) = service.recv().await {
match event {
Event::Cw {
cp_number,
parity,
cw,
} => {
println!(
"Cw cp={cp_number} parity={parity:?} cw={} (shared by both CAS)",
hex(&cw)
);
}
Event::Ecm {
cas,
stream_id,
cp_number,
data,
..
} => {
println!(
"Ecm cas={cas:?} stream_id={stream_id} cp={cp_number:?} len={}",
data.len()
);
}
Event::State { cas, state } => {
tracing::info!("CAS {:?} state changed: {:?}", cas, state);
}
Event::Emm { .. } | Event::Ts(_) => {}
}
}
}