129 lines
3.5 KiB
Rust
129 lines
3.5 KiB
Rust
use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, ByteSlice};
|
|
use servicepoint::{CommandCode, Header, Packet, TypedCommand};
|
|
use std::ptr::NonNull;
|
|
|
|
/// Turns a [TypedCommand] into a [Packet].
|
|
/// The [TypedCommand] gets consumed.
|
|
///
|
|
/// Returns NULL in case of an error.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_from_command(
|
|
command: NonNull<TypedCommand>,
|
|
) -> *mut Packet {
|
|
let command = unsafe { heap_remove(command) };
|
|
if let Ok(packet) = command.try_into() {
|
|
heap_move(packet)
|
|
} else {
|
|
std::ptr::null_mut()
|
|
}
|
|
}
|
|
|
|
/// Tries to load a [Packet] from the passed array with the specified length.
|
|
///
|
|
/// returns: NULL in case of an error, pointer to the allocated packet otherwise
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_try_load(data: ByteSlice) -> *mut Packet {
|
|
let data = unsafe { data.as_slice() };
|
|
match servicepoint::Packet::try_from(data) {
|
|
Err(_) => std::ptr::null_mut(),
|
|
Ok(packet) => heap_move(packet),
|
|
}
|
|
}
|
|
|
|
/// Creates a raw [Packet] from parts.
|
|
///
|
|
/// returns: new instance. Will never return null.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_from_parts(
|
|
header: Header,
|
|
payload: *const ByteSlice,
|
|
) -> NonNull<Packet> {
|
|
let payload = if payload.is_null() {
|
|
vec![]
|
|
} else {
|
|
let payload = unsafe { (*payload).as_slice() };
|
|
Vec::from(payload)
|
|
};
|
|
|
|
heap_move_nonnull(Packet { header, payload })
|
|
}
|
|
|
|
/// Returns a pointer to the header field of the provided packet.
|
|
///
|
|
/// The returned header can be changed and will be valid for the lifetime of the packet.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_get_header(
|
|
packet: NonNull<Packet>,
|
|
) -> NonNull<Header> {
|
|
NonNull::from(&mut unsafe { (*packet.as_ptr()).header })
|
|
}
|
|
|
|
/// Returns a pointer to the current payload of the provided packet.
|
|
///
|
|
/// The returned memory can be changed and will be valid until a new payload is set.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_get_payload(
|
|
packet: NonNull<Packet>,
|
|
) -> ByteSlice {
|
|
unsafe { ByteSlice::from_slice(&mut (*packet.as_ptr()).payload) }
|
|
}
|
|
|
|
/// Sets the payload of the provided packet to the provided data.
|
|
///
|
|
/// This makes previous payload pointers invalid.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_set_payload(
|
|
packet: NonNull<Packet>,
|
|
data: ByteSlice,
|
|
) {
|
|
unsafe { (*packet.as_ptr()).payload = data.as_slice().to_vec() }
|
|
}
|
|
|
|
/// Serialize the packet into the provided buffer.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// - if the buffer is not big enough to hold header+payload.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_serialize_to(
|
|
packet: NonNull<Packet>,
|
|
mut buffer: ByteSlice,
|
|
) {
|
|
unsafe {
|
|
packet.as_ref().serialize_to(buffer.as_slice_mut());
|
|
}
|
|
}
|
|
|
|
/// Clones a [Packet].
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_clone(
|
|
packet: NonNull<Packet>,
|
|
) -> NonNull<Packet> {
|
|
heap_move_nonnull(unsafe { packet.as_ref().clone() })
|
|
}
|
|
|
|
/// Deallocates a [Packet].
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_packet_free(packet: NonNull<Packet>) {
|
|
unsafe { heap_drop(packet) }
|
|
}
|
|
|
|
/// Converts u16 into [CommandCode].
|
|
///
|
|
/// If the provided value is not valid, false is returned and result is not changed.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_u16_to_command_code(
|
|
code: u16,
|
|
result: *mut CommandCode,
|
|
) -> bool {
|
|
match CommandCode::try_from(code) {
|
|
Ok(code) => {
|
|
unsafe {
|
|
*result = code;
|
|
}
|
|
true
|
|
}
|
|
Err(_) => false,
|
|
}
|
|
}
|