use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int, c_void};
use std::ptr;
use crate::config::{
ruleset_from_file, ruleset_from_file_with_processors as load_file_with_processors,
ruleset_from_str, ruleset_from_str_with_processors as load_str_with_processors,
};
use crate::render::{Processor, ProcessorRegistry, RenderContext, RenderOptions, RuleSet};
pub const COPPERLACE_OK: c_int = 0;
pub const COPPERLACE_INVALID_ARGUMENT: c_int = 1;
pub const COPPERLACE_PARSE_ERROR: c_int = 2;
pub const COPPERLACE_RENDER_ERROR: c_int = 3;
pub type CopperlaceProcessorCallback =
unsafe extern "C" fn(*const c_char, *mut CopperlaceProcessorResult, *mut c_void) -> c_int;
pub struct CopperlaceRuleSet {
ruleset: RuleSet,
}
pub struct CopperlaceProcessorResult {
output: Option<String>,
error: Option<String>,
}
struct CallbackProcessor {
callback: CopperlaceProcessorCallback,
user_data: *mut c_void,
}
unsafe impl Send for CallbackProcessor {}
unsafe impl Sync for CallbackProcessor {}
impl Processor for CallbackProcessor {
fn process(&self, value: &str) -> Result<String, String> {
let input =
CString::new(value).map_err(|_| "processor input contains an interior NUL byte")?;
let mut result = CopperlaceProcessorResult {
output: None,
error: None,
};
let status = unsafe { (self.callback)(input.as_ptr(), &mut result, self.user_data) };
if let Some(error) = result.error {
return Err(error);
}
if status != COPPERLACE_OK {
return Err(format!("processor callback failed with status {status}"));
}
result
.output
.ok_or_else(|| "processor callback did not set output".to_string())
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_from_file(
path: *const c_char,
out_handle: *mut *mut CopperlaceRuleSet,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
let Some(path) = read_c_string(path, out_error) else {
write_null_handle(out_handle);
return COPPERLACE_INVALID_ARGUMENT;
};
match ruleset_from_file(path) {
Ok(ruleset) => write_handle(ruleset, out_handle, out_error),
Err(error) => {
write_null_handle(out_handle);
write_out_string(out_error, &error.to_string());
COPPERLACE_PARSE_ERROR
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_from_file_with_processors(
path: *const c_char,
processor_names: *const *const c_char,
processor_callbacks: *const Option<CopperlaceProcessorCallback>,
processor_user_data: *const *mut c_void,
processor_len: usize,
out_handle: *mut *mut CopperlaceRuleSet,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
let Some(path) = read_c_string(path, out_error) else {
write_null_handle(out_handle);
return COPPERLACE_INVALID_ARGUMENT;
};
let Some(processors) = read_processors(
processor_names,
processor_callbacks,
processor_user_data,
processor_len,
out_error,
) else {
write_null_handle(out_handle);
return COPPERLACE_INVALID_ARGUMENT;
};
match load_file_with_processors(path, processors) {
Ok(ruleset) => write_handle(ruleset, out_handle, out_error),
Err(error) => {
write_null_handle(out_handle);
write_out_string(out_error, &error.to_string());
COPPERLACE_PARSE_ERROR
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_from_string(
config: *const c_char,
out_handle: *mut *mut CopperlaceRuleSet,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
let Some(config) = read_c_string(config, out_error) else {
write_null_handle(out_handle);
return COPPERLACE_INVALID_ARGUMENT;
};
match ruleset_from_str(&config) {
Ok(ruleset) => write_handle(ruleset, out_handle, out_error),
Err(error) => {
write_null_handle(out_handle);
write_out_string(out_error, &error.to_string());
COPPERLACE_PARSE_ERROR
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_from_string_with_processors(
config: *const c_char,
processor_names: *const *const c_char,
processor_callbacks: *const Option<CopperlaceProcessorCallback>,
processor_user_data: *const *mut c_void,
processor_len: usize,
out_handle: *mut *mut CopperlaceRuleSet,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
let Some(config) = read_c_string(config, out_error) else {
write_null_handle(out_handle);
return COPPERLACE_INVALID_ARGUMENT;
};
let Some(processors) = read_processors(
processor_names,
processor_callbacks,
processor_user_data,
processor_len,
out_error,
) else {
write_null_handle(out_handle);
return COPPERLACE_INVALID_ARGUMENT;
};
match load_str_with_processors(&config, processors) {
Ok(ruleset) => write_handle(ruleset, out_handle, out_error),
Err(error) => {
write_null_handle(out_handle);
write_out_string(out_error, &error.to_string());
COPPERLACE_PARSE_ERROR
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_processor_result_set_output(
result: *mut CopperlaceProcessorResult,
value: *const c_char,
) -> c_int {
if result.is_null() {
return COPPERLACE_INVALID_ARGUMENT;
}
let Some(value) = read_c_string(value, ptr::null_mut()) else {
return COPPERLACE_INVALID_ARGUMENT;
};
unsafe {
(*result).output = Some(value);
}
COPPERLACE_OK
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_processor_result_set_error(
result: *mut CopperlaceProcessorResult,
message: *const c_char,
) -> c_int {
if result.is_null() {
return COPPERLACE_INVALID_ARGUMENT;
}
let Some(message) = read_c_string(message, ptr::null_mut()) else {
return COPPERLACE_INVALID_ARGUMENT;
};
unsafe {
(*result).error = Some(message);
}
COPPERLACE_OK
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
out_string: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
unsafe {
copperlace_ruleset_render_with_context(
handle,
rule,
ptr::null(),
ptr::null(),
0,
out_string,
out_error,
)
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_with_context(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
context_keys: *const *const c_char,
context_values: *const *const c_char,
context_len: usize,
out_string: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
unsafe {
copperlace_ruleset_render_with_context_and_options(
handle,
rule,
context_keys,
context_values,
context_len,
0,
out_string,
out_error,
)
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_with_context_and_options(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
context_keys: *const *const c_char,
context_values: *const *const c_char,
context_len: usize,
max_recursion_depth: usize,
out_string: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
write_null_string(out_string);
if handle.is_null() {
write_out_string(out_error, "ruleset handle is null");
return COPPERLACE_INVALID_ARGUMENT;
}
let Some(rule) = read_c_string(rule, out_error) else {
return COPPERLACE_INVALID_ARGUMENT;
};
let Some(context) = read_context(context_keys, context_values, context_len, out_error) else {
return COPPERLACE_INVALID_ARGUMENT;
};
let ruleset = unsafe { &(*handle).ruleset };
let options = RenderOptions {
max_recursion_depth,
};
match ruleset.render_rule_with_context_and_options(&rule, context, options) {
Ok(output) => {
if write_out_string(out_string, &output) {
COPPERLACE_OK
} else {
write_out_string(out_error, "output string contains an interior NUL byte");
COPPERLACE_RENDER_ERROR
}
}
Err(error) => {
write_out_string(out_error, &error.to_string());
COPPERLACE_RENDER_ERROR
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_inferred(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
out_string: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
unsafe {
copperlace_ruleset_render_inferred_with_context(
handle,
rule,
ptr::null(),
ptr::null(),
0,
out_string,
out_error,
)
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_inferred_with_context(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
context_keys: *const *const c_char,
context_values: *const *const c_char,
context_len: usize,
out_string: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
unsafe {
copperlace_ruleset_render_inferred_with_context_and_options(
handle,
rule,
context_keys,
context_values,
context_len,
0,
out_string,
out_error,
)
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_inferred_with_context_and_options(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
context_keys: *const *const c_char,
context_values: *const *const c_char,
context_len: usize,
max_recursion_depth: usize,
out_string: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
write_null_string(out_string);
if handle.is_null() {
write_out_string(out_error, "ruleset handle is null");
return COPPERLACE_INVALID_ARGUMENT;
}
let Some(rule) = read_c_string(rule, out_error) else {
return COPPERLACE_INVALID_ARGUMENT;
};
let Some(context) = read_context(context_keys, context_values, context_len, out_error) else {
return COPPERLACE_INVALID_ARGUMENT;
};
let ruleset = unsafe { &(*handle).ruleset };
let options = RenderOptions {
max_recursion_depth,
};
match ruleset.render_rule_inferred_with_context_and_options(&rule, context, options) {
Ok(output) => {
if write_out_string(out_string, &output) {
COPPERLACE_OK
} else {
write_out_string(out_error, "output string contains an interior NUL byte");
COPPERLACE_RENDER_ERROR
}
}
Err(error) => {
write_out_string(out_error, &error.to_string());
COPPERLACE_RENDER_ERROR
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_structured_json(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
format_json: bool,
out_json: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
unsafe {
copperlace_ruleset_render_structured_json_with_context(
handle,
rule,
ptr::null(),
ptr::null(),
0,
format_json,
out_json,
out_error,
)
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_structured_json_with_context(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
context_keys: *const *const c_char,
context_values: *const *const c_char,
context_len: usize,
format_json: bool,
out_json: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
unsafe {
copperlace_ruleset_render_structured_json_with_context_and_options(
handle,
rule,
context_keys,
context_values,
context_len,
format_json,
0,
out_json,
out_error,
)
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_render_structured_json_with_context_and_options(
handle: *const CopperlaceRuleSet,
rule: *const c_char,
context_keys: *const *const c_char,
context_values: *const *const c_char,
context_len: usize,
format_json: bool,
max_recursion_depth: usize,
out_json: *mut *mut c_char,
out_error: *mut *mut c_char,
) -> c_int {
clear_out_error(out_error);
if out_json.is_null() {
write_out_string(out_error, "out_json is null");
return COPPERLACE_INVALID_ARGUMENT;
}
write_null_string(out_json);
if handle.is_null() {
write_out_string(out_error, "ruleset handle is null");
return COPPERLACE_INVALID_ARGUMENT;
}
let Some(rule) = read_c_string(rule, out_error) else {
return COPPERLACE_INVALID_ARGUMENT;
};
let Some(context) = read_context(context_keys, context_values, context_len, out_error) else {
return COPPERLACE_INVALID_ARGUMENT;
};
let ruleset = unsafe { &(*handle).ruleset };
let options = RenderOptions {
max_recursion_depth,
};
let json = ruleset
.render_rule_structured_with_context_and_options(&rule, context, options)
.and_then(|value| {
if format_json {
value.to_formatted_json()
} else {
value.to_compact_json()
}
});
match json {
Ok(output) => {
if write_out_string(out_json, &output) {
COPPERLACE_OK
} else {
write_out_string(out_error, "structured JSON contains an interior NUL byte");
COPPERLACE_RENDER_ERROR
}
}
Err(error) => {
write_out_string(out_error, &error.to_string());
COPPERLACE_RENDER_ERROR
}
}
}
fn read_context(
keys: *const *const c_char,
values: *const *const c_char,
len: usize,
out_error: *mut *mut c_char,
) -> Option<RenderContext> {
let mut context = RenderContext::new();
if len == 0 {
return Some(context);
}
if keys.is_null() {
write_out_string(out_error, "context keys array is null");
return None;
}
if values.is_null() {
write_out_string(out_error, "context values array is null");
return None;
}
for index in 0..len {
let key_ptr = unsafe { *keys.add(index) };
let value_ptr = unsafe { *values.add(index) };
let key = read_c_string(key_ptr, out_error)?;
let value = read_c_string(value_ptr, out_error)?;
context.insert(key, value);
}
Some(context)
}
fn read_processors(
names: *const *const c_char,
callbacks: *const Option<CopperlaceProcessorCallback>,
user_data: *const *mut c_void,
len: usize,
out_error: *mut *mut c_char,
) -> Option<ProcessorRegistry> {
let mut processors = ProcessorRegistry::new();
if len == 0 {
return Some(processors);
}
if names.is_null() {
write_out_string(out_error, "processor names array is null");
return None;
}
if callbacks.is_null() {
write_out_string(out_error, "processor callbacks array is null");
return None;
}
if user_data.is_null() {
write_out_string(out_error, "processor user data array is null");
return None;
}
for index in 0..len {
let name_ptr = unsafe { *names.add(index) };
let callback = unsafe { *callbacks.add(index) };
let Some(callback) = callback else {
write_out_string(out_error, "processor callback is null");
return None;
};
let name = read_c_string(name_ptr, out_error)?;
let user_data = unsafe { *user_data.add(index) };
processors.insert(
name,
std::sync::Arc::new(CallbackProcessor {
callback,
user_data,
}),
);
}
Some(processors)
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_ruleset_free(handle: *mut CopperlaceRuleSet) {
if !handle.is_null() {
unsafe {
drop(Box::from_raw(handle));
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn copperlace_string_free(value: *mut c_char) {
if !value.is_null() {
unsafe {
drop(CString::from_raw(value));
}
}
}
fn read_c_string(value: *const c_char, out_error: *mut *mut c_char) -> Option<String> {
if value.is_null() {
write_out_string(out_error, "input string is null");
return None;
}
match unsafe { CStr::from_ptr(value) }.to_str() {
Ok(value) => Some(value.to_string()),
Err(error) => {
write_out_string(
out_error,
&format!("input string is not valid UTF-8: {error}"),
);
None
}
}
}
fn write_handle(
ruleset: RuleSet,
out_handle: *mut *mut CopperlaceRuleSet,
out_error: *mut *mut c_char,
) -> c_int {
if out_handle.is_null() {
write_out_string(out_error, "out_handle is null");
return COPPERLACE_INVALID_ARGUMENT;
}
let handle = Box::into_raw(Box::new(CopperlaceRuleSet { ruleset }));
unsafe {
*out_handle = handle;
}
COPPERLACE_OK
}
fn write_null_handle(out_handle: *mut *mut CopperlaceRuleSet) {
if !out_handle.is_null() {
unsafe {
*out_handle = ptr::null_mut();
}
}
}
fn write_null_string(out_string: *mut *mut c_char) {
if !out_string.is_null() {
unsafe {
*out_string = ptr::null_mut();
}
}
}
fn clear_out_error(out_error: *mut *mut c_char) {
write_null_string(out_error);
}
fn write_out_string(out_string: *mut *mut c_char, value: &str) -> bool {
if out_string.is_null() {
return true;
}
let Ok(value) = CString::new(value) else {
return false;
};
unsafe {
*out_string = value.into_raw();
}
true
}