#![allow(non_camel_case_types)]
use core::ffi::{c_char, c_void};
use core::slice;
use crate::DecodeError;
extern "C" {
fn malloc(size: usize) -> *mut c_void;
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum base85n_status {
BASE85N_OK = 0,
BASE85N_ERR_INVALID_CHAR = 1,
BASE85N_ERR_UNEXPECTED_EOF = 2,
BASE85N_ERR_UNDEFINED_SIGNAL = 3,
BASE85N_ERR_INVALID_FINAL_BLOCK = 4,
BASE85N_ERR_ALLOC = 5,
BASE85N_ERR_INVALID_ARGUMENT = 6,
}
use base85n_status::*;
impl From<&DecodeError> for base85n_status {
fn from(e: &DecodeError) -> Self {
match e {
DecodeError::InvalidCharacter { .. } => BASE85N_ERR_INVALID_CHAR,
DecodeError::UnexpectedEndOfStream => BASE85N_ERR_UNEXPECTED_EOF,
DecodeError::UndefinedSignal { .. } => BASE85N_ERR_UNDEFINED_SIGNAL,
DecodeError::InvalidFinalBlock { .. } => BASE85N_ERR_INVALID_FINAL_BLOCK,
}
}
}
fn malloc_copy(bytes: &[u8], nul: bool) -> *mut u8 {
let size = match bytes.len().checked_add(1) {
Some(n) => n,
None => return core::ptr::null_mut(),
};
let p = unsafe { malloc(size) } as *mut u8;
if p.is_null() {
return p;
}
unsafe {
core::ptr::copy_nonoverlapping(bytes.as_ptr(), p, bytes.len());
if nul {
p.add(bytes.len()).write(0);
}
}
p
}
#[no_mangle]
pub unsafe extern "C" fn base85n_encode(
data: *const u8,
data_len: usize,
out_str: *mut *mut c_char,
out_len: *mut usize,
) -> base85n_status {
if out_str.is_null() || out_len.is_null() {
return BASE85N_ERR_INVALID_ARGUMENT;
}
if data.is_null() && data_len != 0 {
return BASE85N_ERR_INVALID_ARGUMENT;
}
let input = if data_len == 0 {
&[][..]
} else {
unsafe { slice::from_raw_parts(data, data_len) }
};
let encoded = crate::encode(input);
let buf = malloc_copy(encoded.as_bytes(), true);
if buf.is_null() {
return BASE85N_ERR_ALLOC;
}
unsafe {
*out_str = buf as *mut c_char;
*out_len = encoded.len();
}
BASE85N_OK
}
#[no_mangle]
pub unsafe extern "C" fn base85n_decode(
s: *const c_char,
s_len: usize,
out_data: *mut *mut u8,
out_len: *mut usize,
) -> base85n_status {
if out_data.is_null() || out_len.is_null() {
return BASE85N_ERR_INVALID_ARGUMENT;
}
if s.is_null() && s_len != 0 {
return BASE85N_ERR_INVALID_ARGUMENT;
}
let input = if s_len == 0 {
&[][..]
} else {
unsafe { slice::from_raw_parts(s as *const u8, s_len) }
};
let owned;
let text = if input.is_ascii() {
unsafe { core::str::from_utf8_unchecked(input) }
} else {
owned = input.iter().map(|&b| b as char).collect::<String>();
owned.as_str()
};
let decoded = match crate::decode(text) {
Ok(d) => d,
Err(e) => return base85n_status::from(&e),
};
let buf = malloc_copy(&decoded, false);
if buf.is_null() {
return BASE85N_ERR_ALLOC;
}
unsafe {
*out_data = buf;
*out_len = decoded.len();
}
BASE85N_OK
}
#[no_mangle]
pub extern "C" fn base85n_strerror(status: base85n_status) -> *const c_char {
let s: &'static str = match status {
BASE85N_OK => "ok\0",
BASE85N_ERR_INVALID_CHAR => "invalid character (not in Alphabet-N)\0",
BASE85N_ERR_UNEXPECTED_EOF => "unexpected end of stream\0",
BASE85N_ERR_UNDEFINED_SIGNAL => "undefined signal value (FUTURE_SIGNAL_SPACE)\0",
BASE85N_ERR_INVALID_FINAL_BLOCK => "invalid final block\0",
BASE85N_ERR_ALLOC => "memory allocation failure\0",
BASE85N_ERR_INVALID_ARGUMENT => "invalid argument\0",
};
s.as_ptr() as *const c_char
}
#[cfg(test)]
mod tests {
use super::*;
use core::ptr;
extern "C" {
fn free(p: *mut c_void);
}
fn encode_ffi(data: &[u8]) -> Result<String, base85n_status> {
let mut out: *mut c_char = ptr::null_mut();
let mut len: usize = 0;
let st = unsafe { base85n_encode(data.as_ptr(), data.len(), &mut out, &mut len) };
if st != BASE85N_OK {
return Err(st);
}
let bytes = unsafe { slice::from_raw_parts(out as *const u8, len) };
let s = String::from_utf8(bytes.to_vec()).expect("encoder emits ASCII");
assert_eq!(unsafe { *out.add(len) }, 0);
unsafe { free(out as *mut c_void) };
Ok(s)
}
fn decode_ffi(text: &[u8]) -> Result<Vec<u8>, base85n_status> {
let mut out: *mut u8 = ptr::null_mut();
let mut len: usize = 0;
let st = unsafe {
base85n_decode(text.as_ptr() as *const c_char, text.len(), &mut out, &mut len)
};
if st != BASE85N_OK {
return Err(st);
}
assert!(!out.is_null(), "a successful decode always yields a pointer");
let v = unsafe { slice::from_raw_parts(out, len) }.to_vec();
unsafe { free(out as *mut c_void) };
Ok(v)
}
#[test]
fn round_trip_matches_the_rust_api() {
let cases: [&[u8]; 5] = [
b"",
b"hello, world!",
b"{\"id\":184223,\"name\":\"Ada Lovelace\"}",
&[0u8; 64],
b"\x00\x01\x02\xfd\xfe\xff",
];
for case in cases {
let encoded = encode_ffi(case).expect("encoding never fails");
assert_eq!(encoded, crate::encode(case));
assert_eq!(decode_ffi(encoded.as_bytes()).unwrap(), case);
}
}
#[test]
fn empty_input_still_yields_freeable_pointers() {
assert_eq!(encode_ffi(b"").unwrap(), "");
assert_eq!(decode_ffi(b"").unwrap(), Vec::<u8>::new());
}
#[test]
fn null_data_is_only_allowed_with_zero_length() {
let mut out: *mut c_char = ptr::null_mut();
let mut len: usize = 0;
assert_eq!(
unsafe { base85n_encode(ptr::null(), 0, &mut out, &mut len) },
BASE85N_OK
);
unsafe { free(out as *mut c_void) };
assert_eq!(
unsafe { base85n_encode(ptr::null(), 1, &mut out, &mut len) },
BASE85N_ERR_INVALID_ARGUMENT
);
}
#[test]
fn null_out_pointers_are_rejected_not_dereferenced() {
let mut len: usize = 0;
assert_eq!(
unsafe { base85n_encode(b"x".as_ptr(), 1, ptr::null_mut(), &mut len) },
BASE85N_ERR_INVALID_ARGUMENT
);
let mut out: *mut u8 = ptr::null_mut();
assert_eq!(
unsafe { base85n_decode(b"x".as_ptr() as *const c_char, 1, &mut out, ptr::null_mut()) },
BASE85N_ERR_INVALID_ARGUMENT
);
}
#[test]
fn decode_errors_map_to_the_c_status_codes() {
assert_eq!(decode_ffi(b"ab\x22cd"), Err(BASE85N_ERR_INVALID_CHAR));
assert_eq!(decode_ffi(b"ab\xffcd"), Err(BASE85N_ERR_INVALID_CHAR));
assert_eq!(
decode_ffi(b"a"),
Err(BASE85N_ERR_INVALID_FINAL_BLOCK)
);
for st in [
BASE85N_OK,
BASE85N_ERR_INVALID_CHAR,
BASE85N_ERR_UNEXPECTED_EOF,
BASE85N_ERR_UNDEFINED_SIGNAL,
BASE85N_ERR_INVALID_FINAL_BLOCK,
BASE85N_ERR_ALLOC,
BASE85N_ERR_INVALID_ARGUMENT,
] {
let p = base85n_strerror(st);
assert!(!p.is_null());
assert_ne!(unsafe { *p }, 0, "every status has a description");
}
}
#[test]
fn non_ascii_in_a_truncated_segment_is_an_unexpected_end_of_stream() {
let data: Vec<u8> = (0..40u8).map(|i| b'a' + (i % 26)).collect();
let encoded = crate::encode(&data);
let mut bytes = encoded.into_bytes();
bytes.truncate(bytes.len() - 3);
let at = bytes.len() - 4;
bytes[at] = 0xC3;
let mut out: *mut u8 = ptr::null_mut();
let mut len: usize = 0;
let st = unsafe {
base85n_decode(bytes.as_ptr() as *const c_char, bytes.len(), &mut out, &mut len)
};
assert_eq!(st, BASE85N_ERR_UNEXPECTED_EOF, "got {st:?}");
assert!(out.is_null());
}
#[test]
fn arguments_the_encoder_rejects_leave_the_out_pointers_alone() {
let mut sentinel: u8 = 0;
let untouched: *mut c_char = (&mut sentinel as *mut u8).cast();
let mut out = untouched;
let mut len: usize = 42;
let st = unsafe { base85n_encode(ptr::null(), 7, &mut out, &mut len) };
assert_eq!(st, BASE85N_ERR_INVALID_ARGUMENT);
assert_eq!(out, untouched);
assert_eq!(len, 42);
}
#[test]
fn text_the_decoder_rejects_leaves_the_out_pointers_alone() {
let mut sentinel: u8 = 0;
let untouched: *mut u8 = &mut sentinel;
let mut out = untouched;
let mut len: usize = 42;
let bad = b"a";
let st = unsafe {
base85n_decode(bad.as_ptr() as *const c_char, bad.len(), &mut out, &mut len)
};
assert_ne!(st, BASE85N_OK);
assert_eq!(out, untouched);
assert_eq!(len, 42);
}
}