redirectionio 2.5.2

Redirection IO Library to handle matching rule, redirect and filtering headers and body.
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

use crate::action::Action;
use crate::api::{Rule, RulesMessage};
use crate::ffi_helpers::c_char_to_str;
use crate::http::Request;
use crate::router::{Route, Router, RouterConfig};
use std::os::raw::{c_char, c_ulong};
use std::ptr::null;

#[no_mangle]
pub unsafe extern "C" fn redirectionio_router_create(
    config_serialized: *mut c_char,
    _message: *mut RulesMessage,
    cache: u64,
) -> *mut Router<Rule> {
    let config = match c_char_to_str(config_serialized) {
        None => RouterConfig::default(),
        Some(str) => {
            if str.is_empty() {
                RouterConfig::default()
            } else {
                match serde_json::from_str(str) {
                    Ok(value) => value,
                    Err(error) => {
                        error!("Unable to deserialize router config: {}", error,);

                        RouterConfig::default()
                    }
                }
            }
        }
    };

    let mut router = Router::<Rule>::from_config(config);

    if !_message.is_null() {
        let message = Box::from_raw(_message);

        for rule in message.rules {
            router.insert(rule.into_route(&router.config));
        }
    }

    router.cache(cache);

    Box::into_raw(Box::new(router))
}

#[no_mangle]
pub unsafe extern "C" fn redirectionio_router_route_add(_route: *mut Route<Rule>, _router: *mut Router<Rule>) {
    let route = Box::from_raw(_route);
    let router = &mut *_router;

    router.insert(*route);
}

#[no_mangle]
pub unsafe extern "C" fn redirectionio_router_route_remove(_route_id: *const c_char, _router: *mut Router<Rule>) {
    if _router.is_null() {
        return;
    }

    let route_id = c_char_to_str(_route_id);

    if route_id.is_none() {
        return;
    }

    let router = &mut *_router;

    router.remove(route_id.unwrap());
}

#[no_mangle]
pub unsafe extern "C" fn redirectionio_router_drop(_router: *mut Router<Rule>) {
    if _router.is_null() {
        return;
    }

    drop(Box::from_raw(_router));
}

#[no_mangle]
pub unsafe extern "C" fn redirectionio_router_match_action(_router: *const Router<Rule>, _request: *const Request) -> *const Action {
    if _router.is_null() || _request.is_null() {
        return null() as *const Action;
    }

    let router = &*_router;
    let request = &*_request;

    let routes = router.match_request(request);
    let action = Action::from_routes_rule(routes, request);

    Box::into_raw(Box::new(action))
}

#[no_mangle]
pub unsafe extern "C" fn redirectionio_router_len(_router: *const Router<Rule>) -> c_ulong {
    if _router.is_null() {
        return 0;
    }

    let router = &*_router;

    router.len() as c_ulong
}