modsecurity 1.0.0

A high-level Rust interface to libmodsecurity
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use modsecurity_sys::{ModSecLogCb, ModSecurity, ModSecurityIntervention, RulesSet, Transaction};

pub(crate) mod types {
    pub use modsecurity_sys::{ModSecurityIntervention_t, ModSecurity_t, Rules_t, Transaction_t};
}

macro_rules! sys_passthrough {
    // With return type
    ($(
        unsafe fn $name:ident(
            $($param_name:ident: $param_type:ty),*
        ) $( -> $ret:ty)?;
    )*) => {
        $(
            unsafe fn $name($($param_name: $param_type),*) $( -> $ret)? {
                ::modsecurity_sys::$name($($param_name),*)
            }
        )*
    };
}

/// A trait that wraps the FFI bindings to ModSecurity.
/// Consumers of this library should not need to use this trait directly.
/// It is primarily used for testing.
#[allow(non_snake_case)]
#[doc(hidden)]
pub trait RawBindings {
    sys_passthrough! {
        unsafe fn msc_new_transaction(
            ms: *mut ModSecurity,
            rules: *mut RulesSet,
            logCbData: *mut ::std::os::raw::c_void
        ) -> *mut Transaction;

        unsafe fn msc_new_transaction_with_id(
            ms: *mut ModSecurity,
            rules: *mut RulesSet,
            id: *mut ::std::os::raw::c_char,
            logCbData: *mut ::std::os::raw::c_void
        ) -> *mut Transaction;

        unsafe fn msc_process_connection(
            transaction: *mut Transaction,
            client: *const ::std::os::raw::c_char,
            cPort: ::std::os::raw::c_int,
            server: *const ::std::os::raw::c_char,
            sPort: ::std::os::raw::c_int
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_process_request_headers(transaction: *mut Transaction) -> ::std::os::raw::c_int;

        unsafe fn msc_add_request_header(
            transaction: *mut Transaction,
            key: *const ::std::os::raw::c_uchar,
            value: *const ::std::os::raw::c_uchar
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_process_request_body(transaction: *mut Transaction) -> ::std::os::raw::c_int;

        unsafe fn msc_append_request_body(
            transaction: *mut Transaction,
            body: *const ::std::os::raw::c_uchar,
            size: usize
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_process_response_headers(
            transaction: *mut Transaction,
            code: ::std::os::raw::c_int,
            protocol: *const ::std::os::raw::c_char
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_add_response_header(
            transaction: *mut Transaction,
            key: *const ::std::os::raw::c_uchar,
            value: *const ::std::os::raw::c_uchar
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_process_response_body(transaction: *mut Transaction) -> ::std::os::raw::c_int;

        unsafe fn msc_append_response_body(
            transaction: *mut Transaction,
            body: *const ::std::os::raw::c_uchar,
            size: usize
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_process_uri(
            transaction: *mut Transaction,
            uri: *const ::std::os::raw::c_char,
            protocol: *const ::std::os::raw::c_char,
            http_version: *const ::std::os::raw::c_char
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_get_response_body_length(transaction: *mut Transaction) -> usize;

        unsafe fn msc_get_request_body_length(transaction: *mut Transaction) -> usize;

        unsafe fn msc_transaction_cleanup(transaction: *mut Transaction);

        unsafe fn msc_intervention(
            transaction: *mut Transaction,
            it: *mut ModSecurityIntervention
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_intervention_cleanup(it: *mut ModSecurityIntervention);

        unsafe fn msc_process_logging(transaction: *mut Transaction) -> ::std::os::raw::c_int;

        unsafe fn msc_init() -> *mut ModSecurity;

        unsafe fn msc_who_am_i(msc: *mut ModSecurity) -> *const ::std::os::raw::c_char;

        unsafe fn msc_set_connector_info(msc: *mut ModSecurity, connector: *const ::std::os::raw::c_char);

        unsafe fn msc_set_log_cb(msc: *mut ModSecurity, cb: ModSecLogCb);

        unsafe fn msc_cleanup(msc: *mut ModSecurity);

        unsafe fn msc_create_rules_set() -> *mut RulesSet;

        unsafe fn msc_rules_dump(rules: *mut RulesSet);

        unsafe fn msc_rules_add_file(
            rules: *mut RulesSet,
            file: *const ::std::os::raw::c_char,
            error: *mut *const ::std::os::raw::c_char
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_rules_add(
            rules: *mut RulesSet,
            plain_rules: *const ::std::os::raw::c_char,
            error: *mut *const ::std::os::raw::c_char
        ) -> ::std::os::raw::c_int;

        unsafe fn msc_rules_error_cleanup(error: *const ::std::os::raw::c_char);

        unsafe fn msc_rules_cleanup(rules: *mut RulesSet) -> ::std::os::raw::c_int;
    }
}

#[derive(Clone, Copy)]
pub struct Bindings;

impl Default for Bindings {
    fn default() -> Self {
        Self
    }
}

impl RawBindings for Bindings {}