use std::{
collections::{
HashMap,
VecDeque,
},
sync::{
Arc,
Mutex,
Weak,
},
time::Duration,
};
use rand::{
SeedableRng,
rngs::StdRng,
};
use tokio::{
sync::{
broadcast,
watch,
},
task::AbortHandle,
};
use crate::{
carousel::{
Carousel,
EmmPackets,
},
cas::{
CasEntry,
register_new_member_io,
},
config::ServiceConfig,
cw::{
CwGenerator,
Parity,
},
error::Error,
event::{
Event,
StreamInfo,
},
lock_ext::MutexExt,
simulcrypt::{
CasRef,
Inner,
},
spawn::spawn_supervised,
};
const EVENT_CHANNEL_CAPACITY: usize = 1024;
const CW_ROTATION_TICK: Duration = Duration::from_millis(100);
#[derive(Clone)]
pub struct Member {
cas: CasRef,
pub stream_id: u16,
pub access_criteria: Vec<u8>,
refcount: usize,
}
#[derive(Clone, Copy)]
struct Cw {
cp_number: u16,
parity: Parity,
cw: [u8; 8],
}
impl From<Cw> for Event {
fn from(cw: Cw) -> Self {
Event::Cw {
cp_number: cw.cp_number,
parity: cw.parity,
cw: cw.cw,
}
}
}
pub struct ServiceGroup {
crypto_period: Duration,
nominal_cp_duration: u16,
cw_tx: watch::Sender<Option<Cw>>,
events_tx: broadcast::Sender<Event>,
rotation: Mutex<Option<AbortHandle>>,
members: Mutex<HashMap<(CasRef, u16), Member>>,
}
impl ServiceGroup {
pub fn nominal_cp_duration(&self) -> u16 {
self.nominal_cp_duration
}
pub fn cp_number(&self) -> Option<u16> {
self.cw_tx.borrow().map(|cw| cw.cp_number)
}
pub fn remove_member(&self, cas: CasRef, stream_id: u16) {
self.members.lock_or_recover().remove(&(cas, stream_id));
}
}
fn resolve_service_streams(
cfg: &ServiceConfig,
entries: &[Arc<CasEntry>],
group: &Arc<ServiceGroup>,
nominal_cp_duration: u16,
) -> Vec<StreamInfo> {
let mut processed: HashMap<(CasRef, u16), u16> = HashMap::new();
let mut stream_infos = Vec::with_capacity(cfg.cas.len());
for (service_cas, entry) in cfg.cas.iter().zip(entries) {
let dedup_key = (service_cas.cas, service_cas.ecm_pid);
let stream_id = if let Some(&stream_id) = processed.get(&dedup_key) {
stream_id
} else {
let existing = entry.membership(service_cas.ecm_pid);
let stream_id = match existing {
Some(membership)
if membership
.group
.upgrade()
.is_some_and(|g| Arc::ptr_eq(&g, group)) =>
{
membership.stream_id
}
_ => {
let stream_id =
entry.attach_stream(service_cas.ecm_pid, &Arc::downgrade(group));
register_new_member_io(
service_cas.cas,
entry,
stream_id,
&group.events_tx,
nominal_cp_duration,
);
stream_id
}
};
processed.insert(dedup_key, stream_id);
stream_id
};
{
let mut members = group.members.lock_or_recover();
match members.get_mut(&(service_cas.cas, stream_id)) {
Some(member) => {
if member.access_criteria != service_cas.access_criteria {
tracing::warn!(
name = %cfg.name,
stream_id,
"access_criteria differ from the running group, keeping the first"
);
}
member.refcount += 1;
}
None => {
members.insert(
(service_cas.cas, stream_id),
Member {
cas: service_cas.cas,
stream_id,
access_criteria: service_cas.access_criteria.clone(),
refcount: 1,
},
);
}
}
}
stream_infos.push(StreamInfo {
cas: service_cas.cas,
ecm_pid: service_cas.ecm_pid,
stream_id,
});
}
stream_infos
}
pub struct Service {
name: String,
inner: Arc<Inner>,
group: Arc<ServiceGroup>,
streams: Vec<StreamInfo>,
cw_rx: watch::Receiver<Option<Cw>>,
pending: VecDeque<Event>,
events_rx: broadcast::Receiver<Event>,
carousel: Carousel,
emm: EmmPackets,
}
impl Service {
pub fn open(inner: &Arc<Inner>, cfg: &ServiceConfig) -> Result<Self, Error> {
if cfg.cas.is_empty() {
return Err(Error::EmptyService);
}
let nominal_cp_duration = cfg.nominal_cp_duration()?;
let mut entries = Vec::with_capacity(cfg.cas.len());
for service_cas in &cfg.cas {
entries.push(inner.cas_entry(service_cas.cas)?);
}
let _topology = inner.topology.lock_or_recover();
for (service_cas, entry) in cfg.cas.iter().zip(&entries) {
entry.ensure_running(service_cas.cas);
}
let mut found: Option<Arc<ServiceGroup>> = None;
for (service_cas, entry) in cfg.cas.iter().zip(&entries) {
let Some(membership) = entry.membership(service_cas.ecm_pid) else {
continue;
};
let Some(group) = membership.group.upgrade() else {
continue; };
match &found {
None => found = Some(group),
Some(existing) if Arc::ptr_eq(existing, &group) => {}
Some(_) => {
return Err(Error::CwGroupConflict {
ecm_pid: service_cas.ecm_pid,
stream_id: membership.stream_id,
});
}
}
}
let (group, cw_rx, events_rx) = if let Some(group) = found {
if group.crypto_period != cfg.crypto_period {
return Err(Error::CryptoPeriodMismatch {
expected: group.crypto_period,
actual: cfg.crypto_period,
});
}
let mut cw_rx = group.cw_tx.subscribe();
if cw_rx.borrow().is_some() {
cw_rx.mark_changed();
}
let events_rx = group.events_tx.subscribe();
(group, cw_rx, events_rx)
} else {
let (cw_tx, cw_rx) = watch::channel(None);
let (events_tx, events_rx) = broadcast::channel(EVENT_CHANNEL_CAPACITY);
let group = Arc::new(ServiceGroup {
crypto_period: cfg.crypto_period,
nominal_cp_duration,
cw_tx,
events_tx,
rotation: Mutex::new(None),
members: Mutex::new(HashMap::new()),
});
(group, cw_rx, events_rx)
};
let streams = resolve_service_streams(cfg, &entries, &group, nominal_cp_duration);
let mut rotation = group.rotation.lock_or_recover();
if rotation.is_none() {
*rotation = Some(spawn_supervised(
"cw-rotation",
run_cw_rotation(
Arc::clone(inner),
nominal_cp_duration,
Arc::downgrade(&group),
),
));
}
drop(rotation);
let mut pending = VecDeque::new();
let mut seen = Vec::new();
for (info, entry) in streams.iter().zip(&entries) {
if !seen.contains(&info.cas) {
seen.push(info.cas);
pending.push_back(entry.state_event(info.cas));
}
}
for (info, entry) in streams.iter().zip(&entries) {
pending.extend(entry.last_ecm(info.stream_id));
}
Ok(Service {
name: cfg.name.clone(),
inner: Arc::clone(inner),
group,
carousel: Carousel::new(&streams),
emm: EmmPackets::new(&streams),
streams,
cw_rx,
pending,
events_rx,
})
}
#[must_use]
pub fn streams(&self) -> &[StreamInfo] {
&self.streams
}
pub async fn recv(&mut self) -> Option<Event> {
loop {
if !self.cw_rx.has_changed().unwrap_or(false) {
self.carousel.run(&self.inner, &mut self.pending);
if let Some(event) = self.pending.pop_front() {
return Some(event);
}
}
let due = self.carousel.next_due();
tokio::select! {
biased;
changed = self.cw_rx.changed() => {
changed.ok()?;
if let Some(cw) = *self.cw_rx.borrow_and_update() {
return Some(cw.into());
}
}
() = async {
match due {
Some(due) => tokio::time::sleep_until(due).await,
None => std::future::pending().await,
}
} => {}
event = self.events_rx.recv() => match event {
Ok(event) => {
self.emm.push(&self.inner, &event, &mut self.pending);
return Some(event);
}
Err(broadcast::error::RecvError::Lagged(skipped)) => {
tracing::warn!(
name = %self.name,
skipped,
"service event receiver lagged"
);
}
Err(broadcast::error::RecvError::Closed) => return None,
},
}
}
}
pub fn try_recv(&mut self) -> Option<Event> {
if self.cw_rx.has_changed().unwrap_or(false)
&& let Some(cw) = *self.cw_rx.borrow_and_update()
{
return Some(cw.into());
}
self.carousel.run(&self.inner, &mut self.pending);
if let Some(event) = self.pending.pop_front() {
return Some(event);
}
loop {
match self.events_rx.try_recv() {
Ok(event) => {
self.emm.push(&self.inner, &event, &mut self.pending);
return Some(event);
}
Err(broadcast::error::TryRecvError::Lagged(skipped)) => {
tracing::warn!(
name = %self.name,
skipped,
"service event receiver lagged"
);
}
Err(_) => return None,
}
}
}
}
impl Drop for Service {
fn drop(&mut self) {
let _topology = self.inner.topology.lock_or_recover();
let mut freed = Vec::new();
{
let mut members = self.group.members.lock_or_recover();
for info in &self.streams {
let key = (info.cas, info.stream_id);
if let Some(member) = members.get_mut(&key) {
member.refcount -= 1;
if member.refcount == 0 {
members.remove(&key);
freed.push(*info);
}
}
}
if members.is_empty()
&& let Some(handle) = self.group.rotation.lock_or_recover().take()
{
handle.abort();
}
}
if freed.is_empty() {
return;
}
for info in &freed {
if let Ok(entry) = self.inner.cas_entry(info.cas) {
entry.release_stream(info);
}
}
}
}
fn all_streams_ready(inner: &Inner, targets: &[Member]) -> bool {
targets.iter().all(|member| {
inner
.cas_entry(member.cas)
.is_ok_and(|entry| entry.is_stream_ready(member.stream_id))
})
}
async fn run_cw_rotation(inner: Arc<Inner>, nominal_cp_duration: u16, group: Weak<ServiceGroup>) {
let mut rng = StdRng::from_rng(&mut rand::rng());
let mut generator = CwGenerator::new(&mut rng);
let mut interval = tokio::time::interval(CW_ROTATION_TICK);
let mut ticks_since_rotation = nominal_cp_duration;
loop {
interval.tick().await;
let Some(group) = group.upgrade() else {
return;
};
let targets: Vec<Member> = group.members.lock_or_recover().values().cloned().collect();
if targets.is_empty() {
return;
}
if ticks_since_rotation < nominal_cp_duration {
ticks_since_rotation += 1;
continue;
}
if !all_streams_ready(&inner, &targets) {
continue;
}
ticks_since_rotation = 0;
let advance = generator.advance(&mut rng);
group.cw_tx.send_replace(Some(Cw {
cp_number: advance.cp_number,
parity: advance.parity,
cw: advance.active,
}));
for member in targets {
if let Ok(entry) = inner.cas_entry(member.cas) {
entry.provision_cw(member, &advance);
}
}
}
}