use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int, c_longlong};
use std::sync::RwLock;
use crate::client::ArcaneClient;
use crate::error::{OwnershipStatus, SdkError};
pub const ARCANE_OK: c_int = 0;
pub const ARCANE_ERR_ARGUMENT: c_int = 1;
pub const ARCANE_ERR_SDK: c_int = 2;
pub const ARCANE_ERR_NOT_INITIALIZED: c_int = -1;
pub const ARCANE_ERR_BAD_BUFFER: c_int = -2;
pub const ARCANE_ERR_BUFFER_TOO_SMALL: c_int = -3;
pub const ARCANE_ERR_UNAVAILABLE: c_int = -4;
pub const ARCANE_OWNERSHIP_OWNED: c_int = 0;
pub const ARCANE_OWNERSHIP_DRM_DISABLED: c_int = 1;
static CLIENT: RwLock<Option<ArcaneClient>> = RwLock::new(None);
static LAST_ERROR: RwLock<Option<SdkError>> = RwLock::new(None);
fn store_error(err: &SdkError) {
let mut slot = LAST_ERROR.write().unwrap_or_else(|e| e.into_inner());
*slot = Some(err.clone());
}
fn clear_error() {
let mut slot = LAST_ERROR.write().unwrap_or_else(|e| e.into_inner());
*slot = None;
}
fn write_str(value: &str, buf: *mut c_char, len: usize) -> c_int {
if buf.is_null() || len == 0 {
return ARCANE_ERR_BAD_BUFFER;
}
let Ok(c_value) = CString::new(value) else {
return ARCANE_ERR_UNAVAILABLE;
};
let bytes = c_value.as_bytes_with_nul();
if bytes.len() > len {
unsafe { *buf = 0 };
return ARCANE_ERR_BUFFER_TOO_SMALL;
}
unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), buf as *mut u8, bytes.len());
}
(bytes.len() - 1) as c_int
}
fn write_err(err: &SdkError, buf: *mut c_char, len: usize) {
store_error(err);
if buf.is_null() || len == 0 {
return;
}
let rendered = err.to_string().replace('\0', "");
let c_value = CString::new(rendered).unwrap_or_default();
let bytes = c_value.as_bytes_with_nul();
let copy_len = bytes.len().min(len);
unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), buf as *mut u8, copy_len);
*buf.add(copy_len - 1) = 0;
}
}
fn with_client<F>(buf: *mut c_char, len: usize, read: F) -> c_int
where
F: FnOnce(&ArcaneClient) -> Option<String>,
{
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
let Some(client) = guard.as_ref() else {
let err = SdkError::not_initialized("The Arcane SDK client is not initialised.")
.with_hint("Call arcane_sdk_init once at launch before reading client state.");
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
};
match read(client) {
Some(value) => write_str(&value, buf, len),
None => ARCANE_ERR_UNAVAILABLE,
}
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_init(
public_key: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
if public_key.is_null() {
return ARCANE_ERR_ARGUMENT;
}
let Ok(key) = CStr::from_ptr(public_key).to_str() else {
return ARCANE_ERR_ARGUMENT;
};
match ArcaneClient::init(key) {
Ok(client) => {
*CLIENT.write().unwrap_or_else(|e| e.into_inner()) = Some(client);
clear_error();
ARCANE_OK
}
Err(err) => {
write_err(&err, err_buf, err_len);
ARCANE_ERR_SDK
}
}
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_refresh(err_buf: *mut c_char, err_len: usize) -> c_int {
let mut guard = CLIENT.write().unwrap_or_else(|e| e.into_inner());
let Some(client) = guard.as_mut() else {
let err = SdkError::not_initialized("The Arcane SDK client is not initialised.")
.with_hint("Call arcane_sdk_init once at launch before calling arcane_sdk_refresh.");
write_err(&err, err_buf, err_len);
return ARCANE_ERR_ARGUMENT;
};
match client.refresh() {
Ok(_) => {
clear_error();
ARCANE_OK
}
Err(err) => {
write_err(&err, err_buf, err_len);
ARCANE_ERR_SDK
}
}
}
#[no_mangle]
pub extern "C" fn arcane_sdk_shutdown() {
let client = { CLIENT.write().unwrap_or_else(|e| e.into_inner()).take() };
if let Some(client) = client {
client.shutdown();
}
clear_error();
}
#[no_mangle]
pub extern "C" fn arcane_sdk_frame() {
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
if let Some(client) = guard.as_ref() {
client.frame();
}
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_set_graphics(
resolution: *const c_char,
preset: *const c_char,
) -> c_int {
if resolution.is_null() || preset.is_null() {
return ARCANE_ERR_ARGUMENT;
}
let (Ok(resolution), Ok(preset)) = (
CStr::from_ptr(resolution).to_str(),
CStr::from_ptr(preset).to_str(),
) else {
return ARCANE_ERR_ARGUMENT;
};
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
let Some(client) = guard.as_ref() else {
let err = SdkError::not_initialized("The Arcane SDK client is not initialised.")
.with_hint("Call arcane_sdk_init once at launch before arcane_sdk_set_graphics.");
store_error(&err);
return ARCANE_ERR_ARGUMENT;
};
client.set_graphics(resolution, preset);
ARCANE_OK
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_session_json(buf: *mut c_char, len: usize) -> c_int {
with_client(buf, len, |c| Some(c.session().to_json()))
}
#[no_mangle]
pub extern "C" fn arcane_sdk_is_initialized() -> c_int {
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
c_int::from(guard.is_some())
}
#[no_mangle]
pub extern "C" fn arcane_sdk_ownership() -> c_int {
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
match guard.as_ref().map(ArcaneClient::ownership) {
Some(OwnershipStatus::Owned) => ARCANE_OWNERSHIP_OWNED,
Some(OwnershipStatus::DrmDisabled) => ARCANE_OWNERSHIP_DRM_DISABLED,
None => ARCANE_ERR_NOT_INITIALIZED,
}
}
#[no_mangle]
pub extern "C" fn arcane_sdk_ticket_expires_at() -> c_longlong {
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
guard
.as_ref()
.and_then(ArcaneClient::ticket_expires_at)
.unwrap_or(-1) as c_longlong
}
#[no_mangle]
pub extern "C" fn arcane_sdk_checked_at() -> c_longlong {
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
guard.as_ref().map(ArcaneClient::checked_at).unwrap_or(-1) as c_longlong
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_user_id(buf: *mut c_char, len: usize) -> c_int {
with_client(buf, len, |c| c.user_id().map(str::to_string))
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_game_id(buf: *mut c_char, len: usize) -> c_int {
with_client(buf, len, |c| c.game_id().map(str::to_string))
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_public_key(buf: *mut c_char, len: usize) -> c_int {
with_client(buf, len, |c| Some(c.public_key().to_string()))
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_device_hash(buf: *mut c_char, len: usize) -> c_int {
with_client(buf, len, |c| Some(c.device_hash().to_string()))
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_last_error_json(buf: *mut c_char, len: usize) -> c_int {
let guard = LAST_ERROR.read().unwrap_or_else(|e| e.into_inner());
match guard.as_ref() {
Some(err) => write_str(&err.to_json(), buf, len),
None => ARCANE_ERR_UNAVAILABLE,
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
static GLOBAL_STATE: Mutex<()> = Mutex::new(());
fn read_c_string(buf: &[c_char]) -> String {
let bytes: Vec<u8> = buf
.iter()
.take_while(|b| **b != 0)
.map(|b| *b as u8)
.collect();
String::from_utf8(bytes).unwrap()
}
#[test]
fn write_str_reports_bytes_and_nul_terminates() {
let mut buf = [1 as c_char; 16];
let written = write_str("pk_abc", buf.as_mut_ptr(), buf.len());
assert_eq!(written, 6);
assert_eq!(read_c_string(&buf), "pk_abc");
assert_eq!(buf[6], 0);
}
#[test]
fn write_str_refuses_to_truncate() {
let mut buf = [1 as c_char; 4];
let written = write_str("pk_abc", buf.as_mut_ptr(), buf.len());
assert_eq!(written, ARCANE_ERR_BUFFER_TOO_SMALL);
assert_eq!(buf[0], 0);
}
#[test]
fn write_str_rejects_null_and_zero_length_buffers() {
let mut buf = [0 as c_char; 8];
assert_eq!(
write_str("x", std::ptr::null_mut(), 8),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(write_str("x", buf.as_mut_ptr(), 0), ARCANE_ERR_BAD_BUFFER);
}
#[test]
fn write_str_exact_fit_succeeds() {
let mut buf = [1 as c_char; 4];
assert_eq!(write_str("abc", buf.as_mut_ptr(), buf.len()), 3);
assert_eq!(read_c_string(&buf), "abc");
}
#[test]
fn write_err_truncates_and_always_nul_terminates() {
let err = SdkError::not_owned("You do not own this game.")
.with_hint("Buy it on the Arcane Store.");
let mut buf = [1 as c_char; 12];
write_err(&err, buf.as_mut_ptr(), buf.len());
assert_eq!(buf[buf.len() - 1], 0);
assert!(read_c_string(&buf).starts_with("not_owned"));
}
#[test]
fn write_err_records_the_error_for_last_error_json() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
let err = SdkError::network_required("Go online once.").with_hint("Open Arcane.");
write_err(&err, std::ptr::null_mut(), 0);
let mut buf = [0 as c_char; 512];
let written = unsafe { arcane_sdk_last_error_json(buf.as_mut_ptr(), buf.len()) };
assert!(written > 0);
let parsed: serde_json::Value = serde_json::from_str(&read_c_string(&buf)).unwrap();
assert_eq!(parsed["code"], "network_required");
assert_eq!(parsed["retryable"], true);
clear_error();
}
#[test]
fn getters_report_not_initialized_before_init() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
arcane_sdk_shutdown();
let mut buf = [0 as c_char; 64];
assert_eq!(
unsafe { arcane_sdk_user_id(buf.as_mut_ptr(), buf.len()) },
ARCANE_ERR_NOT_INITIALIZED
);
assert_eq!(
unsafe { arcane_sdk_public_key(buf.as_mut_ptr(), buf.len()) },
ARCANE_ERR_NOT_INITIALIZED
);
assert_eq!(arcane_sdk_ownership(), ARCANE_ERR_NOT_INITIALIZED);
assert_eq!(arcane_sdk_is_initialized(), 0);
assert_eq!(arcane_sdk_ticket_expires_at(), -1);
assert_eq!(arcane_sdk_checked_at(), -1);
}
#[test]
fn frame_and_session_json_are_safe_before_init() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
arcane_sdk_shutdown();
arcane_sdk_frame();
let mut buf = [0 as c_char; 256];
assert_eq!(
unsafe { arcane_sdk_session_json(buf.as_mut_ptr(), buf.len()) },
ARCANE_ERR_NOT_INITIALIZED
);
assert_eq!(
unsafe { arcane_sdk_set_graphics(c"1920x1080".as_ptr(), c"ultra".as_ptr()) },
ARCANE_ERR_ARGUMENT
);
}
#[test]
fn set_graphics_rejects_null_arguments() {
assert_eq!(
unsafe { arcane_sdk_set_graphics(std::ptr::null(), std::ptr::null()) },
ARCANE_ERR_ARGUMENT
);
}
#[test]
fn init_rejects_a_null_public_key() {
let mut err = [0 as c_char; 64];
let rc = unsafe { arcane_sdk_init(std::ptr::null(), err.as_mut_ptr(), err.len()) };
assert_eq!(rc, ARCANE_ERR_ARGUMENT);
}
}