Struct Driver 

pub struct Driver<D: CaDevice> { /* private fields */ }

Drives a CaDevice with the CiStack.

Implementations

impl<D: CaDevice> Driver<D>

pub fn new(device: D) -> Self

New driver over device, single transport connection.

Examples found in repository

examples/mock_cam_session.rs (line 18)

fn main() -> std::io::Result<()> {
    // Script a module that accepts the transport connection (C_T_C_Reply).
    let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
    let mut driver = Driver::new(dev);

    // Bring the interface up: reset + open the transport connection.
    driver.init()?;
    println!("init: sent {} device op(s)", driver.device().ops.len());

    // Pump the device. When readable it reads a frame and feeds the stack;
    // otherwise it advances the EN 50221 poll cadence by the timeout.
    for step in 0..5 {
        let read = driver.pump(Duration::from_millis(100))?;
        println!("pump {step}: processed_frame={read}");
    }

    // Anything the host application needs to act on surfaces as a Notification.
    for note in driver.take_notifications() {
        match note {
            Notification::CamReady => println!("note: CAM ready — safe to send ca_pmt"),
            Notification::ApplicationInfo { menu, .. } => {
                println!("note: application_information menu={menu:?}")
            }
            Notification::CaInfo { ca_system_ids } => {
                println!("note: ca_info system_ids={ca_system_ids:?}")
            }
            other => println!("note: {other:?}"),
        }
    }

    // The mock records every device op (writes/ioctls) — handy for assertions.
    println!("total recorded device ops: {}", driver.device().ops.len());
    Ok(())
}

pub fn device(&self) -> &D

Borrow the underlying device (e.g. to inspect a mock’s recorded ops).

Examples found in repository

examples/mock_cam_session.rs (line 22)

fn main() -> std::io::Result<()> {
    // Script a module that accepts the transport connection (C_T_C_Reply).
    let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
    let mut driver = Driver::new(dev);

    // Bring the interface up: reset + open the transport connection.
    driver.init()?;
    println!("init: sent {} device op(s)", driver.device().ops.len());

    // Pump the device. When readable it reads a frame and feeds the stack;
    // otherwise it advances the EN 50221 poll cadence by the timeout.
    for step in 0..5 {
        let read = driver.pump(Duration::from_millis(100))?;
        println!("pump {step}: processed_frame={read}");
    }

    // Anything the host application needs to act on surfaces as a Notification.
    for note in driver.take_notifications() {
        match note {
            Notification::CamReady => println!("note: CAM ready — safe to send ca_pmt"),
            Notification::ApplicationInfo { menu, .. } => {
                println!("note: application_information menu={menu:?}")
            }
            Notification::CaInfo { ca_system_ids } => {
                println!("note: ca_info system_ids={ca_system_ids:?}")
            }
            other => println!("note: {other:?}"),
        }
    }

    // The mock records every device op (writes/ioctls) — handy for assertions.
    println!("total recorded device ops: {}", driver.device().ops.len());
    Ok(())
}

pub fn next_timer(&self) -> Option<Duration>

The poll delay the stack most recently requested, if any.

pub fn take_notifications(&mut self) -> Vec<Notification>

Drain the notifications collected so far.

Examples found in repository

examples/mock_cam_session.rs (line 32)

fn main() -> std::io::Result<()> {
    // Script a module that accepts the transport connection (C_T_C_Reply).
    let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
    let mut driver = Driver::new(dev);

    // Bring the interface up: reset + open the transport connection.
    driver.init()?;
    println!("init: sent {} device op(s)", driver.device().ops.len());

    // Pump the device. When readable it reads a frame and feeds the stack;
    // otherwise it advances the EN 50221 poll cadence by the timeout.
    for step in 0..5 {
        let read = driver.pump(Duration::from_millis(100))?;
        println!("pump {step}: processed_frame={read}");
    }

    // Anything the host application needs to act on surfaces as a Notification.
    for note in driver.take_notifications() {
        match note {
            Notification::CamReady => println!("note: CAM ready — safe to send ca_pmt"),
            Notification::ApplicationInfo { menu, .. } => {
                println!("note: application_information menu={menu:?}")
            }
            Notification::CaInfo { ca_system_ids } => {
                println!("note: ca_info system_ids={ca_system_ids:?}")
            }
            other => println!("note: {other:?}"),
        }
    }

    // The mock records every device op (writes/ioctls) — handy for assertions.
    println!("total recorded device ops: {}", driver.device().ops.len());
    Ok(())
}

