rustduck-core 1.1.0

Safe typed TSDuck core bindings for rustduck
Documentation
//! Pure callback-protocol validation and typed endpoint routing.

use crate::transport_stream::TS_PACKET_SIZE;

use crate::memory::endpoint::CallbackError;
use crate::memory::registry::{self, RegisteredEndpoint};

#[derive(Clone, Copy)]
pub(super) enum CallbackDirection {
    Input,
    Output,
}

pub(super) struct CallbackRequest<'a> {
    pub(super) event_code: u32,
    pub(super) plugin_name_utf16: &'a [u8],
    pub(super) direction: CallbackDirection,
    pub(super) data: &'a [u8],
    pub(super) writable_capacity: usize,
    pub(super) plugin_name_valid: bool,
    pub(super) data_valid: bool,
    pub(super) event_data_valid: bool,
}

pub(super) enum CallbackResponse {
    Input(Option<Vec<u8>>),
    Output,
}

pub(super) fn dispatch(request: CallbackRequest<'_>) -> Option<CallbackResponse> {
    let endpoint = registry::lookup(request.event_code)?;
    if !request.plugin_name_valid {
        record(&endpoint, CallbackError::InvalidPluginName);
        return None;
    }
    if !is_memory_plugin(request.plugin_name_utf16) {
        record(&endpoint, CallbackError::WrongPlugin);
        return None;
    }
    if !request.data_valid {
        record(&endpoint, CallbackError::InvalidEventBuffer);
        return None;
    }

    match (endpoint, request.direction) {
        (RegisteredEndpoint::Input(endpoint), CallbackDirection::Input) => {
            route_input(endpoint, request)
        }
        (RegisteredEndpoint::Output(endpoint), CallbackDirection::Output) => {
            route_output(endpoint, request)
        }
        (endpoint, _) => {
            record(&endpoint, CallbackError::InvalidEventDirection);
            None
        }
    }
}

fn route_input(
    endpoint: std::sync::Arc<crate::memory::endpoint::MemoryInputInner>,
    request: CallbackRequest<'_>,
) -> Option<CallbackResponse> {
    if !request.event_data_valid || !request.data.is_empty() || request.writable_capacity == 0 {
        endpoint.record_callback_error(CallbackError::InvalidEventBuffer);
        return None;
    }
    if request.writable_capacity % TS_PACKET_SIZE != 0 {
        endpoint.record_callback_error(CallbackError::InvalidPacketAlignment);
        return None;
    }
    match endpoint.take_for_callback(request.writable_capacity) {
        Ok(data) => Some(CallbackResponse::Input(data)),
        Err(_) => {
            endpoint.record_callback_error(CallbackError::QueueAborted);
            None
        }
    }
}

fn route_output(
    endpoint: std::sync::Arc<crate::memory::endpoint::MemoryOutputInner>,
    request: CallbackRequest<'_>,
) -> Option<CallbackResponse> {
    if request.writable_capacity != 0 {
        endpoint.record_callback_error(CallbackError::InvalidEventBuffer);
        return None;
    }
    if request.data.len() % TS_PACKET_SIZE != 0 {
        endpoint.record_callback_error(CallbackError::InvalidPacketAlignment);
        return None;
    }
    match endpoint.push_from_callback(request.data) {
        Ok(_) => Some(CallbackResponse::Output),
        Err(_) => {
            endpoint.record_callback_error(CallbackError::QueueAborted);
            None
        }
    }
}

pub(super) fn record(endpoint: &RegisteredEndpoint, error: CallbackError) {
    match endpoint {
        RegisteredEndpoint::Input(endpoint) => endpoint.record_callback_error(error),
        RegisteredEndpoint::Output(endpoint) => endpoint.record_callback_error(error),
    }
}

fn is_memory_plugin(value: &[u8]) -> bool {
    if value.len() % size_of::<u16>() != 0 {
        return false;
    }
    let units = value
        .chunks_exact(size_of::<u16>())
        .map(|bytes| u16::from_ne_bytes([bytes[0], bytes[1]]));
    let mut units = units.peekable();
    if units.peek() == Some(&0xfeff) {
        units.next();
    }
    units.eq("memory".encode_utf16())
}