plamo/
lib.rs

1use std::os::raw::{c_char, c_uchar, c_uint, c_void};
2
3#[repr(u32)]
4#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5pub enum PlamoScheme {
6    PlamoSchemeHttp,
7    PlamoSchemeHttps,
8}
9
10#[repr(u32)]
11#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
12pub enum PlamoHttpVersion {
13    PlamoHttpVersionHttp09,
14    PlamoHttpVersionHttp10,
15    PlamoHttpVersionHttp11,
16    PlamoHttpVersionHttp20,
17}
18
19#[repr(C)]
20#[derive(Debug, Copy, Clone)]
21pub struct PlamoString {
22    _unused: [u8; 0],
23}
24
25extern "C" {
26    pub fn plamo_string_new(value: *const c_char) -> *mut PlamoString;
27    pub fn plamo_string_destroy(plamo_string: *mut PlamoString);
28    pub fn plamo_string_get_char(plamo_string: *const PlamoString) -> *const c_char;
29}
30
31#[repr(C)]
32#[derive(Debug, Copy, Clone)]
33pub struct PlamoStringArray {
34    _unused: [u8; 0],
35}
36
37extern "C" {
38    pub fn plamo_string_array_new() -> *mut PlamoStringArray;
39    pub fn plamo_string_array_destroy(plamo_string_array: *mut PlamoStringArray);
40    pub fn plamo_string_array_length(plamo_string_array: *const PlamoStringArray) -> usize;
41    pub fn plamo_string_array_for_each(
42        plamo_string_array: *const PlamoStringArray,
43        callback: Option<unsafe extern "C" fn(arg1: *const c_char)>,
44    );
45    pub fn plamo_string_array_get_at(
46        plamo_string_array: *const PlamoStringArray,
47        index: usize,
48    ) -> *const c_char;
49    pub fn plamo_string_array_get_first(
50        plamo_string_array: *const PlamoStringArray,
51    ) -> *const c_char;
52    pub fn plamo_string_array_get_last(
53        plamo_string_array: *const PlamoStringArray,
54    ) -> *const c_char;
55    pub fn plamo_string_array_add(
56        plamo_string_array: *mut PlamoStringArray,
57        value: *const c_char,
58    );
59    pub fn plamo_string_array_remove_at(
60        plamo_string_array: *mut PlamoStringArray,
61        index: usize,
62    ) -> bool;
63}
64
65#[repr(C)]
66#[derive(Debug, Copy, Clone)]
67pub struct PlamoByteArray {
68    _unused: [u8; 0],
69}
70
71extern "C" {
72    pub fn plamo_byte_array_new(
73        body: *const c_uchar,
74        length: usize,
75    ) -> *mut PlamoByteArray;
76    pub fn plamo_byte_array_destroy(plamo_byte_array: *mut PlamoByteArray);
77    pub fn plamo_byte_array_get_body(
78        plamo_byte_array: *const PlamoByteArray,
79    ) -> *const c_uchar;
80    pub fn plamo_byte_array_get_body_size(plamo_byte_array: *const PlamoByteArray) -> usize;
81}
82
83#[repr(C)]
84#[derive(Debug, Copy, Clone)]
85pub struct PlamoHttpHeader {
86    _unused: [u8; 0],
87}
88
89extern "C" {
90    pub fn plamo_http_header_new() -> *mut PlamoHttpHeader;
91    pub fn plamo_http_header_destroy(plamo_http_header: *mut PlamoHttpHeader);
92    pub fn plamo_http_header_for_each(
93        plamo_http_header: *mut PlamoHttpHeader,
94        callback: Option<
95            unsafe extern "C" fn(arg1: *const c_char, arg2: *const c_char),
96        >,
97    );
98    pub fn plamo_http_header_get(
99        plamo_http_header: *mut PlamoHttpHeader,
100        key: *const c_char,
101    ) -> *mut PlamoStringArray;
102    pub fn plamo_http_header_add(
103        plamo_http_header: *mut PlamoHttpHeader,
104        key: *const c_char,
105        value: *const c_char,
106    );
107    pub fn plamo_http_header_remove(
108        plamo_http_header: *mut PlamoHttpHeader,
109        key: *const c_char,
110    ) -> bool;
111}
112
113#[repr(C)]
114#[derive(Debug, Copy, Clone)]
115pub struct PlamoHttpQuery {
116    _unused: [u8; 0],
117}
118
119extern "C" {
120    pub fn plamo_http_query_new() -> *mut PlamoHttpQuery;
121    pub fn plamo_http_query_destroy(plamo_http_query: *mut PlamoHttpQuery);
122    pub fn plamo_http_query_for_each(
123        plamo_http_query: *mut PlamoHttpQuery,
124        callback: Option<
125            unsafe extern "C" fn(arg1: *const c_char, arg2: *const c_char),
126        >,
127    );
128    pub fn plamo_http_query_get(
129        plamo_http_query: *mut PlamoHttpQuery,
130        key: *const c_char,
131    ) -> *mut PlamoStringArray;
132    pub fn plamo_http_query_add(
133        plamo_http_query: *mut PlamoHttpQuery,
134        key: *const c_char,
135        value: *const c_char,
136    );
137    pub fn plamo_http_query_remove(
138        plamo_http_query: *mut PlamoHttpQuery,
139        key: *const c_char,
140    ) -> bool;
141}
142
143pub type PlamoDefinedHttpMethod = usize;
144
145pub const PLAMO_HTTP_METHOD_GET: PlamoDefinedHttpMethod = usize::max_value();
146pub const PLAMO_HTTP_METHOD_POST: PlamoDefinedHttpMethod = usize::max_value() - 1;
147pub const PLAMO_HTTP_METHOD_PUT: PlamoDefinedHttpMethod = usize::max_value() - 2;
148pub const PLAMO_HTTP_METHOD_DELETE: PlamoDefinedHttpMethod = usize::max_value() - 3;
149pub const PLAMO_HTTP_METHOD_HEAD: PlamoDefinedHttpMethod = usize::max_value() - 4;
150pub const PLAMO_HTTP_METHOD_CONNECT: PlamoDefinedHttpMethod = usize::max_value() - 5;
151pub const PLAMO_HTTP_METHOD_OPTIONS: PlamoDefinedHttpMethod = usize::max_value() - 6;
152pub const PLAMO_HTTP_METHOD_TRACE: PlamoDefinedHttpMethod = usize::max_value() - 7;
153pub const PLAMO_HTTP_METHOD_PATCH: PlamoDefinedHttpMethod = usize::max_value() - 8;
154
155#[repr(C)]
156#[derive(Copy, Clone)]
157pub union PlamoHttpMethod {
158    pub defined_http_method: PlamoDefinedHttpMethod,
159    pub undefined_http_method: *mut c_char,
160}
161
162unsafe impl Send for PlamoHttpMethod {}
163unsafe impl Sync for PlamoHttpMethod {}
164
165extern "C" {
166    pub fn plamo_http_method_new(method: usize) -> PlamoHttpMethod;
167    pub fn plamo_http_method_destroy(plamo_http_method: *mut PlamoHttpMethod);
168}
169
170#[repr(C)]
171#[derive(Copy, Clone)]
172pub struct PlamoRequest {
173    pub scheme: PlamoScheme,
174    pub version: PlamoHttpVersion,
175    pub method: PlamoHttpMethod,
176    pub path: *mut PlamoString,
177    pub query: *mut PlamoHttpQuery,
178    pub header: *mut PlamoHttpHeader,
179    pub body: *mut PlamoByteArray,
180}
181
182extern "C" {
183    pub fn plamo_request_new(
184        scheme: PlamoScheme,
185        version: PlamoHttpVersion,
186        method: PlamoHttpMethod,
187        path: *const c_char,
188        query: *mut PlamoHttpQuery,
189        header: *mut PlamoHttpHeader,
190        body: *mut PlamoByteArray,
191    ) -> *mut PlamoRequest;
192    pub fn plamo_request_destroy(plamo_request: *mut PlamoRequest);
193}
194
195#[repr(C)]
196#[derive(Debug, Copy, Clone)]
197pub struct PlamoResponse {
198    pub status_code: c_uint,
199    pub header: *mut PlamoHttpHeader,
200    pub body: *mut PlamoByteArray,
201}
202
203extern "C" {
204    pub fn plamo_response_new() -> *mut PlamoResponse;
205    pub fn plamo_response_destroy(plamo_response: *mut PlamoResponse);
206}
207
208#[repr(C)]
209#[derive(Debug, Copy, Clone)]
210pub struct PlamoFormUrlencoded {
211    _unused: [u8; 0],
212}
213
214extern "C" {
215    pub fn plamo_form_urlencoded_new(plamo_request: *const PlamoRequest) -> *mut PlamoFormUrlencoded;
216    pub fn plamo_form_urlencoded_destroy(plamo_form_urlencoded: *mut PlamoFormUrlencoded);
217    pub fn plamo_form_urlencoded_for_each(
218        plamo_form_urlencoded: *const PlamoFormUrlencoded,
219        callback: Option<
220            unsafe extern "C" fn(arg1: *const c_char, arg2: *const c_char),
221        >
222    );
223    pub fn plamo_form_urlencoded_get(plamo_form_urlencoded: *const PlamoFormUrlencoded, key: *const c_char) -> *const PlamoStringArray;
224}
225
226#[repr(C)]
227#[derive(Debug, Copy, Clone)]
228pub struct PlamoFormDataFile {
229    _unused: [u8; 0],
230}
231
232extern "C" {
233    pub fn plamo_form_data_file_get_content_type(plamo_form_data_file: *const PlamoFormDataFile) -> *const c_char;
234    pub fn plamo_form_data_file_get_file_name(plamo_form_data_file: *const PlamoFormDataFile) -> *const c_char;
235    pub fn plamo_form_data_file_get_body(plamo_form_data_file: *const PlamoFormDataFile) -> *const c_uchar;
236    pub fn plamo_form_data_file_get_body_size(plamo_form_data_file: *const PlamoFormDataFile) -> usize;
237}
238
239#[repr(C)]
240#[derive(Debug, Copy, Clone)]
241pub struct PlamoFormDataField {
242    pub text: *mut PlamoString,
243    pub file: *mut PlamoFormDataFile,
244}
245
246#[repr(C)]
247#[derive(Debug, Copy, Clone)]
248pub struct PlamoFormDataFieldArray {
249    _unused: [u8; 0],
250}
251
252extern "C" {
253    pub fn plamo_form_data_field_array_length(plamo_form_data_field_array: *const PlamoFormDataFieldArray) -> usize;
254    pub fn plamo_form_data_field_array_for_each(
255        plamo_form_data_field_array: *const PlamoFormDataFieldArray,
256        callback: Option<
257            unsafe extern "C" fn(*const PlamoFormDataField),
258        >
259    );
260    pub fn plamo_form_data_field_array_get_at(plamo_form_data_field_array: *const PlamoFormDataFieldArray, index: usize) -> *const PlamoFormDataField;
261    pub fn plamo_form_data_field_array_get_first(plamo_form_data_field_array: *const PlamoFormDataFieldArray) -> *const PlamoFormDataField;
262    pub fn plamo_form_data_field_array_get_last(plamo_form_data_field_array: *const PlamoFormDataFieldArray) -> *const PlamoFormDataField;
263}
264
265#[repr(C)]
266#[derive(Debug, Copy, Clone)]
267pub struct PlamoFormData {
268    _unused: [u8; 0],
269}
270
271extern "C" {
272    pub fn plamo_form_data_new(plamo_request: *const PlamoRequest) -> *mut PlamoFormData;
273    pub fn plamo_form_data_destroy(plamo_form_data: *mut PlamoFormData);
274    pub fn plamo_form_data_for_each(
275        plamo_form_data: *const PlamoFormData,
276        callback: Option<
277            unsafe extern "C" fn(arg1: *const c_char, arg2: *const PlamoFormDataField),
278        >
279    );
280    pub fn plamo_form_data_get(plamo_form_data: *const PlamoFormData, key: *const c_char) -> *const PlamoFormDataFieldArray;
281}
282
283#[repr(C)]
284#[derive(Debug, Copy, Clone)]
285pub struct PlamoMiddleware {
286    pub config: *const c_void,
287    pub callback: Option<
288        unsafe extern "C" fn(
289            arg1: *const c_void,
290            arg2: *const PlamoRequest,
291            arg3: *mut PlamoResponse,
292        ),
293    >,
294}
295
296extern "C" {
297    pub fn plamo_middleware_new(
298        config: *const c_void,
299        callback: Option<
300            unsafe extern "C" fn(
301                arg1: *const c_void,
302                arg2: *const PlamoRequest,
303                arg3: *mut PlamoResponse,
304            ),
305        >,
306    ) -> *mut PlamoMiddleware;
307    pub fn plamo_middleware_destroy(plamo_middleware: *mut PlamoMiddleware);
308}
309
310#[repr(C)]
311#[derive(Debug, Copy, Clone)]
312pub struct PlamoApp {
313    _unused: [u8; 0],
314}
315
316extern "C" {
317    pub fn plamo_app_new() -> *mut PlamoApp;
318    pub fn plamo_app_destroy(plamo_app: *mut PlamoApp);
319    pub fn plamo_app_add_middleware(
320        plamo_app: *mut PlamoApp,
321        plamo_middleware: *const PlamoMiddleware,
322    );
323    pub fn plamo_app_execute(
324        plamo_app: *const PlamoApp,
325        plamo_request: *const PlamoRequest,
326    ) -> *mut PlamoResponse;
327}
plamo/lib.rs

plamo/
lib.rs
