use std::collections::BTreeMap;
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int, c_longlong};
use std::panic::{self, AssertUnwindSafe};
use std::sync::RwLock;
use serde::Deserialize;
use crate::achievements;
use crate::client::ArcaneClient;
use crate::error::{OwnershipStatus, SdkError};
use crate::friends;
use crate::net::{Channel, NetOptions, Peer, ReceiveInto};
use crate::p2p::{self, LobbyOptions, LobbyQuery, Visibility};
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;
pub const ARCANE_LOBBY_FRIENDS: c_int = 0;
pub const ARCANE_LOBBY_CODE: c_int = 1;
pub const ARCANE_LOBBY_FRIENDS_AND_CODE: c_int = 2;
pub const ARCANE_LOBBY_PUBLIC: c_int = 3;
pub const ARCANE_NET_RELIABLE: c_int = 0;
pub const ARCANE_NET_UNRELIABLE: c_int = 1;
pub const ARCANE_NET_PEER_HOST: u16 = 0xFFFE;
pub const ARCANE_NET_PEER_ALL: u16 = 0xFFFF;
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 client_snapshot() -> Option<ArcaneClient> {
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
guard.as_ref().cloned()
}
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,
}
}
fn panic_error(payload: Box<dyn std::any::Any + Send>) -> SdkError {
let detail = payload
.downcast_ref::<&str>()
.map(|s| s.to_string())
.or_else(|| payload.downcast_ref::<String>().cloned())
.unwrap_or_default();
let err = SdkError::internal("The Arcane SDK hit an unexpected error and recovered.")
.with_hint("The game can keep running; report the context to Arcane Powered.");
if detail.is_empty() {
err
} else {
err.with_context("panic", detail)
}
}
fn guard<T>(fallback: T, body: impl FnOnce() -> T) -> T {
match panic::catch_unwind(AssertUnwindSafe(body)) {
Ok(value) => value,
Err(payload) => {
store_error(&panic_error(payload));
fallback
}
}
}
fn guard_action(err_buf: *mut c_char, err_len: usize, body: impl FnOnce() -> c_int) -> c_int {
match panic::catch_unwind(AssertUnwindSafe(body)) {
Ok(value) => value,
Err(payload) => {
write_err(&panic_error(payload), err_buf, err_len);
ARCANE_ERR_SDK
}
}
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_init(err_buf: *mut c_char, err_len: usize) -> c_int {
guard_action(err_buf, err_len, || match ArcaneClient::init() {
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 {
guard_action(err_buf, err_len, || {
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() {
guard((), || {
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() {
guard((), || {
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 {
guard(ARCANE_ERR_ARGUMENT, || {
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 {
guard(ARCANE_ERR_UNAVAILABLE, || {
with_client(buf, len, |c| Some(c.session().to_json()))
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_achievements_json(buf: *mut c_char, len: usize) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(client) = client_snapshot() else {
let err = SdkError::not_initialized("The Arcane SDK client is not initialised.")
.with_hint("Call arcane_sdk_init once at launch before reading achievements.");
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
};
match client.achievements().list() {
Ok(list) => {
clear_error();
write_str(&achievements::to_json(&list), buf, len)
}
Err(err) => {
store_error(&err);
ARCANE_ERR_UNAVAILABLE
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_achievement_unlock(
key: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
if key.is_null() {
return ARCANE_ERR_ARGUMENT;
}
let Ok(key) = CStr::from_ptr(key).to_str() else {
return ARCANE_ERR_ARGUMENT;
};
let Some(client) = client_snapshot() 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_achievement_unlock.",
);
write_err(&err, err_buf, err_len);
return ARCANE_ERR_ARGUMENT;
};
match client.achievements().unlock(key) {
Ok(_) => {
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_achievement_is_unlocked(key: *const c_char) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
if key.is_null() {
return ARCANE_ERR_BAD_BUFFER;
}
let Ok(key) = CStr::from_ptr(key).to_str() else {
return ARCANE_ERR_BAD_BUFFER;
};
let guard = CLIENT.read().unwrap_or_else(|e| e.into_inner());
let Some(client) = guard.as_ref() else {
return ARCANE_ERR_NOT_INITIALIZED;
};
match client.achievements().is_unlocked(key) {
Some(unlocked) => c_int::from(unlocked),
None => ARCANE_ERR_UNAVAILABLE,
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_friends_json(buf: *mut c_char, len: usize) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(client) = client_snapshot() else {
let err = SdkError::not_initialized("The Arcane SDK client is not initialised.")
.with_hint("Call arcane_sdk_init once at launch before reading friends.");
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
};
match client.friends().list() {
Ok(list) => {
clear_error();
write_str(&friends::to_json(&list), buf, len)
}
Err(err) => {
store_error(&err);
ARCANE_ERR_UNAVAILABLE
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_friend_request(
user_id: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
let Some(Some(user_id)) = c_str(user_id) else {
return ARCANE_ERR_ARGUMENT;
};
let client = match lobby_client("arcane_sdk_friend_request") {
Ok(client) => client,
Err(err) => {
write_err(&err, err_buf, err_len);
return ARCANE_ERR_ARGUMENT;
}
};
match client.friends().send_request(user_id) {
Ok(()) => {
clear_error();
ARCANE_OK
}
Err(err) => {
write_err(&err, err_buf, err_len);
ARCANE_ERR_SDK
}
}
})
}
unsafe fn c_str<'a>(value: *const c_char) -> Option<Option<&'a str>> {
if value.is_null() {
return Some(None);
}
match CStr::from_ptr(value).to_str() {
Ok(value) => Some(Some(value)),
Err(_) => None,
}
}
unsafe fn payload_arg(payload_b64: *const c_char) -> Option<Vec<u8>> {
let raw = c_str(payload_b64)?.unwrap_or_default();
p2p::decode_payload_arg(raw)
}
fn visibility_arg(visibility: c_int) -> Option<Visibility> {
match visibility {
ARCANE_LOBBY_FRIENDS => Some(Visibility::Friends),
ARCANE_LOBBY_CODE => Some(Visibility::Code),
ARCANE_LOBBY_FRIENDS_AND_CODE => Some(Visibility::FriendsAndCode),
ARCANE_LOBBY_PUBLIC => Some(Visibility::Public),
_ => None,
}
}
fn bad_lobby_argument(detail: &str) -> c_int {
let err = SdkError::invalid_argument(detail)
.with_hint("Pass a base64 payload of at most 4096 raw bytes, and a known visibility.");
store_error(&err);
ARCANE_ERR_BAD_BUFFER
}
fn lobby_result(lobby: Result<crate::p2p::Lobby, SdkError>, buf: *mut c_char, len: usize) -> c_int {
match lobby {
Ok(lobby) => {
clear_error();
write_str(&p2p::to_json(&lobby), buf, len)
}
Err(err) => {
store_error(&err);
ARCANE_ERR_UNAVAILABLE
}
}
}
fn lobby_client(action: &str) -> Result<ArcaneClient, SdkError> {
client_snapshot().ok_or_else(|| {
SdkError::not_initialized("The Arcane SDK client is not initialised.").with_hint(format!(
"Call arcane_sdk_init once at launch before {action}."
))
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_create(
max_players: u8,
visibility: c_int,
payload_b64: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(payload) = payload_arg(payload_b64) else {
return bad_lobby_argument("The lobby payload is null-terminated but not base64.");
};
let Some(visibility) = visibility_arg(visibility) else {
return bad_lobby_argument("That is not an Arcane lobby visibility.");
};
let client = match lobby_client("arcane_sdk_lobby_create") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
lobby_result(
client.p2p().create_lobby(max_players, visibility, &payload),
buf,
len,
)
})
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct CreateOptionsArg {
max_players: u8,
visibility: String,
#[serde(default)]
payload: Option<String>,
#[serde(default)]
metadata: BTreeMap<String, String>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct MetadataArg {
#[serde(default)]
metadata: BTreeMap<String, String>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SearchArg {
#[serde(default)]
filters: BTreeMap<String, String>,
#[serde(default)]
has_free_slot: Option<bool>,
#[serde(default)]
limit: Option<u8>,
}
fn visibility_name(name: &str) -> Option<Visibility> {
match name {
"friends" => Some(Visibility::Friends),
"code" => Some(Visibility::Code),
"friends_and_code" => Some(Visibility::FriendsAndCode),
"public" => Some(Visibility::Public),
_ => None,
}
}
unsafe fn json_arg<T: for<'de> Deserialize<'de>>(raw: *const c_char, empty: &str) -> Option<T> {
let text = match c_str(raw)? {
Some(text) if !text.trim().is_empty() => text,
_ => empty,
};
serde_json::from_str(text).ok()
}
fn bad_json_argument(detail: &str) -> c_int {
let err = SdkError::invalid_argument(detail).with_hint(
"Pass a JSON object as documented in arcane_sdk.h; metadata is at most 16 string pairs.",
);
store_error(&err);
ARCANE_ERR_BAD_BUFFER
}
fn initialized_client(action: &str) -> Result<ArcaneClient, c_int> {
lobby_client(action).map_err(|err| {
store_error(&err);
ARCANE_ERR_NOT_INITIALIZED
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_create_json(
options_json: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(options) = json_arg::<CreateOptionsArg>(options_json, "") else {
return bad_json_argument("The lobby options are not a valid JSON object.");
};
let Some(visibility) = visibility_name(&options.visibility) else {
return bad_json_argument("That is not an Arcane lobby visibility.");
};
let Some(payload) = p2p::decode_payload_arg(options.payload.as_deref().unwrap_or_default())
else {
return bad_lobby_argument("The lobby payload is not base64.");
};
let client = match initialized_client("arcane_sdk_lobby_create_json") {
Ok(client) => client,
Err(code) => return code,
};
let metadata: Vec<(&str, &str)> = options
.metadata
.iter()
.map(|(key, value)| (key.as_str(), value.as_str()))
.collect();
lobby_result(
client.p2p().create(LobbyOptions {
max_players: options.max_players,
visibility,
payload: &payload,
metadata: &metadata,
}),
buf,
len,
)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_set_metadata(
lobby_id: *const c_char,
metadata_json: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(Some(lobby_id)) = c_str(lobby_id) else {
return bad_lobby_argument("The lobby id is null or not UTF-8.");
};
let Some(arg) = json_arg::<MetadataArg>(metadata_json, "{}") else {
return bad_json_argument("The lobby metadata is not a valid JSON object.");
};
let client = match initialized_client("arcane_sdk_lobby_set_metadata") {
Ok(client) => client,
Err(code) => return code,
};
let metadata: Vec<(&str, &str)> = arg
.metadata
.iter()
.map(|(key, value)| (key.as_str(), value.as_str()))
.collect();
lobby_result(client.p2p().set_metadata(lobby_id, &metadata), buf, len)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_search(
query_json: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(arg) = json_arg::<SearchArg>(query_json, "{}") else {
return bad_json_argument("The lobby search query is not a valid JSON object.");
};
let client = match initialized_client("arcane_sdk_lobby_search") {
Ok(client) => client,
Err(code) => return code,
};
let defaults = LobbyQuery::default();
let query = LobbyQuery {
filters: arg.filters.into_iter().collect(),
has_free_slot: arg.has_free_slot.unwrap_or(defaults.has_free_slot),
limit: arg.limit.unwrap_or(defaults.limit),
};
match client.p2p().search(&query) {
Ok(lobbies) => {
clear_error();
write_str(&p2p::summaries_to_json(&lobbies), buf, len)
}
Err(err) => {
store_error(&err);
ARCANE_ERR_UNAVAILABLE
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_join_code(
join_code: *const c_char,
payload_b64: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(Some(join_code)) = c_str(join_code) else {
return bad_lobby_argument("The join code is null or not UTF-8.");
};
let Some(payload) = payload_arg(payload_b64) else {
return bad_lobby_argument("The lobby payload is null-terminated but not base64.");
};
let client = match lobby_client("arcane_sdk_lobby_join_code") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
lobby_result(client.p2p().join_by_code(join_code, &payload), buf, len)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_join(
lobby_id: *const c_char,
payload_b64: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(Some(lobby_id)) = c_str(lobby_id) else {
return bad_lobby_argument("The lobby id is null or not UTF-8.");
};
let Some(payload) = payload_arg(payload_b64) else {
return bad_lobby_argument("The lobby payload is null-terminated but not base64.");
};
let client = match lobby_client("arcane_sdk_lobby_join") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
lobby_result(client.p2p().join(lobby_id, &payload), buf, len)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_get(
lobby_id: *const c_char,
buf: *mut c_char,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let Some(Some(lobby_id)) = c_str(lobby_id) else {
return bad_lobby_argument("The lobby id is null or not UTF-8.");
};
let client = match lobby_client("arcane_sdk_lobby_get") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
lobby_result(client.p2p().get_lobby(lobby_id), buf, len)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_invite(
lobby_id: *const c_char,
to_user_id: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
let (Some(Some(lobby_id)), Some(Some(to_user_id))) = (c_str(lobby_id), c_str(to_user_id))
else {
return ARCANE_ERR_ARGUMENT;
};
let client = match lobby_client("arcane_sdk_lobby_invite") {
Ok(client) => client,
Err(err) => {
write_err(&err, err_buf, err_len);
return ARCANE_ERR_ARGUMENT;
}
};
match client.p2p().invite(lobby_id, to_user_id) {
Ok(()) => {
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_lobby_leave(
lobby_id: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
lobby_action(
lobby_id,
err_buf,
err_len,
"arcane_sdk_lobby_leave",
|client, id| client.p2p().leave(id),
)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_close(
lobby_id: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
lobby_action(
lobby_id,
err_buf,
err_len,
"arcane_sdk_lobby_close",
|client, id| client.p2p().close(id),
)
})
}
unsafe fn lobby_action<F>(
lobby_id: *const c_char,
err_buf: *mut c_char,
err_len: usize,
action: &str,
call: F,
) -> c_int
where
F: FnOnce(&ArcaneClient, &str) -> Result<(), SdkError>,
{
let Some(Some(lobby_id)) = c_str(lobby_id) else {
return ARCANE_ERR_ARGUMENT;
};
let client = match lobby_client(action) {
Ok(client) => client,
Err(err) => {
write_err(&err, err_buf, err_len);
return ARCANE_ERR_ARGUMENT;
}
};
match call(&client, lobby_id) {
Ok(()) => {
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_launch_join_code(buf: *mut c_char, len: usize) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let client = match lobby_client("arcane_sdk_launch_join_code") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
match client.p2p().launch_join_code() {
Some(code) => write_str(&code, buf, len),
None => ARCANE_ERR_UNAVAILABLE,
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_lobby_events_json(buf: *mut c_char, len: usize) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let client = match lobby_client("arcane_sdk_lobby_events_json") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
let (rendered, through) = client.p2p().events_json();
let written = write_str(&rendered, buf, len);
if let (true, Some(through)) = (written >= 0, through) {
client.p2p().discard(through);
}
written
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_net_open(
lobby_id: *const c_char,
allow_relay: c_int,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
let options = NetOptions {
allow_relay: allow_relay != 0,
};
lobby_action(
lobby_id,
err_buf,
err_len,
"arcane_sdk_net_open",
|client, id| client.net().open(id, options),
)
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_net_send(
peer: u16,
channel: c_int,
data: *const u8,
data_len: usize,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
guard_action(err_buf, err_len, || {
let channel = match channel {
ARCANE_NET_RELIABLE => Channel::Reliable,
ARCANE_NET_UNRELIABLE => Channel::Unreliable,
_ => return ARCANE_ERR_ARGUMENT,
};
let bytes: &[u8] = match (data.is_null(), data_len) {
(_, 0) => &[],
(true, _) => return ARCANE_ERR_ARGUMENT,
(false, len) => std::slice::from_raw_parts(data, len),
};
let peer = match peer {
ARCANE_NET_PEER_HOST => Peer::Host,
ARCANE_NET_PEER_ALL => Peer::All,
index => Peer::Index(index),
};
let client = match lobby_client("arcane_sdk_net_send") {
Ok(client) => client,
Err(err) => {
write_err(&err, err_buf, err_len);
return ARCANE_ERR_ARGUMENT;
}
};
match client.net().send(peer, channel, bytes) {
Ok(()) => ARCANE_OK,
Err(err) => {
write_err(&err, err_buf, err_len);
ARCANE_ERR_SDK
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_net_receive(
peer_out: *mut u16,
channel_out: *mut c_int,
buf: *mut u8,
len: usize,
) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
if buf.is_null() && len != 0 {
return ARCANE_ERR_BAD_BUFFER;
}
let client = match lobby_client("arcane_sdk_net_receive") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
let target: &mut [u8] = if len == 0 {
&mut []
} else {
std::slice::from_raw_parts_mut(buf, len)
};
match client.net().receive_into(target) {
ReceiveInto::Empty => ARCANE_ERR_UNAVAILABLE,
ReceiveInto::TooSmall => ARCANE_ERR_BUFFER_TOO_SMALL,
ReceiveInto::Received { peer, channel, len } => {
if !peer_out.is_null() {
*peer_out = peer;
}
if !channel_out.is_null() {
*channel_out = match channel {
Channel::Reliable => ARCANE_NET_RELIABLE,
Channel::Unreliable => ARCANE_NET_UNRELIABLE,
};
}
len as c_int
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_net_events_json(buf: *mut c_char, len: usize) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
let client = match lobby_client("arcane_sdk_net_events_json") {
Ok(client) => client,
Err(err) => {
store_error(&err);
return ARCANE_ERR_NOT_INITIALIZED;
}
};
let (rendered, count) = client.net().events_json();
let written = write_str(&rendered, buf, len);
if written >= 0 {
client.net().discard_events(count);
}
written
})
}
#[no_mangle]
pub extern "C" fn arcane_sdk_net_close() {
guard((), || {
if let Some(client) = client_snapshot() {
client.net().close();
}
})
}
#[no_mangle]
pub extern "C" fn arcane_sdk_net_is_open() -> c_int {
guard(0, || {
client_snapshot().map_or(0, |client| c_int::from(client.net().is_open()))
})
}
#[no_mangle]
pub extern "C" fn arcane_sdk_is_initialized() -> c_int {
guard(0, || {
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 {
guard(ARCANE_ERR_NOT_INITIALIZED, || {
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 {
guard(-1, || {
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 {
guard(-1, || {
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 {
guard(ARCANE_ERR_UNAVAILABLE, || {
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 {
guard(ARCANE_ERR_UNAVAILABLE, || {
with_client(buf, len, |c| Some(c.game_id().to_string()))
})
}
#[no_mangle]
pub unsafe extern "C" fn arcane_sdk_device_hash(buf: *mut c_char, len: usize) -> c_int {
guard(ARCANE_ERR_UNAVAILABLE, || {
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 {
guard(ARCANE_ERR_UNAVAILABLE, || {
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("game-abc", buf.as_mut_ptr(), buf.len());
assert_eq!(written, 8);
assert_eq!(read_c_string(&buf), "game-abc");
assert_eq!(buf[8], 0);
}
#[test]
fn write_str_refuses_to_truncate() {
let mut buf = [1 as c_char; 4];
let written = write_str("game-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_game_id(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 the_achievement_entry_points_are_safe_before_init() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
arcane_sdk_shutdown();
let mut buf = [0 as c_char; 256];
assert_eq!(
unsafe { arcane_sdk_achievements_json(buf.as_mut_ptr(), buf.len()) },
ARCANE_ERR_NOT_INITIALIZED
);
assert_eq!(
unsafe {
arcane_sdk_achievement_unlock(c"first_blood".as_ptr(), buf.as_mut_ptr(), buf.len())
},
ARCANE_ERR_ARGUMENT
);
assert_eq!(
unsafe { arcane_sdk_achievement_is_unlocked(c"first_blood".as_ptr()) },
ARCANE_ERR_NOT_INITIALIZED
);
}
#[test]
fn the_friends_entry_point_is_safe_before_init() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
arcane_sdk_shutdown();
let mut buf = [0 as c_char; 256];
assert_eq!(
unsafe { arcane_sdk_friends_json(buf.as_mut_ptr(), buf.len()) },
ARCANE_ERR_NOT_INITIALIZED
);
}
#[test]
fn the_achievement_entry_points_reject_a_null_key() {
let mut buf = [0 as c_char; 64];
assert_eq!(
unsafe { arcane_sdk_achievement_unlock(std::ptr::null(), buf.as_mut_ptr(), buf.len()) },
ARCANE_ERR_ARGUMENT
);
assert_eq!(
unsafe { arcane_sdk_achievement_is_unlocked(std::ptr::null()) },
ARCANE_ERR_BAD_BUFFER
);
}
#[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 a_panic_never_crosses_the_c_boundary() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
let value = guard(-7, || -> c_int { panic!("boom") });
assert_eq!(value, -7);
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"], "internal");
assert!(parsed["context"].to_string().contains("boom"));
let mut err = [0 as c_char; 256];
let rc = guard_action(err.as_mut_ptr(), err.len(), || {
panic!("{}", String::from("again"))
});
assert_eq!(rc, ARCANE_ERR_SDK);
assert!(read_c_string(&err).starts_with("internal:"));
clear_error();
}
#[test]
fn the_json_lobby_entry_points_check_their_arguments_before_init() {
let _guard = GLOBAL_STATE.lock().unwrap_or_else(|e| e.into_inner());
arcane_sdk_shutdown();
let mut buf = [0 as c_char; 256];
let (ptr, len) = (buf.as_mut_ptr(), buf.len());
unsafe {
assert_eq!(
arcane_sdk_lobby_create_json(std::ptr::null(), ptr, len),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_create_json(c"not json".as_ptr(), ptr, len),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_create_json(
c"{\"max_players\":4,\"visibility\":\"open\"}".as_ptr(),
ptr,
len
),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_create_json(
c"{\"max_players\":4,\"visibility\":\"public\",\"extra\":1}".as_ptr(),
ptr,
len
),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_create_json(
c"{\"max_players\":4,\"visibility\":\"public\",\"metadata\":{\"mode\":\"coop\"}}".as_ptr(),
ptr,
len
),
ARCANE_ERR_NOT_INITIALIZED
);
assert_eq!(
arcane_sdk_lobby_search(c"{\"limit\":\"many\"}".as_ptr(), ptr, len),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_search(std::ptr::null(), ptr, len),
ARCANE_ERR_NOT_INITIALIZED
);
assert_eq!(
arcane_sdk_lobby_set_metadata(std::ptr::null(), c"{}".as_ptr(), ptr, len),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_set_metadata(
c"lobby-1".as_ptr(),
c"{\"metadata\":[]}".as_ptr(),
ptr,
len
),
ARCANE_ERR_BAD_BUFFER
);
assert_eq!(
arcane_sdk_lobby_set_metadata(c"lobby-1".as_ptr(), std::ptr::null(), ptr, len),
ARCANE_ERR_NOT_INITIALIZED
);
}
assert_eq!(
visibility_arg(ARCANE_LOBBY_PUBLIC),
Some(Visibility::Public)
);
assert_eq!(visibility_name("public"), Some(Visibility::Public));
assert_eq!(visibility_name("Public"), None);
}
}