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())
}