dvb_ci_runtime/
driver.rs

1//! The driver — the one place I/O happens. It pumps a [`CaDevice`] against the
2//! sans-IO [`CiStack`]: reads frames in, executes the stack's [`Action`]s
3//! (writes/ioctls) out, tracks the requested poll timer, and collects
4//! [`Notification`]s for the host application.
5
6use std::io;
7use std::time::Duration;
8
9use crate::device::CaDevice;
10use crate::event::{Action, Event, HostRequest, Notification};
11use crate::stack::CiStack;
12
13/// Drives a [`CaDevice`] with the [`CiStack`].
14pub struct Driver<D: CaDevice> {
15    device: D,
16    stack: CiStack,
17    notifications: Vec<Notification>,
18    /// Delay the stack last asked to be polled after (`None` = none pending).
19    next_timer: Option<Duration>,
20    /// Read buffer for one link-layer frame.
21    buf: Vec<u8>,
22}
23
24impl<D: CaDevice> Driver<D> {
25    /// New driver over `device`, single transport connection.
26    #[must_use]
27    pub fn new(device: D) -> Self {
28        Self {
29            device,
30            stack: CiStack::new(),
31            notifications: Vec::new(),
32            next_timer: None,
33            buf: vec![0u8; 4096],
34        }
35    }
36
37    /// Borrow the underlying device (e.g. to inspect a mock's recorded ops).
38    pub fn device(&self) -> &D {
39        &self.device
40    }
41
42    /// The poll delay the stack most recently requested, if any.
43    pub fn next_timer(&self) -> Option<Duration> {
44        self.next_timer
45    }
46
47    /// Drain the notifications collected so far.
48    pub fn take_notifications(&mut self) -> Vec<Notification> {
49        core::mem::take(&mut self.notifications)
50    }
51
52    /// Bring the interface up (reset + open the transport connection).
53    pub fn init(&mut self) -> io::Result<()> {
54        let actions = self.stack.handle(Event::Host(HostRequest::Init));
55        self.run(actions)
56    }
57
58    /// Request the module descramble the services in `ca_pmt` (a serialized
59    /// `ca_pmt` APDU body, e.g. from `dvb_ci::build_ca_pmt`).
60    pub fn send_ca_pmt(&mut self, ca_pmt: &[u8]) -> io::Result<()> {
61        let actions = self
62            .stack
63            .handle(Event::Host(HostRequest::SendCaPmt(ca_pmt)));
64        self.run(actions)
65    }
66
67    /// Descramble the services in a PMT section: the stack filters the PMT's
68    /// `CA_descriptor`s to the CAM's advertised CAIDs, sends a `ca_pmt` query,
69    /// and auto-sends `ok_descrambling` once the `ca_pmt_reply` confirms it.
70    /// Drive [`pump`](Self::pump) afterwards to exchange the reply; the outcome
71    /// surfaces as [`Notification::CaPmtReply`]. Call after the CAM is ready and
72    /// its `ca_info` has been received (otherwise no CAID filter is applied).
73    pub fn descramble(&mut self, pmt_section: &[u8]) -> io::Result<()> {
74        let actions = self
75            .stack
76            .handle(Event::Host(HostRequest::Descramble(pmt_section)));
77        self.run(actions)
78    }
79
80    /// Answer an MMI menu/list by 1-based `choice_ref` (0 = back/cancel).
81    pub fn mmi_menu_answer(&mut self, choice_ref: u8) -> io::Result<()> {
82        let actions = self
83            .stack
84            .handle(Event::Host(HostRequest::MmiMenuAnswer(choice_ref)));
85        self.run(actions)
86    }
87
88    /// Answer an MMI enquiry with the user's input (EN 300 468 Annex A bytes).
89    pub fn mmi_enquiry_answer(&mut self, text: &[u8]) -> io::Result<()> {
90        let actions = self
91            .stack
92            .handle(Event::Host(HostRequest::MmiEnquiryAnswer(text)));
93        self.run(actions)
94    }
95
96    /// Abort the current MMI dialogue (`answ` with `answ_id = cancel`).
97    pub fn mmi_cancel(&mut self) -> io::Result<()> {
98        let actions = self.stack.handle(Event::Host(HostRequest::MmiCancel));
99        self.run(actions)
100    }
101
102    /// Ask the module to open its MMI menu (`enter_menu`) — e.g. to read card /
103    /// entitlement info from the module's own menus.
104    pub fn enter_menu(&mut self) -> io::Result<()> {
105        let actions = self.stack.handle(Event::Host(HostRequest::EnterMenu));
106        self.run(actions)
107    }
108
109    /// One pump step: if the device is readable within `timeout`, read a frame
110    /// and feed it; otherwise advance the stack's timers by `timeout` (driving
111    /// the poll cadence). Returns whether a frame was processed.
112    pub fn pump(&mut self, timeout: Duration) -> io::Result<bool> {
113        if self.device.poll(timeout)? {
114            let n = self.device.read(&mut self.buf)?;
115            if n > 0 {
116                let frame = self.buf[..n].to_vec();
117                let actions = self.stack.handle(Event::Readable(&frame));
118                self.run(actions)?;
119                return Ok(true);
120            }
121        }
122        let actions = self.stack.handle(Event::Tick { elapsed: timeout });
123        self.run(actions)?;
124        Ok(false)
125    }
126
127    /// Execute the stack's actions against the device.
128    fn run(&mut self, actions: Vec<Action>) -> io::Result<()> {
129        for action in actions {
130            match action {
131                Action::Write(bytes) => self.device.write(&bytes)?,
132                Action::Reset => self.device.reset()?,
133                Action::QuerySlot => {
134                    self.device.slot_info()?;
135                }
136                Action::SetTimer { after } => self.next_timer = Some(after),
137                Action::Notify(n) => self.notifications.push(n),
138            }
139        }
140        Ok(())
141    }
142}
143
144#[cfg(test)]
145mod tests {
146    use super::*;
147    use crate::device::{DeviceOp, MockCaDevice};
148    use dvb_ci::tpdu::tags;
149
150    #[test]
151    fn init_drives_reset_slotinfo_and_create_tc_to_device() {
152        let mut d = Driver::new(MockCaDevice::new([]));
153        d.init().unwrap();
154        let ops = &d.device().ops;
155        assert_eq!(ops[0], DeviceOp::Reset);
156        assert_eq!(ops[1], DeviceOp::SlotInfo);
157        assert!(matches!(&ops[2], DeviceOp::Write(w) if w[0] == tags::CREATE_T_C));
158    }
159
160    #[test]
161    fn reads_reply_then_polls_on_pump() {
162        // Script the module accepting the connection.
163        let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
164        let mut d = Driver::new(dev);
165        d.init().unwrap();
166        // first pump reads the C_T_C_Reply (activates the connection)
167        assert!(d.pump(Duration::from_millis(100)).unwrap());
168        // next pump has nothing to read → ticks → emits a poll write
169        assert!(!d.pump(Duration::from_millis(100)).unwrap());
170        let last = d.device().ops.last().unwrap();
171        assert!(matches!(last, DeviceOp::Write(w) if w.first() == Some(&tags::DATA_LAST)));
172    }
173}
dvb_ci_runtime/driver.rs

dvb_ci_runtime/
driver.rs
