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    /// One pump step: if the device is readable within `timeout`, read a frame
81    /// and feed it; otherwise advance the stack's timers by `timeout` (driving
82    /// the poll cadence). Returns whether a frame was processed.
83    pub fn pump(&mut self, timeout: Duration) -> io::Result<bool> {
84        if self.device.poll(timeout)? {
85            let n = self.device.read(&mut self.buf)?;
86            if n > 0 {
87                let frame = self.buf[..n].to_vec();
88                let actions = self.stack.handle(Event::Readable(&frame));
89                self.run(actions)?;
90                return Ok(true);
91            }
92        }
93        let actions = self.stack.handle(Event::Tick { elapsed: timeout });
94        self.run(actions)?;
95        Ok(false)
96    }
97
98    /// Execute the stack's actions against the device.
99    fn run(&mut self, actions: Vec<Action>) -> io::Result<()> {
100        for action in actions {
101            match action {
102                Action::Write(bytes) => self.device.write(&bytes)?,
103                Action::Reset => self.device.reset()?,
104                Action::QuerySlot => {
105                    self.device.slot_info()?;
106                }
107                Action::SetTimer { after } => self.next_timer = Some(after),
108                Action::Notify(n) => self.notifications.push(n),
109            }
110        }
111        Ok(())
112    }
113}
114
115#[cfg(test)]
116mod tests {
117    use super::*;
118    use crate::device::{DeviceOp, MockCaDevice};
119    use dvb_ci::tpdu::tags;
120
121    #[test]
122    fn init_drives_reset_slotinfo_and_create_tc_to_device() {
123        let mut d = Driver::new(MockCaDevice::new([]));
124        d.init().unwrap();
125        let ops = &d.device().ops;
126        assert_eq!(ops[0], DeviceOp::Reset);
127        assert_eq!(ops[1], DeviceOp::SlotInfo);
128        assert!(matches!(&ops[2], DeviceOp::Write(w) if w[0] == tags::CREATE_T_C));
129    }
130
131    #[test]
132    fn reads_reply_then_polls_on_pump() {
133        // Script the module accepting the connection.
134        let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
135        let mut d = Driver::new(dev);
136        d.init().unwrap();
137        // first pump reads the C_T_C_Reply (activates the connection)
138        assert!(d.pump(Duration::from_millis(100)).unwrap());
139        // next pump has nothing to read → ticks → emits a poll write
140        assert!(!d.pump(Duration::from_millis(100)).unwrap());
141        let last = d.device().ops.last().unwrap();
142        assert!(matches!(last, DeviceOp::Write(w) if w.first() == Some(&tags::DATA_LAST)));
143    }
144}
dvb_ci_runtime/driver.rs

dvb_ci_runtime/
driver.rs
