dvb_ci_runtime/managed.rs
1//! Managed CAS-layer state (#763) — the [`Driver`](crate::Driver)'s owned view
2//! of the slot's active descrambled-service set.
3//!
4//! This is Layer 1 of the #763 CAS orchestration design
5//! (`docs/superpowers/specs/2026-07-24-dvb-ci-cas-layer-design.md`): parsed
6//! `dvb-si` structures in (never raw bytes), the existing
7//! `dvb_ci::builder::build_ca_pmt` PMT→`ca_pmt` projection
8//! (ETSI EN 50221 §8.4.3.4, Table 25) does the wire work, and this module just
9//! tracks what was sent. [`Driver::add_service`](crate::driver::Driver::add_service)
10//! builds + sends the `ca_pmt` and records the service here.
11
12use mpeg_ts::pid::Pid;
13use mpeg_ts::pid::well_known::CAT as CAT_PID;
14use std::collections::{BTreeMap, BTreeSet};
15use std::time::Duration;
16
17use dvb_ci::objects::ca_pmt::CaPmtCmdId;
18use dvb_ci::objects::ca_pmt_reply::CaEnable;
19use dvb_si::descriptors::DescriptorLoop;
20use dvb_si::descriptors::ca::TAG as CA_DESCRIPTOR_TAG;
21use dvb_si::tables::cat::CatCaEntry;
22use dvb_si::tables::pmt::PmtSection;
23
24/// Default entitlement re-query cadence (#763 Task 5's `Resource::tick`-driven
25/// refresh; `Duration::ZERO` disables it). Set on [`ManagedCa::new`] so the
26/// field is in place before the re-query timer is wired up.
27///
28/// **`Duration::ZERO` (opt-in, since #1032).** The feature was on by default
29/// at 10s until #1032, when a lone `query` every 10 s was found to stop an
30/// AlphaCrypt/Irdeto module descrambling. The timer now sends `update/query`
31/// immediately followed by `update/ok_descrambling`, which was hardware-verified
32/// on an entitled AlphaCrypt One4All V2.5 (the module answered most queries with
33/// `ca_enable = 0x81` and descrambling never gapped), but it stays opt-in: the
34/// periodic re-query only helps a host that wants a fresh `ca_pmt_reply`, and it
35/// has been verified on that one CAM only. Call
36/// [`Driver::set_requery_interval`](crate::driver::Driver::set_requery_interval)
37/// explicitly once re-query is verified against your own CAM.
38pub const REQUERY_DEFAULT: Duration = Duration::ZERO;
39
40/// Sentinel `PCR_PID` value meaning "no PCR carried for this programme" (ISO/IEC
41/// 13818-1 §2.4.4.8, Table 2-33's `PCR_PID` field). A `ManagedService` whose
42/// `pcr_pid` is this value carries no dedicated PCR PID to route — it must be
43/// excluded from [`ManagedCa::required_pids`], never treated as a routable PID.
44const PCR_PID_NONE: Pid = Pid::new(0x1FFF);
45
46/// Errors from the managed CAS-layer API (`Driver::add_service` and friends,
47/// #763).
48#[derive(Debug, thiserror::Error)]
49#[non_exhaustive]
50pub enum CaError {
51 /// The PMT carries no `CA_descriptor` (ETSI EN 300 468 §6.2.16, tag
52 /// `0x09`) at programme or elementary-stream level — there is nothing for
53 /// the CAM to descramble, so no `ca_pmt` is built or sent.
54 #[error("PMT for program_number {program_number} has no CA_descriptor at program or ES level")]
55 NoCaDescriptor {
56 /// The programme whose PMT carried no CA info.
57 program_number: u16,
58 },
59 /// Sending the built `ca_pmt` to the device failed.
60 #[error("ca_pmt send failed: {0}")]
61 Io(#[from] std::io::Error),
62 /// The `ca_pmt` projected from the caller's PMT has no valid wire
63 /// encoding (a `program_info_length`/`ES_info_length` or `version_number`
64 /// out of its spec range — e.g. a source PMT whose descriptor loop is
65 /// corrupted past the section end) or its stored raw PMT no longer
66 /// re-parses. r10-W-20: `Driver::add_service` and the re-query timer
67 /// must reject such a PMT as an `Err` value rather than panic inside
68 /// the serialization.
69 #[error("ca_pmt serialization failed: {0}")]
70 Serialize(#[from] dvb_ci::Error),
71 /// The raw PMT bytes stored at `add_service` time no longer re-parse on
72 /// a re-query tick (corruption of the caller's own state); the re-query
73 /// is reported as an error instead of panicking (r10-W-20). Shares the
74 /// `dvb_si::error::Error` payload of the `Cat` arm.
75 #[error("stored PMT re-parse failed: {0}")]
76 PmtParse(dvb_si::error::Error),
77 /// The CAT's descriptor loop (ISO/IEC 13818-1 §2.4.4.5) carried a
78 /// truncated `CA_descriptor` (EN 300 468 §6.2.16) — [`Driver::set_cat`](crate::driver::Driver::set_cat)
79 /// could not extract the CAID/EMM-PID map.
80 #[error("CAT CA_descriptor parse failed: {0}")]
81 Cat(#[from] dvb_si::error::Error),
82}
83
84/// One actively-managed service (owned, no borrowed lifetime — copied out of
85/// the caller's `PmtSection` at [`Driver::add_service`](crate::driver::Driver::add_service)
86/// time).
87///
88/// `cmd` and `last_ca_enable` are recorded starting now but are only *read* by
89/// Task 6's `remove_service`; `last_ca_enable`/`last_descrambling_ok` are also
90/// read+written by `ManagedCa::record_reply` (#763 Task 5's edge-triggered
91/// `Notification::Entitlement`).
92#[derive(Debug, Clone, PartialEq, Eq)]
93#[non_exhaustive]
94pub struct ManagedService {
95 /// Elementary-stream PIDs carried by this programme (every stream, not
96 /// only the CA-bearing ones — a caller routing PIDs into `ci0` needs the
97 /// full component set).
98 pub es_pids: Vec<Pid>,
99 /// `CA_PID`s (ECM PIDs) advertised by this programme's `CA_descriptor`s,
100 /// programme- and ES-level combined.
101 pub ca_pids: Vec<Pid>,
102 /// This programme's PMT `PCR_PID` (ISO/IEC 13818-1 §2.4.4.8) — the PID
103 /// carrying the programme clock reference. May coincide with an
104 /// `es_pids` entry (PCR piggybacked on a component stream) or be a PID of
105 /// its own (a dedicated PCR PID, carrying no other stream) — either way a
106 /// caller routing PIDs into `ci0` needs it, or the descrambled TS loses
107 /// its clock reference. `0x1FFF` means the programme carries no PCR (ISO/IEC
108 /// 13818-1 §2.4.4.8) and is excluded from routing.
109 pub pcr_pid: Pid,
110 /// The `ca_pmt_cmd_id` last sent for this service (EN 50221 §8.4.3.4
111 /// Table 25).
112 pub cmd: CaPmtCmdId,
113 /// The last observed programme-level `CA_enable` (EN 50221 §8.4.3.5 Table
114 /// 26), for the Task 5 edge-triggered `Notification::Entitlement`. `None`
115 /// until a `ca_pmt_reply` has been seen for this programme, or when the
116 /// last-seen reply's programme `CA_enable_flag` was clear.
117 pub last_ca_enable: Option<CaEnable>,
118 /// The last observed `descrambling_ok` (derived from `last_ca_enable`),
119 /// paired with it for the Task 5 transition diff.
120 pub(crate) last_descrambling_ok: bool,
121 /// The exact `ca_pmt` bytes sent by [`Driver::add_service`](crate::driver::Driver::add_service)
122 /// to start descrambling — `list_management = only`/`add`,
123 /// `cmd_id = ok_descrambling` (EN 50221 §8.4.3.4 Table 25). Kept for the
124 /// add_service oracle test to assert what was actually sent; this is
125 /// *not* what the #765/#1032 re-query timer resends —
126 /// `Driver::requery_tick` rebuilds a fresh `list_management = update`
127 /// `query`/`ok_descrambling` pair (#1032) per tick from
128 /// [`pmt_raw`](Self::pmt_raw), against the *current* active set each
129 /// time (not frozen at this service's `add_service` time).
130 pub(crate) built_ca_pmt: Vec<u8>,
131 /// The owned raw PMT section bytes this service was built from (#763
132 /// Task 6), kept so [`Driver::remove_service`](crate::driver::Driver::remove_service)
133 /// can re-drive the existing [`Driver::remove_program`](crate::driver::Driver::remove_program)
134 /// path (which needs the raw PMT to build the `Update`/`NotSelected`
135 /// `ca_pmt`, EN 50221 §8.4.3.4 Table 25) without the caller re-supplying
136 /// it.
137 pub(crate) pmt_raw: Vec<u8>,
138}
139
140/// The [`Driver`](crate::Driver)'s owned CAS-layer state (#763 Layer 1) — one
141/// CI slot's active service set plus the entitlement re-query cadence.
142#[derive(Debug, Clone)]
143pub struct ManagedCa {
144 /// Active services, keyed by `program_number`.
145 services: BTreeMap<u16, ManagedService>,
146 /// Entitlement re-query cadence (Task 5); `Duration::ZERO` disables it.
147 requery_interval: Duration,
148 /// Elapsed time accumulated since the last re-query (Task 5's
149 /// [`tick`](Self::tick), mirroring `resource.rs`'s `DateTime::tick`
150 /// accumulate-then-fire pattern).
151 since: Duration,
152 /// The last `set_cat`'s (CAID, EMM PID) entries, one per `CA_descriptor` (a CAID may list several EMM PIDs; ISO/IEC 13818-1 §2.4.4.5's
153 /// `CA_descriptor`s, EN 300 468 §6.2.16). Kept even when it yields no
154 /// `emm_pids` (no `ca_info` seen yet) so a later `ca_info` can recompute
155 /// against it (#763 Task 4).
156 cat_emm_pids: Vec<(u16, Pid)>,
157 /// The last-observed `Notification::CaInfo` CAID set — the CAM's
158 /// advertised systems (#763 Task 4).
159 cam_caids: BTreeSet<u16>,
160 /// `cat_emm_pids` ∩ `cam_caids` — the EMM PIDs to route into `ci0`.
161 /// Recomputed on every [`set_cat`](Self::set_cat)/
162 /// [`set_cam_caids`](Self::set_cam_caids) call.
163 emm_pids: Vec<Pid>,
164 /// Union of active services' ES PIDs. Recomputed on every
165 /// [`record`](Self::record)/[`remove`](Self::remove) call.
166 descramble_pids: Vec<Pid>,
167 /// Union of active services' `ca_pids` (ECM PIDs, programme+ES combined).
168 /// Recomputed on every [`record`](Self::record)/[`remove`](Self::remove)
169 /// call, exactly like [`descramble_pids`](Self::descramble_pids).
170 ca_pids: Vec<Pid>,
171}
172
173impl Default for ManagedCa {
174 fn default() -> Self {
175 Self {
176 services: BTreeMap::new(),
177 requery_interval: REQUERY_DEFAULT,
178 since: Duration::ZERO,
179 cat_emm_pids: Vec::new(),
180 cam_caids: BTreeSet::new(),
181 emm_pids: Vec::new(),
182 descramble_pids: Vec::new(),
183 ca_pids: Vec::new(),
184 }
185 }
186}
187
188impl ManagedCa {
189 /// New, empty managed-CA state at the default re-query cadence
190 /// ([`REQUERY_DEFAULT`]).
191 #[must_use]
192 pub fn new() -> Self {
193 Self::default()
194 }
195
196 /// The currently-tracked services, keyed by `program_number`.
197 #[must_use]
198 pub fn services(&self) -> &BTreeMap<u16, ManagedService> {
199 &self.services
200 }
201
202 /// The re-query cadence currently configured (Task 5 consumes this).
203 #[must_use]
204 pub fn requery_interval(&self) -> Duration {
205 self.requery_interval
206 }
207
208 /// Set the entitlement re-query cadence
209 /// ([`Driver::set_requery_interval`](crate::driver::Driver::set_requery_interval)).
210 /// `Duration::ZERO` disables re-query. Resets the accumulated `since` so a
211 /// newly-set interval doesn't fire immediately off stale accumulation.
212 pub(crate) fn set_requery_interval(&mut self, interval: Duration) {
213 self.requery_interval = interval;
214 self.since = Duration::ZERO;
215 }
216
217 /// Whether no service is currently tracked — used to pick
218 /// `CaPmtListManagement::Only` (first-ever service) vs `Add` (joining an
219 /// already-active set) for the next `add_service`, mirroring
220 /// [`Driver::descramble_programs`](crate::driver::Driver::descramble_programs)/
221 /// [`Driver::add_program`](crate::driver::Driver::add_program)'s existing
222 /// multi-programme list-management convention (EN 50221 §8.4.3.4 Table 25).
223 #[must_use]
224 pub(crate) fn is_empty(&self) -> bool {
225 self.services.is_empty()
226 }
227
228 /// Record a service after its `ca_pmt` has been built and sent.
229 pub(crate) fn record(&mut self, program_number: u16, service: ManagedService) {
230 self.services.insert(program_number, service);
231 self.recompute_service_pids();
232 }
233
234 /// Stop tracking `program_number` (#763 Task 6's
235 /// [`Driver::remove_service`](crate::driver::Driver::remove_service)),
236 /// recomputing [`descramble_pids`](Self::descramble_pids)/[`ca_pids`](Self::ca_pids)
237 /// afterwards. Returns whether the programme was actually tracked
238 /// (`false` is a no-op — nothing to remove).
239 pub(crate) fn remove(&mut self, program_number: u16) -> bool {
240 let removed = self.services.remove(&program_number).is_some();
241 if removed {
242 self.recompute_service_pids();
243 }
244 removed
245 }
246
247 /// Clear all module-scoped managed state (#763 Task 6's CAM hot-plug
248 /// fix): the active service set, the CAT/CAM CAID-derived EMM-PID state,
249 /// and the descramble-PID union, plus the re-query accumulator (`since`)
250 /// so a freshly (re)inserted module doesn't inherit a departed module's
251 /// partially-elapsed re-query countdown. `requery_interval` is
252 /// deliberately **not** reset — it is host configuration
253 /// ([`set_requery_interval`](Self::set_requery_interval)), not
254 /// per-module state, and must survive a CAM insert/remove edge.
255 pub(crate) fn clear(&mut self) {
256 self.services.clear();
257 self.cat_emm_pids.clear();
258 self.cam_caids.clear();
259 self.emm_pids.clear();
260 self.descramble_pids.clear();
261 self.ca_pids.clear();
262 self.since = Duration::ZERO;
263 }
264
265 /// The EMM PIDs to route into `ci0`: the last `set_cat`'s list of
266 /// `(CAID, EMM PID)` entries (one per `CA_descriptor`; a CAID may have
267 /// several), intersected with the CAM's advertised CAIDs (last `ca_info`) — a
268 /// CAT entry for a CAID the CAM never advertised is never fed (#763 Task
269 /// 4).
270 #[must_use]
271 pub fn emm_pids(&self) -> &[Pid] {
272 &self.emm_pids
273 }
274
275 /// The union of every actively-managed service's elementary-stream PIDs
276 /// — the PIDs a caller must route into `ci0` for descrambling.
277 #[must_use]
278 pub fn descramble_pids(&self) -> &[Pid] {
279 &self.descramble_pids
280 }
281
282 /// The union of every actively-managed service's `CA_PID`s (ECM PIDs,
283 /// ISO/IEC 13818-1 §2.6.16 `CA_descriptor` `CA_PID`, programme + ES level
284 /// combined) — the control-word channel a caller must route into `ci0`
285 /// alongside [`descramble_pids`](Self::descramble_pids); without these
286 /// the module has ES to descramble but no control words to do it with.
287 #[must_use]
288 pub fn ca_pids(&self) -> &[Pid] {
289 &self.ca_pids
290 }
291
292 /// `descramble_pids ∪ ca_pids ∪ emm_pids ∪ PCR ∪ CAT` — every PID class a
293 /// caller must route into `ci0` for this slot to both descramble the
294 /// tracked services (ES + ECM), keep entitlements current (EMM), and
295 /// carry each active service's programme clock reference (PCR — ISO/IEC
296 /// 13818-1 §2.4.4.8). The PCR PID is folded in here rather than into
297 /// [`descramble_pids`](Self::descramble_pids) because a dedicated PCR PID
298 /// carries no elementary stream of its own; a service whose `pcr_pid` is
299 /// `0x1FFF` ("no PCR") contributes nothing. Computed on demand (small
300 /// sets); dedup + sorted.
301 ///
302 /// The CAT PID ([`CAT_PID`], 0x0001) is **always** included, even with no
303 /// services and no CAM. This is hardware-evidenced, not mandated by
304 /// EN 50221: on a Digital Devices CXD2099 with an entitled AlphaCrypt
305 /// One4All V2.5 (CAID 0x0650) decrypting ORF1 over 180 s runs, routing the
306 /// CAT plus only EMM PID 0x259 descrambled from about 55 s, while routing
307 /// all seven EMM PIDs without the CAT never descrambled (#1296).
308 #[must_use]
309 pub fn required_pids(&self) -> Vec<Pid> {
310 let mut pids: BTreeSet<Pid> = BTreeSet::new();
311 pids.extend(self.descramble_pids.iter().copied());
312 pids.extend(self.ca_pids.iter().copied());
313 pids.extend(self.emm_pids.iter().copied());
314 pids.insert(CAT_PID);
315 for service in self.services.values() {
316 if service.pcr_pid != PCR_PID_NONE {
317 pids.insert(service.pcr_pid);
318 }
319 }
320 pids.into_iter().collect()
321 }
322
323 /// Store the CAT's CAID → EMM-PID map (ISO/IEC 13818-1 §2.4.4.5's
324 /// `CA_descriptor`s, EN 300 468 §6.2.16) and recompute [`emm_pids`](Self::emm_pids).
325 /// Calling this before any `ca_info` is not an error: the map is kept so
326 /// a later [`set_cam_caids`](Self::set_cam_caids) recomputes against it.
327 pub(crate) fn set_cat(&mut self, entries: &[CatCaEntry]) {
328 self.cat_emm_pids = entries.iter().map(|e| (e.ca_system_id, e.ca_pid)).collect();
329 self.recompute_emm_pids();
330 }
331
332 /// Record the CAM's advertised CAID set (from `Notification::CaInfo`)
333 /// and recompute [`emm_pids`](Self::emm_pids).
334 pub(crate) fn set_cam_caids(&mut self, caids: BTreeSet<u16>) {
335 self.cam_caids = caids;
336 self.recompute_emm_pids();
337 }
338
339 /// The CAM's advertised CAID set (last `Notification::CaInfo`), for a
340 /// caller that must CAID-filter a `ca_pmt` before sending it (#1067) —
341 /// mirrors `CiStack`'s existing filter on the raw `descramble` path
342 /// (`dvb_ci::builder::build_ca_pmt_for_caids`, whose own doc cites: "a
343 /// CICAM rejects a `ca_pmt` carrying a `CA_descriptor` for a
344 /// `CA_system_id` it does not support, declining even the streams it
345 /// could descramble"). Empty means no `ca_info` has been observed yet —
346 /// the caller falls back to sending every `CA_descriptor` unfiltered,
347 /// same as `CiStack::build_ca_pmt_bytes`.
348 #[must_use]
349 pub(crate) fn cam_caids(&self) -> &BTreeSet<u16> {
350 &self.cam_caids
351 }
352
353 /// `emm_pids` = `cat_emm_pids` ∩ `cam_caids`, deduped and sorted by PID
354 /// (matching [`recompute_service_pids`](Self::recompute_service_pids)'s
355 /// convention) — two CAIDs the CAT maps to the *same* EMM PID must not
356 /// list that PID twice.
357 fn recompute_emm_pids(&mut self) {
358 let pids: BTreeSet<Pid> = self
359 .cat_emm_pids
360 .iter()
361 .filter(|(caid, _)| self.cam_caids.contains(caid))
362 .map(|(_, pid)| *pid)
363 .collect();
364 self.emm_pids = pids.into_iter().collect();
365 }
366
367 /// Advance the entitlement re-query cadence by `elapsed` — mirrors
368 /// `resource.rs`'s `DateTime::tick` accumulate-then-fire pattern:
369 /// accumulate `since`, and once it reaches `requery_interval`, reset it
370 /// and report that a re-query is due. Returns `false` (never fires) when
371 /// re-query is disabled (`requery_interval == Duration::ZERO`) or there
372 /// are no active services to re-query.
373 pub(crate) fn tick(&mut self, elapsed: Duration) -> bool {
374 if self.requery_interval.is_zero() || self.services.is_empty() {
375 return false;
376 }
377 self.since += elapsed;
378 if self.since >= self.requery_interval {
379 self.since = Duration::ZERO;
380 true
381 } else {
382 false
383 }
384 }
385
386 /// Diff an incoming `ca_pmt_reply`'s programme-level status (EN 50221
387 /// §8.4.3.5 Table 26) against the last-observed status for
388 /// `program_number` and report the edge-triggered transition (#763 Task
389 /// 5): `Some((v, descrambling_ok))` fires only when `ca_enable` is
390 /// `Some(v)` *and* `(ca_enable, descrambling_ok)` differs from what was
391 /// last observed for this programme — including the first-ever reply
392 /// (no prior observation) establishing the baseline and reporting it.
393 /// `ca_enable == None` (programme status withdrawn) never fires: there is
394 /// no per-programme status to report (the coarse withdrawal signal is
395 /// #726 `HotPlug`'s job). The last-observed status is updated
396 /// unconditionally, whether or not this call fires.
397 ///
398 /// No-op (`None`) if `program_number` names no actively-managed service
399 /// (never `add_service`'d, or already removed) — there is nothing to
400 /// diff against.
401 pub(crate) fn record_reply(
402 &mut self,
403 program_number: u16,
404 ca_enable: Option<CaEnable>,
405 descrambling_ok: bool,
406 ) -> Option<(CaEnable, bool)> {
407 let service = self.services.get_mut(&program_number)?;
408 let prev = (service.last_ca_enable, service.last_descrambling_ok);
409 service.last_ca_enable = ca_enable;
410 service.last_descrambling_ok = descrambling_ok;
411 match ca_enable {
412 Some(v) if prev != (ca_enable, descrambling_ok) => Some((v, descrambling_ok)),
413 _ => None,
414 }
415 }
416
417 /// `descramble_pids`/`ca_pids` = the union (dedup, sorted) of every
418 /// active service's `es_pids`/`ca_pids` respectively.
419 fn recompute_service_pids(&mut self) {
420 let mut descramble: BTreeSet<Pid> = BTreeSet::new();
421 let mut ca: BTreeSet<Pid> = BTreeSet::new();
422 for service in self.services.values() {
423 descramble.extend(service.es_pids.iter().copied());
424 ca.extend(service.ca_pids.iter().copied());
425 }
426 self.descramble_pids = descramble.into_iter().collect();
427 self.ca_pids = ca.into_iter().collect();
428 }
429}
430
431/// `true` if `loop_` carries at least one `CA_descriptor` (ISO/IEC 13818-1
432/// §2.6.16 / ETSI EN 300 468 §6.2.16, tag `0x09`).
433fn has_ca_descriptor(loop_: &DescriptorLoop<'_>) -> bool {
434 loop_.raw_tags().any(|(tag, _)| tag == CA_DESCRIPTOR_TAG)
435}
436
437/// Byte offset within a `CA_descriptor` body (after tag + length) where the
438/// `reserved(3)`/`CA_PID(13)` field starts — `CA_system_id` occupies the first
439/// two bytes (ISO/IEC 13818-1 §2.6.16).
440const CA_PID_BODY_OFFSET: usize = 2;
441/// `CA_PID` field width in bytes.
442const CA_PID_FIELD_LEN: usize = 2;
443/// Mask for the `CA_PID`'s upper byte (top 3 bits are reserved, set to `1`).
444const CA_PID_HIGH_MASK: u8 = 0x1F;
445
446/// The `CA_PID` carried by one `CA_descriptor` body (tag + length already
447/// stripped by [`DescriptorLoop::raw_tags`]), if the body is long enough to
448/// carry the mandatory fields.
449fn ca_pid_of(body: &[u8]) -> Option<Pid> {
450 let field = body.get(CA_PID_BODY_OFFSET..CA_PID_BODY_OFFSET + CA_PID_FIELD_LEN)?;
451 Some(Pid::new(
452 (u16::from(field[0] & CA_PID_HIGH_MASK) << 8) | u16::from(field[1]),
453 ))
454}
455
456/// Collect the `CA_PID`s from every `CA_descriptor` in `loop_`.
457fn ca_pids_in(loop_: &DescriptorLoop<'_>) -> Vec<Pid> {
458 loop_
459 .raw_tags()
460 .filter(|(tag, _)| *tag == CA_DESCRIPTOR_TAG)
461 .filter_map(|(_, body)| ca_pid_of(body))
462 .collect()
463}
464
465/// Whether `pmt` carries a `CA_descriptor` at programme or any ES level (EN
466/// 300 468 §6.2.16) — used to reject a CA-free PMT before building a useless
467/// `ca_pmt`.
468pub(crate) fn pmt_has_ca(pmt: &PmtSection<'_>) -> bool {
469 has_ca_descriptor(&pmt.program_info)
470 || pmt.streams.iter().any(|s| has_ca_descriptor(&s.es_info))
471}
472
473/// The owned [`ManagedService`] state to record for `pmt`, sent with `cmd`;
474/// `built_ca_pmt` is the exact `ok_descrambling` bytes sent (kept for the
475/// add_service oracle test). `pmt_raw` is kept so a later re-query
476/// (`Driver::requery_tick`, #765) can rebuild a fresh `query`-variant
477/// `ca_pmt` against the *current* active set rather than freezing
478/// `list_management` at this moment.
479pub(crate) fn service_of(
480 pmt: &PmtSection<'_>,
481 cmd: CaPmtCmdId,
482 built_ca_pmt: Vec<u8>,
483 pmt_raw: Vec<u8>,
484) -> ManagedService {
485 let mut ca_pids = ca_pids_in(&pmt.program_info);
486 for s in &pmt.streams {
487 ca_pids.extend(ca_pids_in(&s.es_info));
488 }
489 ManagedService {
490 es_pids: pmt.streams.iter().map(|s| s.elementary_pid).collect(),
491 ca_pids,
492 pcr_pid: pmt.pcr_pid,
493 cmd,
494 last_ca_enable: None,
495 last_descrambling_ok: false,
496 built_ca_pmt,
497 pmt_raw,
498 }
499}
500
501#[cfg(test)]
502mod tests {
503 use super::*;
504
505 #[test]
506 fn new_managed_ca_is_empty_at_default_cadence() {
507 let m = ManagedCa::new();
508 assert!(m.is_empty());
509 assert!(m.services().is_empty());
510 assert_eq!(m.requery_interval(), REQUERY_DEFAULT);
511 }
512
513 #[test]
514 fn required_pids_always_includes_the_cat_pid() {
515 let m = ManagedCa::new();
516 assert_eq!(m.required_pids(), vec![CAT_PID]);
517 }
518
519 #[test]
520 fn set_cat_keeps_every_emm_pid_of_a_shared_caid() {
521 let entry = |caid, pid| CatCaEntry {
522 ca_system_id: caid,
523 ca_pid: Pid::new(pid),
524 private_data: Vec::new(),
525 };
526 let mut m = ManagedCa::new();
527 m.set_cam_caids(BTreeSet::from([0x0650]));
528 m.set_cat(&[
529 entry(0x0650, 0x0258),
530 entry(0x0650, 0x0259),
531 entry(0x0650, 0x025A),
532 entry(0x0100, 0x0300), // CAID the CAM never advertised
533 entry(0x0650, 0x033E),
534 entry(0x0100, 0x033E), // duplicated PID under two CAIDs
535 ]);
536 assert_eq!(
537 m.emm_pids(),
538 &[
539 Pid::new(0x0258),
540 Pid::new(0x0259),
541 Pid::new(0x025A),
542 Pid::new(0x033E)
543 ]
544 );
545 }
546
547 #[test]
548 fn record_tracks_the_service() {
549 let mut m = ManagedCa::new();
550 let svc = ManagedService {
551 es_pids: vec![Pid::new(0x100), Pid::new(0x101)],
552 ca_pids: vec![Pid::new(0x0064)],
553 pcr_pid: PCR_PID_NONE,
554 cmd: CaPmtCmdId::OkDescrambling,
555 last_ca_enable: None,
556 last_descrambling_ok: false,
557 built_ca_pmt: vec![0xAA, 0xBB],
558 pmt_raw: vec![0x02, 0x00],
559 };
560 m.record(7, svc.clone());
561 assert!(!m.is_empty());
562 assert_eq!(m.services().get(&7), Some(&svc));
563 }
564
565 #[test]
566 fn ca_error_no_ca_descriptor_displays_program_number() {
567 let e = CaError::NoCaDescriptor { program_number: 42 };
568 assert!(e.to_string().contains("42"));
569 }
570
571 // --- #763 Task 5 ---
572
573 #[test]
574 fn set_requery_interval_updates_and_resets_accumulator() {
575 let mut m = ManagedCa::new();
576 assert_eq!(m.requery_interval(), REQUERY_DEFAULT);
577 m.set_requery_interval(Duration::from_secs(3));
578 assert_eq!(m.requery_interval(), Duration::from_secs(3));
579 }
580
581 #[test]
582 fn tick_fires_once_interval_elapses_and_resets() {
583 let mut m = ManagedCa::new();
584 m.set_requery_interval(Duration::from_secs(5));
585 m.record(
586 1,
587 ManagedService {
588 es_pids: vec![Pid::new(0x100)],
589 ca_pids: vec![Pid::new(0x64)],
590 pcr_pid: PCR_PID_NONE,
591 cmd: CaPmtCmdId::OkDescrambling,
592 last_ca_enable: None,
593 last_descrambling_ok: false,
594 built_ca_pmt: vec![],
595 pmt_raw: vec![],
596 },
597 );
598 assert!(
599 !m.tick(Duration::from_secs(3)),
600 "before the interval: no fire"
601 );
602 assert!(
603 m.tick(Duration::from_secs(3)),
604 "crossing the interval: fires"
605 );
606 assert!(!m.tick(Duration::from_secs(1)), "since resets after firing");
607 }
608
609 #[test]
610 fn tick_disabled_at_zero_interval_never_fires() {
611 let mut m = ManagedCa::new();
612 m.set_requery_interval(Duration::ZERO);
613 m.record(
614 1,
615 ManagedService {
616 es_pids: vec![Pid::new(0x100)],
617 ca_pids: vec![Pid::new(0x64)],
618 pcr_pid: PCR_PID_NONE,
619 cmd: CaPmtCmdId::OkDescrambling,
620 last_ca_enable: None,
621 last_descrambling_ok: false,
622 built_ca_pmt: vec![],
623 pmt_raw: vec![],
624 },
625 );
626 assert!(!m.tick(Duration::from_secs(1000)));
627 }
628
629 #[test]
630 fn tick_with_no_active_services_never_fires() {
631 let mut m = ManagedCa::new();
632 m.set_requery_interval(Duration::from_secs(1));
633 assert!(!m.tick(Duration::from_secs(1000)));
634 }
635
636 #[test]
637 fn record_reply_first_ever_some_establishes_baseline_and_reports() {
638 let mut m = ManagedCa::new();
639 m.record(
640 1,
641 ManagedService {
642 es_pids: vec![Pid::new(0x100)],
643 ca_pids: vec![Pid::new(0x64)],
644 pcr_pid: PCR_PID_NONE,
645 cmd: CaPmtCmdId::OkDescrambling,
646 last_ca_enable: None,
647 last_descrambling_ok: false,
648 built_ca_pmt: vec![],
649 pmt_raw: vec![],
650 },
651 );
652 let out = m.record_reply(1, Some(CaEnable::NotPossibleNoEntitlement), false);
653 assert_eq!(out, Some((CaEnable::NotPossibleNoEntitlement, false)));
654 }
655
656 #[test]
657 fn record_reply_unchanged_status_does_not_re_fire() {
658 let mut m = ManagedCa::new();
659 m.record(
660 1,
661 ManagedService {
662 es_pids: vec![Pid::new(0x100)],
663 ca_pids: vec![Pid::new(0x64)],
664 pcr_pid: PCR_PID_NONE,
665 cmd: CaPmtCmdId::OkDescrambling,
666 last_ca_enable: None,
667 last_descrambling_ok: false,
668 built_ca_pmt: vec![],
669 pmt_raw: vec![],
670 },
671 );
672 assert!(m.record_reply(1, Some(CaEnable::Possible), true).is_some());
673 assert_eq!(m.record_reply(1, Some(CaEnable::Possible), true), None);
674 }
675
676 #[test]
677 fn record_reply_none_never_fires_but_updates_last() {
678 let mut m = ManagedCa::new();
679 m.record(
680 1,
681 ManagedService {
682 es_pids: vec![Pid::new(0x100)],
683 ca_pids: vec![Pid::new(0x64)],
684 pcr_pid: PCR_PID_NONE,
685 cmd: CaPmtCmdId::OkDescrambling,
686 last_ca_enable: None,
687 last_descrambling_ok: false,
688 built_ca_pmt: vec![],
689 pmt_raw: vec![],
690 },
691 );
692 assert!(m.record_reply(1, Some(CaEnable::Possible), true).is_some());
693 // Withdrawn: None never fires.
694 assert_eq!(m.record_reply(1, None, false), None);
695 // Re-affirmed with the SAME value as before the withdrawal: fires
696 // again, because `last` was overwritten to `None` in between.
697 assert_eq!(
698 m.record_reply(1, Some(CaEnable::Possible), true),
699 Some((CaEnable::Possible, true))
700 );
701 }
702
703 #[test]
704 fn record_reply_unknown_program_is_a_no_op() {
705 let mut m = ManagedCa::new();
706 assert_eq!(m.record_reply(99, Some(CaEnable::Possible), true), None);
707 }
708
709 // --- #763 Task 6: remove + clear ---
710
711 #[test]
712 fn remove_drops_tracked_service_and_recomputes_descramble_pids_false_for_untracked() {
713 let mut m = ManagedCa::new();
714 m.record(
715 1,
716 ManagedService {
717 es_pids: vec![Pid::new(0x100), Pid::new(0x101)],
718 ca_pids: vec![Pid::new(0x64)],
719 pcr_pid: PCR_PID_NONE,
720 cmd: CaPmtCmdId::OkDescrambling,
721 last_ca_enable: None,
722 last_descrambling_ok: false,
723 built_ca_pmt: vec![],
724 pmt_raw: vec![],
725 },
726 );
727 m.record(
728 2,
729 ManagedService {
730 es_pids: vec![Pid::new(0x200)],
731 ca_pids: vec![Pid::new(0x65)],
732 pcr_pid: PCR_PID_NONE,
733 cmd: CaPmtCmdId::OkDescrambling,
734 last_ca_enable: None,
735 last_descrambling_ok: false,
736 built_ca_pmt: vec![],
737 pmt_raw: vec![],
738 },
739 );
740
741 assert!(
742 !m.remove(99),
743 "removing an untracked program_number must return false"
744 );
745 assert_eq!(
746 m.services().len(),
747 2,
748 "an untracked remove must not disturb the tracked set"
749 );
750
751 assert!(
752 m.remove(1),
753 "removing a tracked program_number must return true"
754 );
755 assert!(m.services().get(&1).is_none());
756 assert_eq!(
757 m.descramble_pids(),
758 &[Pid::new(0x200)],
759 "descramble_pids must recompute (drop program 1's PIDs) after remove"
760 );
761 }
762
763 #[test]
764 fn clear_resets_module_state_but_preserves_requery_interval() {
765 use dvb_si::tables::cat::CatCaEntry;
766
767 let mut m = ManagedCa::new();
768 m.set_requery_interval(Duration::from_secs(3));
769 m.record(
770 1,
771 ManagedService {
772 es_pids: vec![Pid::new(0x100)],
773 ca_pids: vec![Pid::new(0x64)],
774 pcr_pid: PCR_PID_NONE,
775 cmd: CaPmtCmdId::OkDescrambling,
776 last_ca_enable: None,
777 last_descrambling_ok: false,
778 built_ca_pmt: vec![],
779 pmt_raw: vec![],
780 },
781 );
782 m.set_cat(&[CatCaEntry {
783 ca_system_id: 0x0648,
784 ca_pid: Pid::new(0x1FF0),
785 private_data: Vec::new(),
786 }]);
787 m.set_cam_caids([0x0648].into_iter().collect());
788 assert!(!m.emm_pids().is_empty(), "precondition: emm_pids populated");
789 assert!(
790 !m.descramble_pids().is_empty(),
791 "precondition: descramble_pids populated"
792 );
793
794 m.clear();
795
796 assert!(m.services().is_empty(), "services must be cleared");
797 assert!(m.emm_pids().is_empty(), "emm_pids must be cleared");
798 assert!(
799 m.descramble_pids().is_empty(),
800 "descramble_pids must be cleared"
801 );
802 assert!(m.ca_pids().is_empty(), "ca_pids must be cleared");
803 assert_eq!(
804 m.requery_interval(),
805 Duration::from_secs(3),
806 "requery_interval is host config, must survive clear()"
807 );
808 }
809
810 // --- #763 Task 7: ca_pids()/required_pids() ---
811
812 #[test]
813 fn ca_pids_is_the_dedup_sorted_union_of_active_services_and_required_pids_unions_all_three() {
814 use dvb_si::tables::cat::CatCaEntry;
815
816 let mut m = ManagedCa::new();
817 m.record(
818 1,
819 ManagedService {
820 es_pids: vec![Pid::new(0x0100), Pid::new(0x0101)],
821 ca_pids: vec![Pid::new(0x0064), Pid::new(0x0065)],
822 pcr_pid: PCR_PID_NONE,
823 cmd: CaPmtCmdId::OkDescrambling,
824 last_ca_enable: None,
825 last_descrambling_ok: false,
826 built_ca_pmt: vec![],
827 pmt_raw: vec![],
828 },
829 );
830 m.record(
831 2,
832 ManagedService {
833 es_pids: vec![Pid::new(0x0200)],
834 // Shares 0x0065 with program 1 to prove dedup, plus a
835 // distinct 0x0066.
836 ca_pids: vec![Pid::new(0x0065), Pid::new(0x0066)],
837 pcr_pid: PCR_PID_NONE,
838 cmd: CaPmtCmdId::OkDescrambling,
839 last_ca_enable: None,
840 last_descrambling_ok: false,
841 built_ca_pmt: vec![],
842 pmt_raw: vec![],
843 },
844 );
845
846 assert_eq!(
847 m.ca_pids(),
848 &[Pid::new(0x0064), Pid::new(0x0065), Pid::new(0x0066)],
849 "ca_pids must be the dedup+sorted union of both services' ca_pids"
850 );
851
852 // Populate emm_pids too (CAT ∩ ca_info CAIDs), so required_pids
853 // exercises all three classes.
854 m.set_cat(&[CatCaEntry {
855 ca_system_id: 0x0648,
856 ca_pid: Pid::new(0x1FF0),
857 private_data: Vec::new(),
858 }]);
859 m.set_cam_caids([0x0648].into_iter().collect());
860 assert_eq!(
861 m.emm_pids(),
862 &[Pid::new(0x1FF0)],
863 "precondition: emm_pids populated"
864 );
865
866 assert_eq!(
867 m.required_pids(),
868 vec![
869 CAT_PID,
870 Pid::new(0x0064),
871 Pid::new(0x0065),
872 Pid::new(0x0066),
873 Pid::new(0x0100),
874 Pid::new(0x0101),
875 Pid::new(0x0200),
876 Pid::new(0x1FF0)
877 ],
878 "required_pids must be CAT ∪ descramble_pids ∪ ca_pids ∪ emm_pids"
879 );
880 }
881
882 // --- #763 final-review Fix 1: dedicated PCR PID routing ---
883
884 #[test]
885 fn service_of_captures_pcr_pid_and_required_pids_includes_dedicated_pcr() {
886 use broadcast_common::Parse;
887 use dvb_si::tables::pmt::PmtSection;
888
889 // A PMT whose PCR is carried on its own dedicated PID (0x00FF),
890 // distinct from every ES PID (0x0100/0x0101) and CA PID (0x0064/
891 // 0x0065) — a legitimate DVB config `service_of` must not lose.
892 let pmt_bytes = crate::driver::tests::build_ca_pmt_fixture_dedicated_pcr(1550);
893 let pmt = PmtSection::parse(&pmt_bytes).unwrap();
894 assert_eq!(
895 pmt.pcr_pid,
896 Pid::new(0x00FF),
897 "fixture precondition: dedicated PCR PID outside the ES/CA set"
898 );
899
900 let svc = service_of(&pmt, CaPmtCmdId::OkDescrambling, vec![], vec![]);
901 assert_eq!(
902 svc.pcr_pid,
903 Pid::new(0x00FF),
904 "service_of must capture pmt.pcr_pid"
905 );
906 assert_eq!(svc.es_pids, vec![Pid::new(0x0100), Pid::new(0x0101)]);
907 assert_eq!(svc.ca_pids, vec![Pid::new(0x0064), Pid::new(0x0065)]);
908
909 let mut m = ManagedCa::new();
910 m.record(1550, svc);
911
912 // Bite: without folding pcr_pid into required_pids, this PID is
913 // absent (it's neither an ES nor a CA nor an EMM PID) and the
914 // dedicated PCR clock reference never reaches ci0.
915 assert!(
916 m.required_pids().contains(&Pid::new(0x00FF)),
917 "required_pids must include the service's dedicated PCR PID, got {:?}",
918 m.required_pids()
919 );
920 }
921
922 #[test]
923 fn required_pids_excludes_pcr_pid_none() {
924 let mut m = ManagedCa::new();
925 m.record(
926 1,
927 ManagedService {
928 es_pids: vec![Pid::new(0x0100)],
929 ca_pids: vec![Pid::new(0x0064)],
930 // PCR_PID_NONE (0x1FFF, ISO/IEC 13818-1 §2.4.4.8) — this
931 // programme carries no PCR of its own.
932 pcr_pid: PCR_PID_NONE,
933 cmd: CaPmtCmdId::OkDescrambling,
934 last_ca_enable: None,
935 last_descrambling_ok: false,
936 built_ca_pmt: vec![],
937 pmt_raw: vec![],
938 },
939 );
940 assert_eq!(
941 m.required_pids(),
942 vec![CAT_PID, Pid::new(0x0064), Pid::new(0x0100)],
943 "PCR_PID_NONE (0x1FFF) must never be added to required_pids"
944 );
945 }
946
947 #[test]
948 fn required_pids_pcr_pid_matching_an_es_pid_adds_no_spurious_pid() {
949 let mut m = ManagedCa::new();
950 m.record(
951 1,
952 ManagedService {
953 es_pids: vec![Pid::new(0x0100)],
954 ca_pids: vec![Pid::new(0x0064)],
955 // PCR piggybacked on the ES PID (the common case, already
956 // covered by every other fixture in this file) — must not
957 // produce a duplicate/spurious entry.
958 pcr_pid: Pid::new(0x0100),
959 cmd: CaPmtCmdId::OkDescrambling,
960 last_ca_enable: None,
961 last_descrambling_ok: false,
962 built_ca_pmt: vec![],
963 pmt_raw: vec![],
964 },
965 );
966 assert_eq!(
967 m.required_pids(),
968 vec![CAT_PID, Pid::new(0x0064), Pid::new(0x0100)],
969 "a pcr_pid coinciding with an ES PID must not duplicate/add a spurious entry"
970 );
971 }
972}