use std::ffi::{CStr, c_char};
use std::ptr;
use squitter::message::{AdsbMessage, Altitude, VelocityData};
pub struct SquitterMessage {
icao_address: u32,
message: AdsbMessage,
}
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SquitterError {
Ok = 0,
NullInput = 1,
InvalidUtf8 = 2,
Frame = 3,
Bit = 4,
Message = 5,
}
impl From<squitter::AdsbError> for SquitterError {
fn from(e: squitter::AdsbError) -> Self {
match e {
squitter::AdsbError::Frame(_) => Self::Frame,
squitter::AdsbError::Bit(_) => Self::Bit,
_ => Self::Message,
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_decode_line(
line: *const c_char,
out_error: *mut SquitterError,
) -> *mut SquitterMessage {
let set_error = |code: SquitterError| {
if !out_error.is_null() {
unsafe {
out_error.write(code);
}
}
};
if line.is_null() {
set_error(SquitterError::NullInput);
return ptr::null_mut();
}
let Ok(line_str) = unsafe { CStr::from_ptr(line) }.to_str() else {
set_error(SquitterError::InvalidUtf8);
return ptr::null_mut();
};
let frame = match squitter::Frame::parse(line_str) {
Ok(frame) => frame,
Err(e) => {
set_error(SquitterError::from(squitter::AdsbError::from(e)));
return ptr::null_mut();
}
};
match frame.decode_message() {
Ok(message) => {
set_error(SquitterError::Ok);
Box::into_raw(Box::new(SquitterMessage {
icao_address: frame.icao_address(),
message,
}))
}
Err(e) => {
set_error(SquitterError::from(e));
ptr::null_mut()
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_free(msg: *mut SquitterMessage) {
if !msg.is_null() {
drop(unsafe { Box::from_raw(msg) });
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_kind(msg: *const SquitterMessage) -> u8 {
match unsafe { msg.as_ref() } {
Some(m) => match m.message {
AdsbMessage::Identification(_) => 1,
AdsbMessage::SurfacePosition(_) => 2,
AdsbMessage::AirbornePosition(_) => 3,
AdsbMessage::AirborneVelocity(_) => 4,
_ => 0,
},
None => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_icao_address(msg: *const SquitterMessage) -> u32 {
match unsafe { msg.as_ref() } {
Some(m) => m.icao_address,
None => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_callsign(
msg: *const SquitterMessage,
buf: *mut c_char,
buf_len: usize,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let AdsbMessage::Identification(id) = &m.message else {
return false;
};
let text = id.callsign.as_str().as_bytes();
if buf.is_null() || buf_len < text.len() + 1 {
return false;
}
unsafe {
ptr::copy_nonoverlapping(text.as_ptr().cast::<c_char>(), buf, text.len());
buf.add(text.len()).write(0);
}
true
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_altitude_feet(
msg: *const SquitterMessage,
out_feet: *mut i32,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let AdsbMessage::AirbornePosition(pos) = &m.message else {
return false;
};
let Altitude::BarometricFeet(feet) = pos.altitude else {
return false;
};
unsafe {
out_feet.write(feet);
}
true
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_altitude_gnss_meters(
msg: *const SquitterMessage,
out_meters: *mut u16,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let AdsbMessage::AirbornePosition(pos) = &m.message else {
return false;
};
let Altitude::GnssMeters(meters) = pos.altitude else {
return false;
};
unsafe {
out_meters.write(meters);
}
true
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_cpr(
msg: *const SquitterMessage,
out_odd: *mut bool,
out_lat_cpr: *mut u32,
out_lon_cpr: *mut u32,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let (is_odd, lat_cpr, lon_cpr) = match &m.message {
AdsbMessage::AirbornePosition(pos) => (
pos.cpr_format == squitter::message::CprFormat::Odd,
pos.lat_cpr,
pos.lon_cpr,
),
AdsbMessage::SurfacePosition(pos) => (
pos.cpr_format == squitter::message::CprFormat::Odd,
pos.lat_cpr,
pos.lon_cpr,
),
_ => return false,
};
unsafe {
out_odd.write(is_odd);
out_lat_cpr.write(lat_cpr);
out_lon_cpr.write(lon_cpr);
}
true
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_ground_speed_knots(
msg: *const SquitterMessage,
out_knots: *mut f64,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let knots = match &m.message {
AdsbMessage::AirborneVelocity(vel) => vel.ground_speed_knots(),
AdsbMessage::SurfacePosition(pos) => pos.ground_speed_knots(),
_ => None,
};
let Some(knots) = knots else {
return false;
};
unsafe {
out_knots.write(knots);
}
true
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_vertical_rate_fpm(
msg: *const SquitterMessage,
out_fpm: *mut i32,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let AdsbMessage::AirborneVelocity(vel) = &m.message else {
return false;
};
let Some(fpm) = vel.vertical_rate_fpm else {
return false;
};
unsafe {
out_fpm.write(fpm);
}
true
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn squitter_message_heading_degrees(
msg: *const SquitterMessage,
out_degrees: *mut f64,
) -> bool {
let Some(m) = (unsafe { msg.as_ref() }) else {
return false;
};
let AdsbMessage::AirborneVelocity(vel) = &m.message else {
return false;
};
let VelocityData::AirSpeed {
heading_degrees: Some(degrees),
..
} = vel.velocity
else {
return false;
};
unsafe {
out_degrees.write(degrees);
}
true
}
#[unsafe(no_mangle)]
pub extern "C" fn squitter_version() -> *const c_char {
const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), "\0");
VERSION.as_ptr().cast::<c_char>()
}