simulcrypt 0.2.2

DVB SimulCrypt (ETSI TS 103 197) head-end protocol: ECMG client, EMMG server, control words
Documentation
//! ECM carousel: `Event::Ts` on `ecm_pid`, repetition period, continuity counter.

use libmpegts::ts::TsPacketRef;

use super::*;

/// ECM section carrying its crypto period number.
fn ecm_section(cp_number: u16) -> Vec<u8> {
    let [hi, lo] = cp_number.to_be_bytes();
    vec![0x80 | (cp_number & 1) as u8, 0x70, 0x02, hi, lo]
}

/// One TS packet on PID 0x1FFF carrying the crypto period number.
fn ecm_ts_packet(cp_number: u16) -> Vec<u8> {
    let mut packet = vec![0xFF; 188];
    packet[.. 4].copy_from_slice(&[0x47, 0x5F, 0xFF, 0x10]);
    packet[4 .. 6].copy_from_slice(&cp_number.to_be_bytes());
    packet
}

async fn open(
    simulcrypt: &Simulcrypt,
    section_ts_pkt_flag: u8,
    rep_period: Option<u16>,
    ecm: fn(u16) -> Vec<u8>,
    ecm_pids: &[u16],
) -> (CasLease, simulcrypt::Service) {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    tokio::spawn(ecmg_peer(listener, 1, section_ts_pkt_flag, rep_period, ecm));
    let lease = simulcrypt
        .acquire_cas(CasConfig {
            id: format!("cas-carousel-{port}"),
            name: "carousel".into(),
            super_cas_id: 0x0900_0001,
            first_stream_id: 1,
            ecmg: EcmgConfig::new(1, SocketAddr::from(([127, 0, 0, 1], port))),
            emmg: None,
        })
        .expect("acquire_cas");
    let service = simulcrypt
        .open_service(&ServiceConfig {
            name: "svc-carousel".into(),
            crypto_period: Duration::from_millis(300),
            cas: ecm_pids
                .iter()
                .map(|&ecm_pid| ServiceCas {
                    cas: lease.cas(),
                    ecm_pid,
                    access_criteria: vec![],
                })
                .collect(),
        })
        .expect("open_service");
    (lease, service)
}

async fn next_ts(service: &mut simulcrypt::Service) -> Vec<[u8; 188]> {
    loop {
        if let Event::Ts(packets) = service.recv().await.expect("service closed unexpectedly") {
            return packets;
        }
    }
}

/// The carousel repeats the current section ECM on `ecm_pid` at the ECMG's `rep_period`, picks up
/// every new ECM, and keeps the continuity counter running across both.
#[tokio::test]
async fn carousel_repeats_the_current_ecm_at_rep_period() {
    let simulcrypt = Simulcrypt::new();
    let (_lease, mut service) = open(&simulcrypt, 0x00, Some(40), ecm_section, &[0x0100]).await;

    let first = tokio::time::timeout(Duration::from_secs(5), next_ts(&mut service))
        .await
        .expect("first carousel packet");
    let started = tokio::time::Instant::now();
    let mut packets = vec![first[0]];
    while packets.len() < 25 {
        let ts = tokio::time::timeout(Duration::from_secs(5), next_ts(&mut service))
            .await
            .expect("carousel packet");
        assert_eq!(ts.len(), 1);
        packets.push(ts[0]);
    }
    let elapsed = started.elapsed();

    // 24 periods of 40 ms; at the default 100 ms they would take 2.4 s.
    assert!(
        elapsed >= Duration::from_millis(23 * 40) && elapsed < Duration::from_millis(1700),
        "24 repetitions took {elapsed:?}"
    );

    let first_cc = TsPacketRef::from(&packets[0]).cc();
    let mut cp_numbers = Vec::new();
    for (index, packet) in packets.iter().enumerate() {
        let packet = TsPacketRef::from(packet);
        assert_eq!(packet.pid(), 0x0100);
        assert_eq!(
            packet.cc(),
            (first_cc + index as u8) & 0x0F,
            "continuity counter"
        );
        assert!(packet.is_payload_start());
        let payload = packet.payload().unwrap();
        assert_eq!(payload[0], 0, "pointer field");
        let cp_number = u16::from_be_bytes([payload[4], payload[5]]);
        assert_eq!(&payload[1 .. 6], ecm_section(cp_number));
        assert!(payload[6 ..].iter().all(|&byte| byte == 0xFF));
        if !cp_numbers.contains(&cp_number) {
            cp_numbers.push(cp_number);
        }
    }
    assert!(
        cp_numbers.len() >= 2,
        "the ECM of a new crypto period must replace the old one: {cp_numbers:?}"
    );
}

/// ECM in TS packets keep everything but the PID, which becomes `ecm_pid`. A stream on a PID that
/// cannot carry ECM gets raw `Event::Ecm` only.
#[tokio::test]
async fn carousel_restamps_ts_packets_and_skips_reserved_pids() {
    let simulcrypt = Simulcrypt::new();
    let (_lease, mut service) =
        open(&simulcrypt, 0x01, None, ecm_ts_packet, &[0x0200, 0x0000]).await;
    let reserved = service
        .streams()
        .iter()
        .find(|info| info.ecm_pid == 0)
        .unwrap()
        .stream_id;

    let mut ts = 0;
    let mut raw_on_reserved = false;
    tokio::time::timeout(Duration::from_secs(5), async {
        while ts < 5 || !raw_on_reserved {
            match service.recv().await.expect("service closed unexpectedly") {
                Event::Ts(packets) => {
                    for packet in &packets {
                        let packet = TsPacketRef::from(packet);
                        assert_eq!(packet.pid(), 0x0200);
                        assert!(packet.is_payload_start());
                        assert_eq!(packet.payload().unwrap()[2 ..], [0xFF; 182]);
                    }
                    ts += 1;
                }
                Event::Ecm { stream_id, .. } if stream_id == reserved => raw_on_reserved = true,
                _ => {}
            }
        }
    })
    .await
    .expect("carousel packets and the raw ECM of the reserved PID");
}