plist_ffi 0.1.6

C FFI for the amazing plist crate, compatible with libplist
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

// Jackson Coxson

use plist::{Dictionary, Uid, Value};
use std::ffi::{CStr, CString, c_char};

use crate::plist_t;

/// Creates a new dictionary plist
#[unsafe(no_mangle)]
pub extern "C" fn plist_new_dict() -> plist_t {
    let p = Value::Dictionary(Dictionary::new()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

/// Creates a new array plist
#[unsafe(no_mangle)]
pub extern "C" fn plist_new_array() -> plist_t {
    let p = Value::Array(Vec::new()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

/// # Safety
/// Don't pass a bad string, libplist doesn't check the string
#[unsafe(no_mangle)]
pub unsafe extern "C" fn plist_new_string(val: *const c_char) -> plist_t {
    let s = unsafe { CStr::from_ptr(val) }.to_str().unwrap();
    let p = Value::String(s.to_string()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

#[unsafe(no_mangle)]
pub extern "C" fn plist_new_bool(val: u8) -> plist_t {
    let p = Value::Boolean(val != 0).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

#[unsafe(no_mangle)]
pub extern "C" fn plist_new_uint(val: u64) -> plist_t {
    let p = Value::Integer(val.into()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

#[unsafe(no_mangle)]
pub extern "C" fn plist_new_int(val: i64) -> plist_t {
    let p = Value::Integer(val.into()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

#[unsafe(no_mangle)]
pub extern "C" fn plist_new_real(val: f64) -> plist_t {
    let p = Value::Real(val).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

/// # Safety
/// Rust owns your data now. Don't pass a bad pointer >:(
#[unsafe(no_mangle)]
pub unsafe extern "C" fn plist_new_data(val: *const u8, length: u64) -> plist_t {
    let slice = unsafe { std::slice::from_raw_parts(val, length as usize) }.to_vec();
    let p = Value::Data(slice).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

/// Don't pass a negative number >:(
#[unsafe(no_mangle)]
pub extern "C" fn plist_new_unix_date(sec: i64) -> plist_t {
    let s = std::time::UNIX_EPOCH + std::time::Duration::from_secs(sec as u64);
    let p = Value::Date(s.into()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

#[unsafe(no_mangle)]
pub extern "C" fn plist_new_uid(val: u64) -> plist_t {
    let p = Value::Uid(Uid::new(val)).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

/// So there's no null plist type in Rust, so we'll just have an empty data :shrug:
#[unsafe(no_mangle)]
pub extern "C" fn plist_new_null() -> plist_t {
    let p = Value::Data(Vec::new()).into();
    let p = Box::new(p);
    Box::into_raw(p)
}

/// # Safety
/// Needs to be allocated by this library
#[unsafe(no_mangle)]
pub unsafe extern "C" fn plist_free(plist: plist_t) {
    if plist.is_null() {
        return;
    }
    let _parent = unsafe { Box::from_raw(plist) };
    // The drop function will take care of the children
}

/// # Safety
/// Needs to be allocated by this library
#[unsafe(no_mangle)]
pub unsafe extern "C" fn plist_copy(node: plist_t) -> plist_t {
    let p = unsafe { &*node };
    let p = Box::new(p.clone());
    Box::into_raw(p)
}

/// # Safety
/// Needs to be allocated by this library
/// I sure hope nothing bad happens
#[unsafe(no_mangle)]
pub unsafe extern "C" fn plist_mem_free(data: *mut c_char) {
    let _ = unsafe { CString::from_raw(data) };
}