servicepoint-binding-c/src/packet.rs

//! C functions for interacting with [SPPacket]s
//!
//! prefix `sp_packet_`
//!
//!
//! The raw packet

use crate::SPByteSlice;
use servicepoint::{Header, Packet, TypedCommand};
use std::ptr::NonNull;

/// Turns a [SPCommand] into a [SPPacket].
/// The [SPCommand] gets consumed.
///
/// Will never return NULL.
///
/// # Panics
///
/// - when `command` is NULL
///
/// # Safety
///
/// The caller has to make sure that:
///
/// - [SPCommand] points to a valid instance of [SPCommand]
/// - [SPCommand] is not used concurrently or after this call
/// - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
///   by explicitly calling `sp_packet_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_packet_from_command(
    command: *mut TypedCommand,
) -> *mut Packet {
    assert!(!command.is_null());
    let command = unsafe { *Box::from_raw(command) };
    if let Ok(packet) = command.try_into() {
        Box::leak(Box::new(packet))
    } else {
        std::ptr::null_mut()
    }
}

/// Tries to load a [SPPacket] from the passed array with the specified length.
///
/// returns: NULL in case of an error, pointer to the allocated packet otherwise
///
/// # Panics
///
/// - when `data` is NULL
///
/// # Safety
///
/// The caller has to make sure that:
///
/// - `data` points to a valid memory region of at least `length` bytes
/// - `data` is not written to concurrently
/// - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
///   by explicitly calling `sp_packet_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_packet_try_load(
    data: *const u8,
    length: usize,
) -> *mut Packet {
    assert!(!data.is_null());
    let data = unsafe { std::slice::from_raw_parts(data, length) };
    match servicepoint::Packet::try_from(data) {
        Err(_) => std::ptr::null_mut(),
        Ok(packet) => Box::into_raw(Box::new(packet)),
    }
}

/// Creates a raw [SPPacket] from parts.
///
/// # Arguments
///
/// - `command_code` specifies which command this packet contains
/// - `a`, `b`, `c` and `d` are command-specific header values
/// - `payload` is the optional data that is part of the command
/// - `payload_len` is the size of the payload
///
/// returns: new instance. Will never return null.
///
/// # Panics
///
/// - when `payload` is null, but `payload_len` is not zero
/// - when `payload_len` is zero, but `payload` is nonnull
///
/// # Safety
///
/// The caller has to make sure that:
///
/// - `payload` points to a valid memory region of at least `payload_len` bytes
/// - `payload` is not written to concurrently
/// - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
///   by explicitly calling [sp_packet_free].
#[no_mangle]
pub unsafe extern "C" fn sp_packet_from_parts(
    header: Header,
    payload: *const u8,
    payload_len: usize,
) -> NonNull<Packet> {
    assert_eq!(payload.is_null(), payload_len == 0);

    let payload = if payload.is_null() {
        vec![]
    } else {
        let payload =
            unsafe { std::slice::from_raw_parts(payload, payload_len) };
        Vec::from(payload)
    };

    let packet = Box::new(Packet { header, payload });
    NonNull::from(Box::leak(packet))
}

#[no_mangle]
pub unsafe extern "C" fn sp_packet_get_header(packet: *mut Packet) -> *mut Header {
    assert!(!packet.is_null());
    &mut unsafe { (*packet).header }
}

#[no_mangle]
pub unsafe extern "C" fn sp_packet_get_payload(packet: *mut Packet) -> SPByteSlice {
    assert!(!packet.is_null());
    unsafe { SPByteSlice::from_slice(&mut *(*packet).payload) }
}

#[no_mangle]
pub unsafe extern "C" fn sp_packet_set_payload(packet: *mut Packet, data: SPByteSlice) {
    assert!(!packet.is_null());
    unsafe {
        (*packet).payload = data.as_slice().to_vec()
    }
}

#[no_mangle]
pub unsafe extern "C" fn sp_packet_write_to(
    packet: *const Packet,
    mut buffer: SPByteSlice,
) {
    assert!(!packet.is_null());

    unsafe {
        (*packet).serialize_to(buffer.as_slice_mut());
    }
}

/// Clones a [SPPacket].
///
/// Will never return NULL.
///
/// # Panics
///
/// - when `packet` is NULL
///
/// # Safety
///
/// The caller has to make sure that:
///
/// - `packet` points to a valid [SPPacket]
/// - `packet` is not written to concurrently
/// - the returned instance is freed in some way, either by using a consuming function or
///   by explicitly calling `sp_packet_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_packet_clone(
    packet: *const Packet,
) -> NonNull<Packet> {
    assert!(!packet.is_null());
    let result = Box::new(unsafe { (*packet).clone() });
    NonNull::from(Box::leak(result))
}

/// Deallocates a [SPPacket].
///
/// # Panics
///
/// - when `packet` is NULL
///
/// # Safety
///
/// The caller has to make sure that:
///
/// - `packet` points to a valid [SPPacket]
/// - `packet` is not used concurrently or after this call
#[no_mangle]
pub unsafe extern "C" fn sp_packet_free(packet: *mut Packet) {
    assert!(!packet.is_null());
    _ = unsafe { Box::from_raw(packet) }
}