pub fn init(&mut self) -> Result<()>

Bring the interface up (reset + open the transport connection).

Examples found in repository

examples/mock_cam_session.rs (line 21)

fn main() -> std::io::Result<()> {
    // Script a module that accepts the transport connection (C_T_C_Reply).
    let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
    let mut driver = Driver::new(dev);

    // Bring the interface up: reset + open the transport connection.
    driver.init()?;
    println!("init: sent {} device op(s)", driver.device().ops.len());

    // Pump the device. When readable it reads a frame and feeds the stack;
    // otherwise it advances the EN 50221 poll cadence by the timeout.
    for step in 0..5 {
        let read = driver.pump(Duration::from_millis(100))?;
        println!("pump {step}: processed_frame={read}");
    }

    // Anything the host application needs to act on surfaces as a Notification.
    for note in driver.take_notifications() {
        match note {
            Notification::CamReady => println!("note: CAM ready — safe to send ca_pmt"),
            Notification::ApplicationInfo { menu, .. } => {
                println!("note: application_information menu={menu:?}")
            }
            Notification::CaInfo { ca_system_ids } => {
                println!("note: ca_info system_ids={ca_system_ids:?}")
            }
            other => println!("note: {other:?}"),
        }
    }

    // The mock records every device op (writes/ioctls) — handy for assertions.
    println!("total recorded device ops: {}", driver.device().ops.len());
    Ok(())
}

pub fn send_ca_pmt(&mut self, ca_pmt: &[u8]) -> Result<()>

Request the module descramble the services in ca_pmt (a serialized ca_pmt APDU body, e.g. from dvb_ci::build_ca_pmt).

pub fn descramble(&mut self, pmt_section: &[u8]) -> Result<()>

Descramble the services in a PMT section: the stack filters the PMT’s CA_descriptors to the CAM’s advertised CAIDs, sends a ca_pmt query, and auto-sends ok_descrambling once the ca_pmt_reply confirms it. Drive pump afterwards to exchange the reply; the outcome surfaces as Notification::CaPmtReply. Call after the CAM is ready and its ca_info has been received (otherwise no CAID filter is applied).

pub fn mmi_menu_answer(&mut self, choice_ref: u8) -> Result<()>

Answer an MMI menu/list by 1-based choice_ref (0 = back/cancel).

pub fn mmi_enquiry_answer(&mut self, text: &[u8]) -> Result<()>

Answer an MMI enquiry with the user’s input (EN 300 468 Annex A bytes).

pub fn mmi_cancel(&mut self) -> Result<()>

Abort the current MMI dialogue (answ with answ_id = cancel).

pub fn enter_menu(&mut self) -> Result<()>

Ask the module to open its MMI menu (enter_menu) — e.g. to read card / entitlement info from the module’s own menus.

pub fn pump(&mut self, timeout: Duration) -> Result<bool>

One pump step: if the device is readable within timeout, read a frame and feed it; otherwise advance the stack’s timers by timeout (driving the poll cadence). Returns whether a frame was processed.

Examples found in repository

examples/mock_cam_session.rs (line 27)

fn main() -> std::io::Result<()> {
    // Script a module that accepts the transport connection (C_T_C_Reply).
    let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
    let mut driver = Driver::new(dev);

    // Bring the interface up: reset + open the transport connection.
    driver.init()?;
    println!("init: sent {} device op(s)", driver.device().ops.len());

    // Pump the device. When readable it reads a frame and feeds the stack;
    // otherwise it advances the EN 50221 poll cadence by the timeout.
    for step in 0..5 {
        let read = driver.pump(Duration::from_millis(100))?;
        println!("pump {step}: processed_frame={read}");
    }

    // Anything the host application needs to act on surfaces as a Notification.
    for note in driver.take_notifications() {
        match note {
            Notification::CamReady => println!("note: CAM ready — safe to send ca_pmt"),
            Notification::ApplicationInfo { menu, .. } => {
                println!("note: application_information menu={menu:?}")
            }
            Notification::CaInfo { ca_system_ids } => {
                println!("note: ca_info system_ids={ca_system_ids:?}")
            }
            other => println!("note: {other:?}"),
        }
    }

    // The mock records every device op (writes/ioctls) — handy for assertions.
    println!("total recorded device ops: {}", driver.device().ops.len());
    Ok(())
}