aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rust: functions that reference raw pointers are unsafe

Browse Source 
Based on the Rust clippy lint that recommends that any public
function that dereferences a raw pointer, mark all FFI functions
that reference raw pointers with build_slice and cast_pointer
as unsafe.

This commits starts by removing the unsafe wrapper inside
the build_slice and cast_pointer macros then marks all
functions that use these macros as unsafe.

Then fix all not_unsafe_ptr_arg_deref warnings from clippy.

Fixes clippy lint:
https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
pull/6304/head
Jason Ish 4 years ago committed by Victor Julien
parent 53413f2d7a
commit 363b5f99c3
36 changed files with 594 additions and 766 deletions
Show Stats Download Patch File Download Diff File

39
rust/src/applayer.rs
Unescape Escape View File

@ -238,7 +238,7 @@ pub struct RustParser {
/// UNSAFE !
#[macro_export]
macro_rules! build_slice {
($buf:ident, $len:expr) => ( unsafe{ std::slice::from_raw_parts($buf, $len) } );
($buf:ident, $len:expr) => ( std::slice::from_raw_parts($buf, $len) );
}
/// Cast pointer to a variable, as a mutable reference to an object
@ -246,32 +246,33 @@ macro_rules! build_slice {
/// UNSAFE !
#[macro_export]
macro_rules! cast_pointer {
($ptr:ident, $ty:ty) => ( unsafe{ &mut *($ptr as *mut $ty) } );
($ptr:ident, $ty:ty) => ( &mut *($ptr as *mut $ty) );
}
pub type ParseFn = extern "C" fn (flow: *const Flow,
pub type ParseFn = unsafe extern "C" fn (flow: *const Flow,
state: *mut c_void,
pstate: *mut c_void,
input: *const u8,
input_len: u32,
data: *const c_void,
flags: u8) -> AppLayerResult;
pub type ProbeFn = extern "C" fn (flow: *const Flow, flags: u8, input:*const u8, input_len: u32, rdir: *mut u8) -> AppProto;
pub type ProbeFn = unsafe extern "C" fn (flow: *const Flow, flags: u8, input:*const u8, input_len: u32, rdir: *mut u8) -> AppProto;
pub type StateAllocFn = extern "C" fn (*mut c_void, AppProto) -> *mut c_void;
pub type StateFreeFn = extern "C" fn (*mut c_void);
pub type StateTxFreeFn = extern "C" fn (*mut c_void, u64);
pub type StateGetTxFn = extern "C" fn (*mut c_void, u64) -> *mut c_void;
pub type StateGetTxCntFn = extern "C" fn (*mut c_void) -> u64;
pub type StateGetProgressFn = extern "C" fn (*mut c_void, u8) -> c_int;
pub type GetDetectStateFn = extern "C" fn (*mut c_void) -> *mut DetectEngineState;
pub type SetDetectStateFn = extern "C" fn (*mut c_void, &mut DetectEngineState) -> c_int;
pub type GetEventInfoFn = extern "C" fn (*const c_char, *mut c_int, *mut AppLayerEventType) -> c_int;
pub type GetEventInfoByIdFn = extern "C" fn (c_int, *mut *const c_char, *mut AppLayerEventType) -> i8;
pub type GetEventsFn = extern "C" fn (*mut c_void) -> *mut AppLayerDecoderEvents;
pub type StateFreeFn = unsafe extern "C" fn (*mut c_void);
pub type StateTxFreeFn = unsafe extern "C" fn (*mut c_void, u64);
pub type StateGetTxFn = unsafe extern "C" fn (*mut c_void, u64) -> *mut c_void;
pub type StateGetTxCntFn = unsafe extern "C" fn (*mut c_void) -> u64;
pub type StateGetProgressFn = unsafe extern "C" fn (*mut c_void, u8) -> c_int;
pub type GetDetectStateFn = unsafe extern "C" fn (*mut c_void) -> *mut DetectEngineState;
pub type SetDetectStateFn = unsafe extern "C" fn (*mut c_void, &mut DetectEngineState) -> c_int;
pub type GetEventInfoFn = unsafe extern "C" fn (*const c_char, *mut c_int, *mut AppLayerEventType) -> c_int;
pub type GetEventInfoByIdFn = unsafe extern "C" fn (c_int, *mut *const c_char, *mut AppLayerEventType) -> i8;
pub type GetEventsFn = unsafe extern "C" fn (*mut c_void) -> *mut AppLayerDecoderEvents;
pub type LocalStorageNewFn = extern "C" fn () -> *mut c_void;
pub type LocalStorageFreeFn = extern "C" fn (*mut c_void);
pub type GetFilesFn = extern "C" fn (*mut c_void, u8) -> *mut FileContainer;
pub type GetTxIteratorFn = extern "C" fn (ipproto: u8, alproto: AppProto,
pub type GetFilesFn = unsafe
extern "C" fn (*mut c_void, u8) -> *mut FileContainer;
pub type GetTxIteratorFn = unsafe extern "C" fn (ipproto: u8, alproto: AppProto,
state: *mut c_void,
min_tx_id: u64,
max_tx_id: u64,
@ -320,7 +321,7 @@ pub const APP_LAYER_PARSER_BYPASS_READY : u8 = BIT_U8!(4);
pub const APP_LAYER_PARSER_OPT_ACCEPT_GAPS: u32 = BIT_U32!(0);
pub const APP_LAYER_PARSER_OPT_UNIDIR_TXS: u32 = BIT_U32!(1);
pub type AppLayerGetTxIteratorFn = extern "C" fn (ipproto: u8,
pub type AppLayerGetTxIteratorFn = unsafe extern "C" fn (ipproto: u8,
alproto: AppProto,
alstate: *mut c_void,
min_tx_id: u64,
@ -384,7 +385,7 @@ impl LoggerFlags {
macro_rules!export_tx_get_detect_state {
($name:ident, $type:ty) => (
#[no_mangle]
pub extern "C" fn $name(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn $name(tx: *mut std::os::raw::c_void)
-> *mut core::DetectEngineState
{
let tx = cast_pointer!(tx, $type);
@ -405,7 +406,7 @@ macro_rules!export_tx_get_detect_state {
macro_rules!export_tx_set_detect_state {
($name:ident, $type:ty) => (
#[no_mangle]
pub extern "C" fn $name(tx: *mut std::os::raw::c_void,
pub unsafe extern "C" fn $name(tx: *mut std::os::raw::c_void,
de_state: &mut core::DetectEngineState) -> std::os::raw::c_int
{
let tx = cast_pointer!(tx, $type);

2
rust/src/applayertemplate/logger.rs
Unescape Escape View File

@ -30,7 +30,7 @@ fn log_template(tx: &TemplateTransaction, js: &mut JsonBuilder) -> Result<(), Js
}
#[no_mangle]
pub extern "C" fn rs_template_logger_log(tx: *mut std::os::raw::c_void, js: &mut JsonBuilder) -> bool {
pub unsafe extern "C" fn rs_template_logger_log(tx: *mut std::os::raw::c_void, js: &mut JsonBuilder) -> bool {
let tx = cast_pointer!(tx, TemplateTransaction);
log_template(tx, js).is_ok()
}

60
rust/src/applayertemplate/template.rs
Unescape Escape View File

@ -276,7 +276,7 @@ export_tx_set_detect_state!(
/// C entry point for a probing parser.
#[no_mangle]
pub extern "C" fn rs_template_probing_parser(
pub unsafe extern "C" fn rs_template_probing_parser(
_flow: *const Flow,
_direction: u8,
input: *const u8,
@ -287,7 +287,7 @@ pub extern "C" fn rs_template_probing_parser(
if input_len > 1 && input != std::ptr::null_mut() {
let slice = build_slice!(input, input_len as usize);
if probe(slice).is_ok() {
return unsafe { ALPROTO_TEMPLATE };
return ALPROTO_TEMPLATE;
}
}
return ALPROTO_UNKNOWN;
@ -301,12 +301,12 @@ pub extern "C" fn rs_template_state_new(_orig_state: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_template_state_free(state: *mut std::os::raw::c_void) {
std::mem::drop(unsafe { Box::from_raw(state as *mut TemplateState) });
pub unsafe extern "C" fn rs_template_state_free(state: *mut std::os::raw::c_void) {
std::mem::drop(Box::from_raw(state as *mut TemplateState));
}
#[no_mangle]
pub extern "C" fn rs_template_state_tx_free(
pub unsafe extern "C" fn rs_template_state_tx_free(
state: *mut std::os::raw::c_void,
tx_id: u64,
) {
@ -315,7 +315,7 @@ pub extern "C" fn rs_template_state_tx_free(
}
#[no_mangle]
pub extern "C" fn rs_template_parse_request(
pub unsafe extern "C" fn rs_template_parse_request(
_flow: *const Flow,
state: *mut std::os::raw::c_void,
pstate: *mut std::os::raw::c_void,
@ -324,12 +324,10 @@ pub extern "C" fn rs_template_parse_request(
_data: *const std::os::raw::c_void,
_flags: u8,
) -> AppLayerResult {
let eof = unsafe {
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS) > 0 {
true
} else {
false
}
let eof = if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS) > 0 {
true
} else {
false
};
if eof {
@ -351,7 +349,7 @@ pub extern "C" fn rs_template_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_template_parse_response(
pub unsafe extern "C" fn rs_template_parse_response(
_flow: *const Flow,
state: *mut std::os::raw::c_void,
pstate: *mut std::os::raw::c_void,
@ -360,12 +358,10 @@ pub extern "C" fn rs_template_parse_response(
_data: *const std::os::raw::c_void,
_flags: u8,
) -> AppLayerResult {
let _eof = unsafe {
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC) > 0 {
true
} else {
false
}
let _eof = if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC) > 0 {
true
} else {
false
};
let state = cast_pointer!(state, TemplateState);
@ -381,7 +377,7 @@ pub extern "C" fn rs_template_parse_response(
}
#[no_mangle]
pub extern "C" fn rs_template_state_get_tx(
pub unsafe extern "C" fn rs_template_state_get_tx(
state: *mut std::os::raw::c_void,
tx_id: u64,
) -> *mut std::os::raw::c_void {
@ -397,7 +393,7 @@ pub extern "C" fn rs_template_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_template_state_get_tx_count(
pub unsafe extern "C" fn rs_template_state_get_tx_count(
state: *mut std::os::raw::c_void,
) -> u64 {
let state = cast_pointer!(state, TemplateState);
@ -405,7 +401,7 @@ pub extern "C" fn rs_template_state_get_tx_count(
}
#[no_mangle]
pub extern "C" fn rs_template_tx_get_alstate_progress(
pub unsafe extern "C" fn rs_template_tx_get_alstate_progress(
tx: *mut std::os::raw::c_void,
_direction: u8,
) -> std::os::raw::c_int {
@ -419,7 +415,7 @@ pub extern "C" fn rs_template_tx_get_alstate_progress(
}
#[no_mangle]
pub extern "C" fn rs_template_state_get_events(
pub unsafe extern "C" fn rs_template_state_get_events(
tx: *mut std::os::raw::c_void
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, TemplateTransaction);
@ -443,7 +439,7 @@ pub extern "C" fn rs_template_state_get_event_info_by_id(_event_id: std::os::raw
return -1;
}
#[no_mangle]
pub extern "C" fn rs_template_state_get_tx_iterator(
pub unsafe extern "C" fn rs_template_state_get_tx_iterator(
_ipproto: u8,
_alproto: AppProto,
state: *mut std::os::raw::c_void,
@ -473,7 +469,7 @@ pub extern "C" fn rs_template_state_get_tx_iterator(
/// No required for parsing, but an example function for retrieving a
/// pointer to the request buffer from C for detection.
#[no_mangle]
pub extern "C" fn rs_template_get_request_buffer(
pub unsafe extern "C" fn rs_template_get_request_buffer(
tx: *mut std::os::raw::c_void,
buf: *mut *const u8,
len: *mut u32,
@ -482,10 +478,8 @@ pub extern "C" fn rs_template_get_request_buffer(
let tx = cast_pointer!(tx, TemplateTransaction);
if let Some(ref request) = tx.request {
if request.len() > 0 {
unsafe {
*len = request.len() as u32;
*buf = request.as_ptr();
}
*len = request.len() as u32;
*buf = request.as_ptr();
return 1;
}
}
@ -494,7 +488,7 @@ pub extern "C" fn rs_template_get_request_buffer(
/// Get the response buffer for a transaction from C.
#[no_mangle]
pub extern "C" fn rs_template_get_response_buffer(
pub unsafe extern "C" fn rs_template_get_response_buffer(
tx: *mut std::os::raw::c_void,
buf: *mut *const u8,
len: *mut u32,
@ -503,10 +497,8 @@ pub extern "C" fn rs_template_get_response_buffer(
let tx = cast_pointer!(tx, TemplateTransaction);
if let Some(ref response) = tx.response {
if response.len() > 0 {
unsafe {
*len = response.len() as u32;
*buf = response.as_ptr();
}
*len = response.len() as u32;
*buf = response.as_ptr();
return 1;
}
}

4
rust/src/asn1/mod.rs
Unescape Escape View File

@ -211,7 +211,7 @@ fn asn1_decode<'a>(
/// input must be a valid buffer of at least input_len bytes
/// pointer must be freed using `rs_asn1_free`
#[no_mangle]
pub extern "C" fn rs_asn1_decode(
pub unsafe extern "C" fn rs_asn1_decode(
input: *const u8, input_len: u16, buffer_offset: u32, ad_ptr: *const DetectAsn1Data,
) -> *mut Asn1<'static> {
if input.is_null() || input_len == 0 || ad_ptr.is_null() {
@ -220,7 +220,7 @@ pub extern "C" fn rs_asn1_decode(
let slice = build_slice!(input, input_len as usize);
let ad = unsafe { &*ad_ptr };
let ad = &*ad_ptr ;
let res = asn1_decode(slice, buffer_offset, ad);

32
rust/src/dcerpc/dcerpc.rs
Unescape Escape View File

@ -1143,7 +1143,7 @@ pub extern "C" fn rs_parse_dcerpc_response_gap(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_parse_request(
pub unsafe extern "C" fn rs_dcerpc_parse_request(
flow: *const core::Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, flags: u8,
) -> AppLayerResult {
@ -1166,7 +1166,7 @@ pub extern "C" fn rs_dcerpc_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_parse_response(
pub unsafe extern "C" fn rs_dcerpc_parse_response(
flow: *const core::Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, flags: u8,
) -> AppLayerResult {
@ -1201,14 +1201,14 @@ pub extern "C" fn rs_dcerpc_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_state_transaction_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_dcerpc_state_transaction_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let dce_state = cast_pointer!(state, DCERPCState);
SCLogDebug!("freeing tx {}", tx_id as u64);
dce_state.free_tx(tx_id);
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_state_trunc(state: *mut std::os::raw::c_void, direction: u8) {
pub unsafe extern "C" fn rs_dcerpc_state_trunc(state: *mut std::os::raw::c_void, direction: u8) {
let dce_state = cast_pointer!(state, DCERPCState);
if direction & core::STREAM_TOSERVER != 0 {
dce_state.ts_ssn_trunc = true;
@ -1232,7 +1232,7 @@ pub extern "C" fn rs_dcerpc_state_trunc(state: *mut std::os::raw::c_void, direct
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_get_tx_detect_state(
pub unsafe extern "C" fn rs_dcerpc_get_tx_detect_state(
vtx: *mut std::os::raw::c_void,
) -> *mut core::DetectEngineState {
let dce_tx = cast_pointer!(vtx, DCERPCTransaction);
@ -1243,7 +1243,7 @@ pub extern "C" fn rs_dcerpc_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_set_tx_detect_state(
pub unsafe extern "C" fn rs_dcerpc_set_tx_detect_state(
vtx: *mut std::os::raw::c_void, de_state: &mut core::DetectEngineState,
) -> std::os::raw::c_int {
let dce_tx = cast_pointer!(vtx, DCERPCTransaction);
@ -1252,7 +1252,7 @@ pub extern "C" fn rs_dcerpc_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_get_tx(
pub unsafe extern "C" fn rs_dcerpc_get_tx(
vtx: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let dce_state = cast_pointer!(vtx, DCERPCState);
@ -1263,13 +1263,13 @@ pub extern "C" fn rs_dcerpc_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_get_tx_cnt(vtx: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_dcerpc_get_tx_cnt(vtx: *mut std::os::raw::c_void) -> u64 {
let dce_state = cast_pointer!(vtx, DCERPCState);
dce_state.tx_id
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_get_alstate_progress(tx: *mut std::os::raw::c_void, direction: u8
pub unsafe extern "C" fn rs_dcerpc_get_alstate_progress(tx: *mut std::os::raw::c_void, direction: u8
)-> std::os::raw::c_int {
let tx = cast_pointer!(tx, DCERPCTransaction);
if direction == core::STREAM_TOSERVER && tx.req_done {
@ -1284,7 +1284,7 @@ pub extern "C" fn rs_dcerpc_get_alstate_progress(tx: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_get_tx_data(
pub unsafe extern "C" fn rs_dcerpc_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
{
@ -1326,16 +1326,14 @@ fn probe(input: &[u8]) -> (bool, bool) {
}
}
pub extern "C" fn rs_dcerpc_probe_tcp(_f: *const core::Flow, direction: u8, input: *const u8,
pub unsafe extern "C" fn rs_dcerpc_probe_tcp(_f: *const core::Flow, direction: u8, input: *const u8,
len: u32, rdir: *mut u8) -> AppProto
{
SCLogDebug!("Probing packet for DCERPC");
if len == 0 {
return core::ALPROTO_UNKNOWN;
}
let slice: &[u8] = unsafe {
std::slice::from_raw_parts(input as *mut u8, len as usize)
};
let slice: &[u8] = std::slice::from_raw_parts(input as *mut u8, len as usize);
//is_incomplete is checked by caller
let (is_dcerpc, is_request, ) = probe(slice);
if is_dcerpc {
@ -1345,11 +1343,11 @@ pub extern "C" fn rs_dcerpc_probe_tcp(_f: *const core::Flow, direction: u8, inpu
core::STREAM_TOCLIENT
};
if direction & (core::STREAM_TOSERVER|core::STREAM_TOCLIENT) != dir {
unsafe { *rdir = dir };
*rdir = dir;
}
return unsafe { ALPROTO_DCERPC };
return ALPROTO_DCERPC;
}
return unsafe { core::ALPROTO_FAILED };
return core::ALPROTO_FAILED;
}
fn register_pattern_probe() -> i8 {

26
rust/src/dcerpc/dcerpc_udp.rs
Unescape Escape View File

@ -205,7 +205,7 @@ impl DCERPCUDPState {
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_parse(
pub unsafe extern "C" fn rs_dcerpc_udp_parse(
_flow: *const core::Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
@ -230,7 +230,7 @@ pub extern "C" fn rs_dcerpc_udp_state_new(_orig_state: *mut std::os::raw::c_void
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_state_transaction_free(
pub unsafe extern "C" fn rs_dcerpc_udp_state_transaction_free(
state: *mut std::os::raw::c_void, tx_id: u64,
) {
let dce_state = cast_pointer!(state, DCERPCUDPState);
@ -239,7 +239,7 @@ pub extern "C" fn rs_dcerpc_udp_state_transaction_free(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_get_tx_detect_state(
pub unsafe extern "C" fn rs_dcerpc_udp_get_tx_detect_state(
vtx: *mut std::os::raw::c_void,
) -> *mut core::DetectEngineState {
let dce_state = cast_pointer!(vtx, DCERPCTransaction);
@ -250,7 +250,7 @@ pub extern "C" fn rs_dcerpc_udp_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_set_tx_detect_state(
pub unsafe extern "C" fn rs_dcerpc_udp_set_tx_detect_state(
vtx: *mut std::os::raw::c_void, de_state: &mut core::DetectEngineState,
) -> std::os::raw::c_int {
let dce_state = cast_pointer!(vtx, DCERPCTransaction);
@ -259,7 +259,7 @@ pub extern "C" fn rs_dcerpc_udp_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_get_tx_data(
pub unsafe extern "C" fn rs_dcerpc_udp_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
{
@ -268,7 +268,7 @@ pub extern "C" fn rs_dcerpc_udp_get_tx_data(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_get_tx(
pub unsafe extern "C" fn rs_dcerpc_udp_get_tx(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let dce_state = cast_pointer!(state, DCERPCUDPState);
@ -283,7 +283,7 @@ pub extern "C" fn rs_dcerpc_udp_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_dcerpc_udp_get_tx_cnt(vtx: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_dcerpc_udp_get_tx_cnt(vtx: *mut std::os::raw::c_void) -> u64 {
let dce_state = cast_pointer!(vtx, DCERPCUDPState);
dce_state.tx_id
}
@ -303,16 +303,14 @@ fn probe(input: &[u8]) -> (bool, bool) {
}
}
pub extern "C" fn rs_dcerpc_probe_udp(_f: *const core::Flow, direction: u8, input: *const u8,
pub unsafe extern "C" fn rs_dcerpc_probe_udp(_f: *const core::Flow, direction: u8, input: *const u8,
len: u32, rdir: *mut u8) -> core::AppProto
{
SCLogDebug!("Probing the packet for DCERPC/UDP");
if len == 0 {
return core::ALPROTO_UNKNOWN;
}
let slice: &[u8] = unsafe {
std::slice::from_raw_parts(input as *mut u8, len as usize)
};
let slice: &[u8] = std::slice::from_raw_parts(input as *mut u8, len as usize);
//is_incomplete is checked by caller
let (is_dcerpc, is_request) = probe(slice);
if is_dcerpc {
@ -322,11 +320,11 @@ pub extern "C" fn rs_dcerpc_probe_udp(_f: *const core::Flow, direction: u8, inpu
core::STREAM_TOCLIENT
};
if direction & (core::STREAM_TOSERVER|core::STREAM_TOCLIENT) != dir {
unsafe { *rdir = dir };
*rdir = dir;
}
return unsafe {ALPROTO_DCERPC};
return ALPROTO_DCERPC;
}
return unsafe { core::ALPROTO_FAILED };
return core::ALPROTO_FAILED;
}
fn register_pattern_probe() -> i8 {

38
rust/src/dhcp/dhcp.rs
Unescape Escape View File

@ -221,7 +221,7 @@ impl DHCPState {
}
#[no_mangle]
pub extern "C" fn rs_dhcp_probing_parser(_flow: *const Flow,
pub unsafe extern "C" fn rs_dhcp_probing_parser(_flow: *const Flow,
_direction: u8,
input: *const u8,
input_len: u32,
@ -234,7 +234,7 @@ pub extern "C" fn rs_dhcp_probing_parser(_flow: *const Flow,
let slice = build_slice!(input, input_len as usize);
match parse_header(slice) {
Ok((_, _)) => {
return unsafe { ALPROTO_DHCP };
return ALPROTO_DHCP;
}
_ => {
return ALPROTO_UNKNOWN;
@ -250,7 +250,7 @@ pub extern "C" fn rs_dhcp_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_get_tx(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_dhcp_state_get_tx(state: *mut std::os::raw::c_void,
tx_id: u64) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, DHCPState);
match state.get_tx(tx_id) {
@ -264,13 +264,13 @@ pub extern "C" fn rs_dhcp_state_get_tx(state: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_dhcp_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, DHCPState);
return state.tx_id;
}
#[no_mangle]
pub extern "C" fn rs_dhcp_parse(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_dhcp_parse(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -286,7 +286,7 @@ pub extern "C" fn rs_dhcp_parse(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_tx_free(
pub unsafe extern "C" fn rs_dhcp_state_tx_free(
state: *mut std::os::raw::c_void,
tx_id: u64)
{
@ -302,12 +302,12 @@ pub extern "C" fn rs_dhcp_state_new(_orig_state: *mut std::os::raw::c_void, _ori
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_free(state: *mut std::os::raw::c_void) {
std::mem::drop(unsafe { Box::from_raw(state as *mut DHCPState) });
pub unsafe extern "C" fn rs_dhcp_state_free(state: *mut std::os::raw::c_void) {
std::mem::drop(Box::from_raw(state as *mut DHCPState));
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_dhcp_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType)
-> i8
@ -317,17 +317,15 @@ pub extern "C" fn rs_dhcp_state_get_event_info_by_id(event_id: std::os::raw::c_i
DHCPEvent::TruncatedOptions => { "truncated_options\0" },
DHCPEvent::MalformedOptions => { "malformed_options\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
}
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_dhcp_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, DHCPTransaction);
@ -335,7 +333,7 @@ pub extern "C" fn rs_dhcp_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_get_event_info(
pub unsafe extern "C" fn rs_dhcp_state_get_event_info(
event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType)
@ -344,7 +342,7 @@ pub extern "C" fn rs_dhcp_state_get_event_info(
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -355,15 +353,13 @@ pub extern "C" fn rs_dhcp_state_get_event_info(
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe{
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
#[no_mangle]
pub extern "C" fn rs_dhcp_state_get_tx_iterator(
pub unsafe extern "C" fn rs_dhcp_state_get_tx_iterator(
_ipproto: u8,
_alproto: AppProto,
state: *mut std::os::raw::c_void,

8
rust/src/dhcp/logger.rs
Unescape Escape View File

@ -263,12 +263,12 @@ pub extern "C" fn rs_dhcp_logger_new(conf: *const c_void) -> *mut std::os::raw::
}
#[no_mangle]
pub extern "C" fn rs_dhcp_logger_free(logger: *mut std::os::raw::c_void) {
std::mem::drop(unsafe { Box::from_raw(logger as *mut DHCPLogger) });
pub unsafe extern "C" fn rs_dhcp_logger_free(logger: *mut std::os::raw::c_void) {
std::mem::drop(Box::from_raw(logger as *mut DHCPLogger));
}
#[no_mangle]
pub extern "C" fn rs_dhcp_logger_log(logger: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_dhcp_logger_log(logger: *mut std::os::raw::c_void,
tx: *mut std::os::raw::c_void,
js: &mut JsonBuilder) -> bool {
let logger = cast_pointer!(logger, DHCPLogger);
@ -277,7 +277,7 @@ pub extern "C" fn rs_dhcp_logger_log(logger: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_dhcp_logger_do_log(logger: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_dhcp_logger_do_log(logger: *mut std::os::raw::c_void,
tx: *mut std::os::raw::c_void)
-> bool {
let logger = cast_pointer!(logger, DHCPLogger);

88
rust/src/dns/dns.rs
Unescape Escape View File

@ -155,23 +155,21 @@ impl DNSEvent {
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_event_info_by_id(
pub unsafe extern "C" fn rs_dns_state_get_event_info_by_id(
event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType,
) -> i8 {
if let Some(e) = DNSEvent::from_id(event_id as u32) {
unsafe {
*event_name = e.to_cstring().as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
}
*event_name = e.to_cstring().as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
return 0;
}
return -1;
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_event_info(
pub unsafe extern "C" fn rs_dns_state_get_event_info(
event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType
@ -180,13 +178,11 @@ pub extern "C" fn rs_dns_state_get_event_info(
return -1;
}
let event_name = unsafe { std::ffi::CStr::from_ptr(event_name) };
let event_name = std::ffi::CStr::from_ptr(event_name);
if let Ok(event_name) = event_name.to_str() {
if let Some(event) = DNSEvent::from_string(event_name) {
unsafe {
*event_id = event as std::os::raw::c_int;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
}
*event_id = event as std::os::raw::c_int;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
} else {
// Unknown event...
return -1;
@ -739,7 +735,7 @@ pub extern "C" fn rs_dns_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_dns_state_tx_free(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_dns_state_tx_free(state: *mut std::os::raw::c_void,
tx_id: u64)
{
let state = cast_pointer!(state, DNSState);
@ -748,7 +744,7 @@ pub extern "C" fn rs_dns_state_tx_free(state: *mut std::os::raw::c_void,
/// C binding parse a DNS request. Returns 1 on success, -1 on failure.
#[no_mangle]
pub extern "C" fn rs_dns_parse_request(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_dns_parse_request(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -757,7 +753,7 @@ pub extern "C" fn rs_dns_parse_request(_flow: *const core::Flow,
_flags: u8)
-> AppLayerResult {
let state = cast_pointer!(state, DNSState);
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
if state.parse_request(buf) {
AppLayerResult::ok()
} else {
@ -766,7 +762,7 @@ pub extern "C" fn rs_dns_parse_request(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_dns_parse_response(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_dns_parse_response(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -775,7 +771,7 @@ pub extern "C" fn rs_dns_parse_response(_flow: *const core::Flow,
_flags: u8)
-> AppLayerResult {
let state = cast_pointer!(state, DNSState);
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
if state.parse_response(buf) {
AppLayerResult::ok()
} else {
@ -785,7 +781,7 @@ pub extern "C" fn rs_dns_parse_response(_flow: *const core::Flow,
/// C binding parse a DNS request. Returns 1 on success, -1 on failure.
#[no_mangle]
pub extern "C" fn rs_dns_parse_request_tcp(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_dns_parse_request_tcp(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -796,8 +792,7 @@ pub extern "C" fn rs_dns_parse_request_tcp(_flow: *const core::Flow,
let state = cast_pointer!(state, DNSState);
if input_len > 0 {
if input != std::ptr::null_mut() {
let buf = unsafe{
std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
return state.parse_request_tcp(buf);
}
state.request_gap(input_len);
@ -806,7 +801,7 @@ pub extern "C" fn rs_dns_parse_request_tcp(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_dns_parse_response_tcp(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_dns_parse_response_tcp(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -817,8 +812,7 @@ pub extern "C" fn rs_dns_parse_response_tcp(_flow: *const core::Flow,
let state = cast_pointer!(state, DNSState);
if input_len > 0 {
if input != std::ptr::null_mut() {
let buf = unsafe{
std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
return state.parse_response_tcp(buf);
}
state.response_gap(input_len);
@ -838,7 +832,7 @@ pub extern "C" fn rs_dns_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_tx_count(state: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_dns_state_get_tx_count(state: *mut std::os::raw::c_void)
-> u64
{
let state = cast_pointer!(state, DNSState);
@ -847,7 +841,7 @@ pub extern "C" fn rs_dns_state_get_tx_count(state: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_tx(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_dns_state_get_tx(state: *mut std::os::raw::c_void,
tx_id: u64)
-> *mut std::os::raw::c_void
{
@ -873,7 +867,7 @@ pub extern "C" fn rs_dns_tx_is_response(tx: &mut DNSTransaction) -> bool {
}
#[no_mangle]
pub extern "C" fn rs_dns_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_dns_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut core::DetectEngineState) -> std::os::raw::c_int
{
@ -883,7 +877,7 @@ pub extern "C" fn rs_dns_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_dns_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void)
-> *mut core::DetectEngineState
{
@ -899,7 +893,7 @@ pub extern "C" fn rs_dns_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_dns_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, DNSTransaction);
@ -907,7 +901,7 @@ pub extern "C" fn rs_dns_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_dns_state_get_tx_data(
pub unsafe extern "C" fn rs_dns_state_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
{
@ -916,7 +910,7 @@ pub extern "C" fn rs_dns_state_get_tx_data(
}
#[no_mangle]
pub extern "C" fn rs_dns_tx_get_query_name(tx: &mut DNSTransaction,
pub unsafe extern "C" fn rs_dns_tx_get_query_name(tx: &mut DNSTransaction,
i: u32,
buf: *mut *const u8,
len: *mut u32)
@ -926,10 +920,8 @@ pub extern "C" fn rs_dns_tx_get_query_name(tx: &mut DNSTransaction,
if (i as usize) < request.queries.len() {
let query = &request.queries[i as usize];
if query.name.len() > 0 {
unsafe {
*len = query.name.len() as u32;
*buf = query.name.as_ptr();
}
*len = query.name.len() as u32;
*buf = query.name.as_ptr();
return 1;
}
}
@ -957,7 +949,7 @@ pub extern "C" fn rs_dns_tx_get_response_flags(tx: &mut DNSTransaction)
}
#[no_mangle]
pub extern "C" fn rs_dns_tx_get_query_rrtype(tx: &mut DNSTransaction,
pub unsafe extern "C" fn rs_dns_tx_get_query_rrtype(tx: &mut DNSTransaction,
i: u16,
rrtype: *mut u16)
-> u8
@ -966,9 +958,7 @@ pub extern "C" fn rs_dns_tx_get_query_rrtype(tx: &mut DNSTransaction,
if (i as usize) < request.queries.len() {
let query = &request.queries[i as usize];
if query.name.len() > 0 {
unsafe {
*rrtype = query.rrtype;
}
*rrtype = query.rrtype;
return 1;
}
}
@ -977,7 +967,7 @@ pub extern "C" fn rs_dns_tx_get_query_rrtype(tx: &mut DNSTransaction,
}
#[no_mangle]
pub extern "C" fn rs_dns_probe(
pub unsafe extern "C" fn rs_dns_probe(
_flow: *const core::Flow,
_dir: u8,
input: *const u8,
@ -987,9 +977,7 @@ pub extern "C" fn rs_dns_probe(
if len == 0 || len < std::mem::size_of::<DNSHeader>() as u32 {
return core::ALPROTO_UNKNOWN;
}
let slice: &[u8] = unsafe {
std::slice::from_raw_parts(input as *mut u8, len as usize)
};
let slice: &[u8] = std::slice::from_raw_parts(input as *mut u8, len as usize);
let (is_dns, is_request, _) = probe(slice, slice.len());
if is_dns {
let dir = if is_request {
@ -997,16 +985,14 @@ pub extern "C" fn rs_dns_probe(
} else {
core::STREAM_TOCLIENT
};
unsafe {
*rdir = dir;
return ALPROTO_DNS;
}
*rdir = dir;
return ALPROTO_DNS;
}
return 0;
}
#[no_mangle]
pub extern "C" fn rs_dns_probe_tcp(
pub unsafe extern "C" fn rs_dns_probe_tcp(
_flow: *const core::Flow,
direction: u8,
input: *const u8,
@ -1016,9 +1002,7 @@ pub extern "C" fn rs_dns_probe_tcp(
if len == 0 || len < std::mem::size_of::<DNSHeader>() as u32 + 2 {
return core::ALPROTO_UNKNOWN;
}
let slice: &[u8] = unsafe {
std::slice::from_raw_parts(input as *mut u8, len as usize)
};
let slice: &[u8] = std::slice::from_raw_parts(input as *mut u8, len as usize);
//is_incomplete is checked by caller
let (is_dns, is_request, _) = probe_tcp(slice);
if is_dns {
@ -1028,15 +1012,15 @@ pub extern "C" fn rs_dns_probe_tcp(
core::STREAM_TOCLIENT
};
if direction & (core::STREAM_TOSERVER|core::STREAM_TOCLIENT) != dir {
unsafe { *rdir = dir };
*rdir = dir;
}
return unsafe { ALPROTO_DNS };
return ALPROTO_DNS;
}
return 0;
}
#[no_mangle]
pub extern "C" fn rs_dns_apply_tx_config(
pub unsafe extern "C" fn rs_dns_apply_tx_config(
_state: *mut std::os::raw::c_void, _tx: *mut std::os::raw::c_void,
_mode: std::os::raw::c_int, config: AppLayerTxConfig
) {

12
rust/src/ftp/mod.rs
Unescape Escape View File

@ -76,7 +76,7 @@ named!(pub ftp_pasv_response<u16>,
#[no_mangle]
pub extern "C" fn rs_ftp_active_port(input: *const u8, len: u32) -> u16 {
pub unsafe extern "C" fn rs_ftp_active_port(input: *const u8, len: u32) -> u16 {
let buf = build_slice!(input, len as usize);
match ftp_active_port(buf) {
Ok((_, dport)) => {
@ -94,8 +94,8 @@ pub extern "C" fn rs_ftp_active_port(input: *const u8, len: u32) -> u16 {
#[no_mangle]
pub extern "C" fn rs_ftp_pasv_response(input: *const u8, len: u32) -> u16 {
let buf = unsafe{std::slice::from_raw_parts(input, len as usize)};
pub unsafe extern "C" fn rs_ftp_pasv_response(input: *const u8, len: u32) -> u16 {
let buf = std::slice::from_raw_parts(input, len as usize);
match ftp_pasv_response(buf) {
Ok((_, dport)) => {
return dport;
@ -140,7 +140,7 @@ named!(pub ftp_active_eprt<u16>,
);
#[no_mangle]
pub extern "C" fn rs_ftp_active_eprt(input: *const u8, len: u32) -> u16 {
pub unsafe extern "C" fn rs_ftp_active_eprt(input: *const u8, len: u32) -> u16 {
let buf = build_slice!(input, len as usize);
match ftp_active_eprt(buf) {
Ok((_, dport)) => {
@ -157,8 +157,8 @@ pub extern "C" fn rs_ftp_active_eprt(input: *const u8, len: u32) -> u16 {
return 0;
}
#[no_mangle]
pub extern "C" fn rs_ftp_epsv_response(input: *const u8, len: u32) -> u16 {
let buf = unsafe{std::slice::from_raw_parts(input, len as usize)};
pub unsafe extern "C" fn rs_ftp_epsv_response(input: *const u8, len: u32) -> u16 {
let buf = std::slice::from_raw_parts(input, len as usize);
match ftp_epsv_response(buf) {
Ok((_, dport)) => {
return dport;

18
rust/src/http2/detect.rs
Unescape Escape View File

@ -43,7 +43,7 @@ fn http2_tx_has_frametype(
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_has_frametype(
pub unsafe extern "C" fn rs_http2_tx_has_frametype(
tx: *mut std::os::raw::c_void, direction: u8, value: u8,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, HTTP2Transaction);
@ -103,7 +103,7 @@ fn http2_tx_has_errorcode(
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_has_errorcode(
pub unsafe extern "C" fn rs_http2_tx_has_errorcode(
tx: *mut std::os::raw::c_void, direction: u8, code: u32,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, HTTP2Transaction);
@ -176,7 +176,7 @@ fn http2_tx_get_next_priority(
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_get_next_priority(
pub unsafe extern "C" fn rs_http2_tx_get_next_priority(
tx: *mut std::os::raw::c_void, direction: u8, nb: u32,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, HTTP2Transaction);
@ -218,7 +218,7 @@ fn http2_tx_get_next_window(
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_get_next_window(
pub unsafe extern "C" fn rs_http2_tx_get_next_window(
tx: *mut std::os::raw::c_void, direction: u8, nb: u32,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, HTTP2Transaction);
@ -312,7 +312,7 @@ fn http2_detect_settingsctx_match(
}
#[no_mangle]
pub extern "C" fn rs_http2_detect_settingsctx_match(
pub unsafe extern "C" fn rs_http2_detect_settingsctx_match(
ctx: *const std::os::raw::c_void, tx: *mut std::os::raw::c_void, direction: u8,
) -> std::os::raw::c_int {
let ctx = cast_pointer!(ctx, parser::DetectHTTP2settingsSigCtx);
@ -413,7 +413,7 @@ fn http2_detect_sizeupdatectx_match(
}
#[no_mangle]
pub extern "C" fn rs_http2_detect_sizeupdatectx_match(
pub unsafe extern "C" fn rs_http2_detect_sizeupdatectx_match(
ctx: *const std::os::raw::c_void, tx: *mut std::os::raw::c_void, direction: u8,
) -> std::os::raw::c_int {
let ctx = cast_pointer!(ctx, parser::DetectU64Data);
@ -704,7 +704,7 @@ fn http2_tx_set_header(state: &mut HTTP2State, name: &[u8], input: &[u8]) {
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_set_method(
pub unsafe extern "C" fn rs_http2_tx_set_method(
state: &mut HTTP2State, buffer: *const u8, buffer_len: u32,
) {
let slice = build_slice!(buffer, buffer_len as usize);
@ -712,7 +712,7 @@ pub extern "C" fn rs_http2_tx_set_method(
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_set_uri(state: &mut HTTP2State, buffer: *const u8, buffer_len: u32) {
pub unsafe extern "C" fn rs_http2_tx_set_uri(state: &mut HTTP2State, buffer: *const u8, buffer_len: u32) {
let slice = build_slice!(buffer, buffer_len as usize);
http2_tx_set_header(state, ":path".as_bytes(), slice)
}
@ -853,7 +853,7 @@ fn http2_tx_set_settings(state: &mut HTTP2State, input: &[u8]) {
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_add_header(
pub unsafe extern "C" fn rs_http2_tx_add_header(
state: &mut HTTP2State, name: *const u8, name_len: u32, value: *const u8, value_len: u32,
) {
let slice_name = build_slice!(name, name_len as usize);

57
rust/src/http2/http2.rs
Unescape Escape View File

@ -963,7 +963,7 @@ export_tx_data_get!(rs_http2_get_tx_data, HTTP2Transaction);
/// C entry point for a probing parser.
#[no_mangle]
pub extern "C" fn rs_http2_probing_parser_tc(
pub unsafe extern "C" fn rs_http2_probing_parser_tc(
_flow: *const Flow, _direction: u8, input: *const u8, input_len: u32, _rdir: *mut u8,
) -> AppProto {
if input != std::ptr::null_mut() {
@ -975,15 +975,15 @@ pub extern "C" fn rs_http2_probing_parser_tc(
|| header.flags & 0xFE != 0
|| header.ftype != parser::HTTP2FrameType::SETTINGS as u8
{
return unsafe { ALPROTO_FAILED };
return ALPROTO_FAILED;
}
return unsafe { ALPROTO_HTTP2 };
return ALPROTO_HTTP2;
}
Err(nom::Err::Incomplete(_)) => {
return ALPROTO_UNKNOWN;
}
Err(_) => {
return unsafe { ALPROTO_FAILED };
return ALPROTO_FAILED ;
}
}
}
@ -997,7 +997,10 @@ extern "C" {
);
}
// Suppress the unsafe warning here as creating a state for an app-layer
// is typically not unsafe.
#[no_mangle]
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn rs_http2_state_new(
orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto,
) -> *mut std::os::raw::c_void {
@ -1014,44 +1017,44 @@ pub extern "C" fn rs_http2_state_new(
}
#[no_mangle]
pub extern "C" fn rs_http2_state_free(state: *mut std::os::raw::c_void) {
let mut state: Box<HTTP2State> = unsafe { Box::from_raw(state as _) };
pub unsafe extern "C" fn rs_http2_state_free(state: *mut std::os::raw::c_void) {
let mut state: Box<HTTP2State> = Box::from_raw(state as _);
state.free();
}
#[no_mangle]
pub extern "C" fn rs_http2_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_http2_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, HTTP2State);
state.free_tx(tx_id);
}
#[no_mangle]
pub extern "C" fn rs_http2_parse_ts(
pub unsafe extern "C" fn rs_http2_parse_ts(
flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
let state = cast_pointer!(state, HTTP2State);
let buf = build_slice!(input, input_len as usize);
state.files.flags_ts = unsafe { FileFlowToFlags(flow, STREAM_TOSERVER) };
state.files.flags_ts = FileFlowToFlags(flow, STREAM_TOSERVER);
state.files.flags_ts = state.files.flags_ts | FILE_USE_DETECT;
return state.parse_ts(buf);
}
#[no_mangle]
pub extern "C" fn rs_http2_parse_tc(
pub unsafe extern "C" fn rs_http2_parse_tc(
flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
let state = cast_pointer!(state, HTTP2State);
let buf = build_slice!(input, input_len as usize);
state.files.flags_tc = unsafe { FileFlowToFlags(flow, STREAM_TOCLIENT) };
state.files.flags_tc = FileFlowToFlags(flow, STREAM_TOCLIENT);
state.files.flags_tc = state.files.flags_tc | FILE_USE_DETECT;
return state.parse_tc(buf);
}
#[no_mangle]
pub extern "C" fn rs_http2_state_get_tx(
pub unsafe extern "C" fn rs_http2_state_get_tx(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, HTTP2State);
@ -1066,26 +1069,26 @@ pub extern "C" fn rs_http2_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_http2_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_http2_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, HTTP2State);
return state.tx_id;
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_get_state(tx: *mut std::os::raw::c_void) -> HTTP2TransactionState {
pub unsafe extern "C" fn rs_http2_tx_get_state(tx: *mut std::os::raw::c_void) -> HTTP2TransactionState {
let tx = cast_pointer!(tx, HTTP2Transaction);
return tx.state;
}
#[no_mangle]
pub extern "C" fn rs_http2_tx_get_alstate_progress(
pub unsafe extern "C" fn rs_http2_tx_get_alstate_progress(
tx: *mut std::os::raw::c_void, _direction: u8,
) -> std::os::raw::c_int {
return rs_http2_tx_get_state(tx) as i32;
}
#[no_mangle]
pub extern "C" fn rs_http2_state_get_events(
pub unsafe extern "C" fn rs_http2_state_get_events(
tx: *mut std::os::raw::c_void,
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, HTTP2Transaction);
@ -1093,14 +1096,14 @@ pub extern "C" fn rs_http2_state_get_events(
}
#[no_mangle]
pub extern "C" fn rs_http2_state_get_event_info(
pub unsafe extern "C" fn rs_http2_state_get_event_info(
event_name: *const std::os::raw::c_char, event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType,
) -> std::os::raw::c_int {
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -1119,15 +1122,13 @@ pub extern "C" fn rs_http2_state_get_event_info(
}
Err(_) => -1, // UTF-8 conversion failed
};
unsafe {
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
#[no_mangle]
pub extern "C" fn rs_http2_state_get_event_info_by_id(
pub unsafe extern "C" fn rs_http2_state_get_event_info_by_id(
event_id: std::os::raw::c_int, event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType,
) -> i8 {
@ -1144,17 +1145,15 @@ pub extern "C" fn rs_http2_state_get_event_info_by_id(
HTTP2Event::InvalidHTTP1Settings => "invalid_http1_settings\0",
HTTP2Event::FailedDecompression => "failed_decompression\0",
};
unsafe {
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
}
}
#[no_mangle]
pub extern "C" fn rs_http2_state_get_tx_iterator(
pub unsafe extern "C" fn rs_http2_state_get_tx_iterator(
_ipproto: u8, _alproto: AppProto, state: *mut std::os::raw::c_void, min_tx_id: u64,
_max_tx_id: u64, istate: &mut u64,
) -> applayer::AppLayerGetTxIterTuple {
@ -1172,7 +1171,7 @@ pub extern "C" fn rs_http2_state_get_tx_iterator(
}
#[no_mangle]
pub extern "C" fn rs_http2_getfiles(
pub unsafe extern "C" fn rs_http2_getfiles(
state: *mut std::os::raw::c_void, direction: u8,
) -> *mut FileContainer {
let state = cast_pointer!(state, HTTP2State);

2
rust/src/http2/logger.rs
Unescape Escape View File

@ -268,7 +268,7 @@ fn log_http2(tx: &HTTP2Transaction, js: &mut JsonBuilder) -> Result<bool, JsonEr
}
#[no_mangle]
pub extern "C" fn rs_http2_log_json(tx: *mut std::os::raw::c_void, js: &mut JsonBuilder) -> bool {
pub unsafe extern "C" fn rs_http2_log_json(tx: *mut std::os::raw::c_void, js: &mut JsonBuilder) -> bool {
let tx = cast_pointer!(tx, HTTP2Transaction);
if let Ok(x) = log_http2(tx, js) {
return x;

48
rust/src/ike/ike.rs
Unescape Escape View File

@ -322,21 +322,21 @@ export_tx_set_detect_state!(rs_ike_tx_set_detect_state, IKETransaction);
/// C entry point for a probing parser.
#[no_mangle]
pub extern "C" fn rs_ike_probing_parser(
pub unsafe extern "C" fn rs_ike_probing_parser(
_flow: *const Flow, direction: u8, input: *const u8, input_len: u32, rdir: *mut u8,
) -> AppProto {
if input_len < 28 {
// at least the ISAKMP_HEADER must be there, not ALPROTO_UNKNOWN because over UDP
return unsafe { ALPROTO_FAILED };
return ALPROTO_FAILED;
}
if input != std::ptr::null_mut() {
let slice = build_slice!(input, input_len as usize);
if probe(slice, direction, rdir) {
return unsafe { ALPROTO_IKE };
return ALPROTO_IKE ;
}
}
return unsafe { ALPROTO_FAILED };
return ALPROTO_FAILED;
}
#[no_mangle]
@ -349,19 +349,19 @@ pub extern "C" fn rs_ike_state_new(
}
#[no_mangle]
pub extern "C" fn rs_ike_state_free(state: *mut std::os::raw::c_void) {
pub unsafe extern "C" fn rs_ike_state_free(state: *mut std::os::raw::c_void) {
// Just unbox...
std::mem::drop(unsafe { Box::from_raw(state as *mut IKEState) });
std::mem::drop(Box::from_raw(state as *mut IKEState));
}
#[no_mangle]
pub extern "C" fn rs_ike_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_ike_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, IKEState);
state.free_tx(tx_id);
}
#[no_mangle]
pub extern "C" fn rs_ike_parse_request(
pub unsafe extern "C" fn rs_ike_parse_request(
_flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
@ -372,7 +372,7 @@ pub extern "C" fn rs_ike_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_ike_parse_response(
pub unsafe extern "C" fn rs_ike_parse_response(
_flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
@ -382,7 +382,7 @@ pub extern "C" fn rs_ike_parse_response(
}
#[no_mangle]
pub extern "C" fn rs_ike_state_get_tx(
pub unsafe extern "C" fn rs_ike_state_get_tx(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, IKEState);
@ -397,7 +397,7 @@ pub extern "C" fn rs_ike_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_ike_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_ike_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, IKEState);
return state.tx_id;
}
@ -416,7 +416,7 @@ pub extern "C" fn rs_ike_tx_get_alstate_progress(
}
#[no_mangle]
pub extern "C" fn rs_ike_tx_get_logged(
pub unsafe extern "C" fn rs_ike_tx_get_logged(
_state: *mut std::os::raw::c_void, tx: *mut std::os::raw::c_void,
) -> u32 {
let tx = cast_pointer!(tx, IKETransaction);
@ -424,7 +424,7 @@ pub extern "C" fn rs_ike_tx_get_logged(
}
#[no_mangle]
pub extern "C" fn rs_ike_tx_set_logged(
pub unsafe extern "C" fn rs_ike_tx_set_logged(
_state: *mut std::os::raw::c_void, tx: *mut std::os::raw::c_void, logged: u32,
) {
let tx = cast_pointer!(tx, IKETransaction);
@ -432,7 +432,7 @@ pub extern "C" fn rs_ike_tx_set_logged(
}
#[no_mangle]
pub extern "C" fn rs_ike_state_get_events(
pub unsafe extern "C" fn rs_ike_state_get_events(
tx: *mut std::os::raw::c_void,
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, IKETransaction);
@ -440,7 +440,7 @@ pub extern "C" fn rs_ike_state_get_events(
}
#[no_mangle]
pub extern "C" fn rs_ike_state_get_event_info_by_id(
pub unsafe extern "C" fn rs_ike_state_get_event_info_by_id(
event_id: std::os::raw::c_int, event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType,
) -> i8 {
@ -459,10 +459,8 @@ pub extern "C" fn rs_ike_state_get_event_info_by_id(
IkeEvent::PayloadExtraData => "payload_extra_data\0",
IkeEvent::MultipleServerProposal => "multiple_server_proposal\0",
};
unsafe {
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -470,14 +468,14 @@ pub extern "C" fn rs_ike_state_get_event_info_by_id(
}
#[no_mangle]
pub extern "C" fn rs_ike_state_get_event_info(
pub unsafe extern "C" fn rs_ike_state_get_event_info(
event_name: *const std::os::raw::c_char, event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType,
) -> std::os::raw::c_int {
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -498,17 +496,15 @@ pub extern "C" fn rs_ike_state_get_event_info(
}
Err(_) => -1, // UTF-8 conversion failed
};
unsafe {
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
static mut ALPROTO_IKE : AppProto = ALPROTO_UNKNOWN;
#[no_mangle]
pub extern "C" fn rs_ike_state_get_tx_iterator(
pub unsafe extern "C" fn rs_ike_state_get_tx_iterator(
_ipproto: u8, _alproto: AppProto, state: *mut std::os::raw::c_void, min_tx_id: u64,
_max_tx_id: u64, istate: &mut u64,
) -> applayer::AppLayerGetTxIterTuple {

2
rust/src/ike/logger.rs
Unescape Escape View File

@ -224,7 +224,7 @@ fn log_ikev2(tx: &IKETransaction, jb: &mut JsonBuilder) -> Result<(), JsonError>
}
#[no_mangle]
pub extern "C" fn rs_ike_logger_log(
pub unsafe extern "C" fn rs_ike_logger_log(
state: &mut IKEState, tx: *mut std::os::raw::c_void, flags: u32, js: &mut JsonBuilder,
) -> bool {
let tx = cast_pointer!(tx, IKETransaction);

62
rust/src/krb/krb5.rs
Unescape Escape View File

@ -288,7 +288,7 @@ pub extern "C" fn rs_krb5_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_get_tx(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_krb5_state_get_tx(state: *mut std::os::raw::c_void,
tx_id: u64)
-> *mut std::os::raw::c_void
{
@ -300,7 +300,7 @@ pub extern "C" fn rs_krb5_state_get_tx(state: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_get_tx_count(state: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_krb5_state_get_tx_count(state: *mut std::os::raw::c_void)
-> u64
{
let state = cast_pointer!(state,KRB5State);
@ -308,7 +308,7 @@ pub extern "C" fn rs_krb5_state_get_tx_count(state: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_tx_free(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_krb5_state_tx_free(state: *mut std::os::raw::c_void,
tx_id: u64)
{
let state = cast_pointer!(state,KRB5State);
@ -324,7 +324,7 @@ pub extern "C" fn rs_krb5_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_krb5_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut core::DetectEngineState) -> std::os::raw::c_int
{
@ -334,7 +334,7 @@ pub extern "C" fn rs_krb5_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_krb5_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void)
-> *mut core::DetectEngineState
{
@ -346,7 +346,7 @@ pub extern "C" fn rs_krb5_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_krb5_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType)
-> i8
@ -356,10 +356,8 @@ pub extern "C" fn rs_krb5_state_get_event_info_by_id(event_id: std::os::raw::c_i
KRB5Event::MalformedData => { "malformed_data\0" },
KRB5Event::WeakEncryption => { "weak_encryption\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -367,7 +365,7 @@ pub extern "C" fn rs_krb5_state_get_event_info_by_id(event_id: std::os::raw::c_i
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_krb5_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, KRB5Transaction);
@ -375,13 +373,13 @@ pub extern "C" fn rs_krb5_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_krb5_state_get_event_info(event_name: *const std::os::raw::c_char,
pub unsafe extern "C" fn rs_krb5_state_get_event_info(event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType)
-> std::os::raw::c_int
{
if event_name == std::ptr::null() { return -1; }
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -392,31 +390,29 @@ pub extern "C" fn rs_krb5_state_get_event_info(event_name: *const std::os::raw::
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe{
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
static mut ALPROTO_KRB5 : AppProto = ALPROTO_UNKNOWN;
#[no_mangle]
pub extern "C" fn rs_krb5_probing_parser(_flow: *const Flow,
pub unsafe extern "C" fn rs_krb5_probing_parser(_flow: *const Flow,
_direction: u8,
input:*const u8, input_len: u32,
_rdir: *mut u8) -> AppProto
{
let slice = build_slice!(input,input_len as usize);
let alproto = unsafe{ ALPROTO_KRB5 };
if slice.len() <= 10 { return unsafe{ALPROTO_FAILED}; }
let alproto = ALPROTO_KRB5;
if slice.len() <= 10 { return ALPROTO_FAILED; }
match der_read_element_header(slice) {
Ok((rem, ref hdr)) => {
// Kerberos messages start with an APPLICATION header
if hdr.class != BerClass::Application { return unsafe{ALPROTO_FAILED}; }
if hdr.class != BerClass::Application { return ALPROTO_FAILED; }
// Tag number should be <= 30
if hdr.tag.0 > 30 { return unsafe{ALPROTO_FAILED}; }
if hdr.tag.0 > 30 { return ALPROTO_FAILED; }
// Kerberos messages contain sequences
if rem.is_empty() || rem[0] != 0x30 { return unsafe{ALPROTO_FAILED}; }
if rem.is_empty() || rem[0] != 0x30 { return ALPROTO_FAILED; }
// Check kerberos version
if let Ok((rem,_hdr)) = der_read_element_header(rem) {
if rem.len() > 5 {
@ -427,29 +423,29 @@ pub extern "C" fn rs_krb5_probing_parser(_flow: *const Flow,
}
}
}
return unsafe{ALPROTO_FAILED};
return ALPROTO_FAILED;
},
Err(nom::Err::Incomplete(_)) => {
return ALPROTO_UNKNOWN;
},
Err(_) => {
return unsafe{ALPROTO_FAILED};
return ALPROTO_FAILED;
},
}
}
#[no_mangle]
pub extern "C" fn rs_krb5_probing_parser_tcp(_flow: *const Flow,
pub unsafe extern "C" fn rs_krb5_probing_parser_tcp(_flow: *const Flow,
direction: u8,
input:*const u8, input_len: u32,
rdir: *mut u8) -> AppProto
{
let slice = build_slice!(input,input_len as usize);
if slice.len() <= 14 { return unsafe{ALPROTO_FAILED}; }
if slice.len() <= 14 { return ALPROTO_FAILED; }
match be_u32(slice) as IResult<&[u8],u32> {
Ok((rem, record_mark)) => {
// protocol implementations forbid very large requests
if record_mark > 16384 { return unsafe{ALPROTO_FAILED}; }
if record_mark > 16384 { return ALPROTO_FAILED; }
return rs_krb5_probing_parser(_flow, direction,
rem.as_ptr(), rem.len() as u32, rdir);
},
@ -457,13 +453,13 @@ pub extern "C" fn rs_krb5_probing_parser_tcp(_flow: *const Flow,
return ALPROTO_UNKNOWN;
},
Err(_) => {
return unsafe{ALPROTO_FAILED};
return ALPROTO_FAILED;
},
}
}
#[no_mangle]
pub extern "C" fn rs_krb5_parse_request(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_krb5_parse_request(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -479,7 +475,7 @@ pub extern "C" fn rs_krb5_parse_request(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_krb5_parse_response(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_krb5_parse_response(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -495,7 +491,7 @@ pub extern "C" fn rs_krb5_parse_response(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_krb5_parse_request_tcp(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_krb5_parse_request_tcp(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -554,7 +550,7 @@ pub extern "C" fn rs_krb5_parse_request_tcp(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_krb5_parse_response_tcp(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_krb5_parse_response_tcp(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,

54
rust/src/modbus/modbus.rs
Unescape Escape View File

@ -349,18 +349,18 @@ pub extern "C" fn rs_modbus_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_modbus_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, ModbusState);
state.free_tx(tx_id);
}
#[no_mangle]
pub extern "C" fn rs_modbus_parse_request(
pub unsafe extern "C" fn rs_modbus_parse_request(
_flow: *const core::Flow, state: *mut std::os::raw::c_void, pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
if input_len == 0 {
if unsafe { AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS) } > 0 {
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS) > 0 {
return AppLayerResult::ok();
} else {
return AppLayerResult::err();
@ -368,40 +368,38 @@ pub extern "C" fn rs_modbus_parse_request(
}
let state = cast_pointer!(state, ModbusState);
let buf = unsafe { std::slice::from_raw_parts(input, input_len as usize) };
let buf = std::slice::from_raw_parts(input, input_len as usize);
state.parse(buf, Direction::ToServer)
}
#[no_mangle]
pub extern "C" fn rs_modbus_parse_response(
pub unsafe extern "C" fn rs_modbus_parse_response(
_flow: *const core::Flow, state: *mut std::os::raw::c_void, pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
if input_len == 0 {
unsafe {
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC) > 0 {
return AppLayerResult::ok();
} else {
return AppLayerResult::err();
}
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC) > 0 {
return AppLayerResult::ok();
} else {
return AppLayerResult::err();
}
}
let state = cast_pointer!(state, ModbusState);
let buf = unsafe { std::slice::from_raw_parts(input, input_len as usize) };
let buf = std::slice::from_raw_parts(input, input_len as usize);
state.parse(buf, Direction::ToClient)
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_modbus_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, ModbusState);
state.tx_id
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_tx(
pub unsafe extern "C" fn rs_modbus_state_get_tx(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, ModbusState);
@ -412,7 +410,7 @@ pub extern "C" fn rs_modbus_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_modbus_tx_get_alstate_progress(
pub unsafe extern "C" fn rs_modbus_tx_get_alstate_progress(
tx: *mut std::os::raw::c_void, _direction: u8,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, ModbusTransaction);
@ -420,7 +418,7 @@ pub extern "C" fn rs_modbus_tx_get_alstate_progress(
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_events(
pub unsafe extern "C" fn rs_modbus_state_get_events(
tx: *mut std::os::raw::c_void,
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, ModbusTransaction);
@ -428,7 +426,7 @@ pub extern "C" fn rs_modbus_state_get_events(
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_event_info(
pub unsafe extern "C" fn rs_modbus_state_get_event_info(
event_name: *const std::os::raw::c_char, event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType,
) -> std::os::raw::c_int {
@ -436,10 +434,10 @@ pub extern "C" fn rs_modbus_state_get_event_info(
return -1;
}
let event_name = unsafe { std::ffi::CStr::from_ptr(event_name) };
let event_name = std::ffi::CStr::from_ptr(event_name);
if let Ok(event_name) = event_name.to_str() {
match ModbusEvent::from_str(event_name) {
Ok(event) => unsafe {
Ok(event) => {
*event_id = event as std::os::raw::c_int;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
@ -458,15 +456,13 @@ pub extern "C" fn rs_modbus_state_get_event_info(
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_event_info_by_id(
pub unsafe extern "C" fn rs_modbus_state_get_event_info_by_id(
event_id: std::os::raw::c_int, event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType,
) -> i8 {
if let Some(e) = ModbusEvent::from_id(event_id as u32) {
unsafe {
*event_name = e.to_str().as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
}
*event_name = e.to_str().as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
SCLogError!("event {} not present in modbus's enum map table.", event_id);
@ -475,7 +471,7 @@ pub extern "C" fn rs_modbus_state_get_event_info_by_id(
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_modbus_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void,
) -> *mut core::DetectEngineState {
let tx = cast_pointer!(tx, ModbusTransaction);
@ -486,7 +482,7 @@ pub extern "C" fn rs_modbus_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_modbus_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void, de_state: &mut core::DetectEngineState,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, ModbusTransaction);
@ -495,7 +491,7 @@ pub extern "C" fn rs_modbus_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_tx_data(
pub unsafe extern "C" fn rs_modbus_state_get_tx_data(
tx: *mut std::os::raw::c_void,
) -> *mut AppLayerTxData {
let tx = cast_pointer!(tx, ModbusTransaction);
@ -841,7 +837,7 @@ pub mod test {
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_tx_request(
pub unsafe extern "C" fn rs_modbus_state_get_tx_request(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> ModbusMessage {
let state = cast_pointer!(state, ModbusState);
@ -857,7 +853,7 @@ pub mod test {
}
#[no_mangle]
pub extern "C" fn rs_modbus_state_get_tx_response(
pub unsafe extern "C" fn rs_modbus_state_get_tx_response(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> ModbusMessage {
let state = cast_pointer!(state, ModbusState);

198
rust/src/mqtt/detect.rs
Unescape Escape View File

@ -67,15 +67,13 @@ pub extern "C" fn rs_mqtt_tx_has_type(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_cstr_message_code(
pub unsafe extern "C" fn rs_mqtt_cstr_message_code(
str: *const std::os::raw::c_char,
) -> std::os::raw::c_int {
unsafe {
let msgtype: &CStr = CStr::from_ptr(str);
if let Ok(s) = msgtype.to_str() {
if let Ok(x) = MQTTTypeCode::from_str(s) {
return x as i32;
}
let msgtype: &CStr = CStr::from_ptr(str);
if let Ok(s) = msgtype.to_str() {
if let Ok(x) = MQTTTypeCode::from_str(s) {
return x as i32;
}
}
return -1;
@ -145,7 +143,7 @@ pub extern "C" fn rs_mqtt_tx_has_connect_flags(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_connect_clientid(
pub unsafe extern "C" fn rs_mqtt_tx_get_connect_clientid(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -154,24 +152,20 @@ pub extern "C" fn rs_mqtt_tx_get_connect_clientid(
if let MQTTOperation::CONNECT(ref cv) = msg.op {
let p = &cv.client_id;
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_connect_username(
pub unsafe extern "C" fn rs_mqtt_tx_get_connect_username(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -180,26 +174,22 @@ pub extern "C" fn rs_mqtt_tx_get_connect_username(
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.username {
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_connect_password(
pub unsafe extern "C" fn rs_mqtt_tx_get_connect_password(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -208,25 +198,21 @@ pub extern "C" fn rs_mqtt_tx_get_connect_password(
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.password {
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_connect_willtopic(
pub unsafe extern "C" fn rs_mqtt_tx_get_connect_willtopic(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -235,26 +221,22 @@ pub extern "C" fn rs_mqtt_tx_get_connect_willtopic(
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.will_topic {
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_connect_willmessage(
pub unsafe extern "C" fn rs_mqtt_tx_get_connect_willmessage(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -263,34 +245,28 @@ pub extern "C" fn rs_mqtt_tx_get_connect_willmessage(
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.will_message {
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_connack_sessionpresent(
pub unsafe extern "C" fn rs_mqtt_tx_get_connack_sessionpresent(
tx: &MQTTTransaction,
session_present: *mut bool,
) -> u8 {
for msg in tx.msg.iter() {
if let MQTTOperation::CONNACK(ref ca) = msg.op {
unsafe {
*session_present = ca.session_present;
}
*session_present = ca.session_present;
return 1;
}
}
@ -298,7 +274,7 @@ pub extern "C" fn rs_mqtt_tx_get_connack_sessionpresent(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_publish_topic(
pub unsafe extern "C" fn rs_mqtt_tx_get_publish_topic(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -307,25 +283,21 @@ pub extern "C" fn rs_mqtt_tx_get_publish_topic(
if let MQTTOperation::PUBLISH(ref pubv) = msg.op {
let p = &pubv.topic;
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_publish_message(
pub unsafe extern "C" fn rs_mqtt_tx_get_publish_message(
tx: &MQTTTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -334,25 +306,21 @@ pub extern "C" fn rs_mqtt_tx_get_publish_message(
if let MQTTOperation::PUBLISH(ref pubv) = msg.op {
let p = &pubv.message;
if p.len() > 0 {
unsafe {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
}
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
}
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_subscribe_topic(tx: &MQTTTransaction,
pub unsafe extern "C" fn rs_mqtt_tx_get_subscribe_topic(tx: &MQTTTransaction,
i: u32,
buf: *mut *const u8,
len: *mut u32)
@ -364,10 +332,8 @@ pub extern "C" fn rs_mqtt_tx_get_subscribe_topic(tx: &MQTTTransaction,
if (i as usize) < subv.topics.len() + offset {
let topic = &subv.topics[(i as usize) - offset];
if topic.topic_name.len() > 0 {
unsafe {
*len = topic.topic_name.len() as u32;
*buf = topic.topic_name.as_ptr();
}
*len = topic.topic_name.len() as u32;
*buf = topic.topic_name.as_ptr();
return 1;
}
} else {
@ -376,16 +342,14 @@ pub extern "C" fn rs_mqtt_tx_get_subscribe_topic(tx: &MQTTTransaction,
}
}
unsafe {
*buf = ptr::null();
*len = 0;
}
*buf = ptr::null();
*len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_unsubscribe_topic(tx: &MQTTTransaction,
pub unsafe extern "C" fn rs_mqtt_tx_get_unsubscribe_topic(tx: &MQTTTransaction,
i: u32,
buf: *mut *const u8,
len: *mut u32)
@ -397,10 +361,8 @@ pub extern "C" fn rs_mqtt_tx_get_unsubscribe_topic(tx: &MQTTTransaction,
if (i as usize) < unsubv.topics.len() + offset {
let topic = &unsubv.topics[(i as usize) - offset];
if topic.len() > 0 {
unsafe {
*len = topic.len() as u32;
*buf = topic.as_ptr();
}
*len = topic.len() as u32;
*buf = topic.as_ptr();
return 1;
}
} else {
@ -409,16 +371,14 @@ pub extern "C" fn rs_mqtt_tx_get_unsubscribe_topic(tx: &MQTTTransaction,
}
}
unsafe {
*buf = ptr::null();
*len = 0;
}
*buf = ptr::null();
*len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_reason_code(
pub unsafe extern "C" fn rs_mqtt_tx_get_reason_code(
tx: &MQTTTransaction,
result: *mut u8,
) -> u8 {
@ -429,29 +389,21 @@ pub extern "C" fn rs_mqtt_tx_get_reason_code(
| MQTTOperation::PUBREC(ref v)
| MQTTOperation::PUBCOMP(ref v) => {
if let Some(rcode) = v.reason_code {
unsafe {
*result = rcode;
}
*result = rcode;
return 1;
}
}
MQTTOperation::AUTH(ref v) => {
unsafe {
*result = v.reason_code;
}
*result = v.reason_code;
return 1;
}
MQTTOperation::CONNACK(ref v) => {
unsafe {
*result = v.return_code;
}
*result = v.return_code;
return 1;
}
MQTTOperation::DISCONNECT(ref v) => {
if let Some(rcode) = v.reason_code {
unsafe {
*result = rcode;
}
*result = rcode;
return 1;
}
}
@ -520,23 +472,23 @@ mod test {
});
let mut s: *const u8 = std::ptr::null_mut();
let mut slen: u32 = 0;
let mut r = rs_mqtt_tx_get_unsubscribe_topic(&t, 0, &mut s, &mut slen);
let mut r = unsafe{rs_mqtt_tx_get_unsubscribe_topic(&t, 0, &mut s, &mut slen)};
assert_eq!(r, 1);
let mut topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
let mut topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "foo");
r = rs_mqtt_tx_get_unsubscribe_topic(&t, 1, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_unsubscribe_topic(&t, 1, &mut s, &mut slen)};
assert_eq!(r, 1);
topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "baar");
r = rs_mqtt_tx_get_unsubscribe_topic(&t, 2, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_unsubscribe_topic(&t, 2, &mut s, &mut slen)};
assert_eq!(r, 1);
topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "fieee");
r = rs_mqtt_tx_get_unsubscribe_topic(&t, 3, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_unsubscribe_topic(&t, 3, &mut s, &mut slen)};
assert_eq!(r, 1);
topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "baaaaz");
r = rs_mqtt_tx_get_unsubscribe_topic(&t, 4, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_unsubscribe_topic(&t, 4, &mut s, &mut slen)};
assert_eq!(r, 0);
}
@ -588,23 +540,23 @@ mod test {
});
let mut s: *const u8 = std::ptr::null_mut();
let mut slen: u32 = 0;
let mut r = rs_mqtt_tx_get_subscribe_topic(&t, 0, &mut s, &mut slen);
let mut r = unsafe{rs_mqtt_tx_get_subscribe_topic(&t, 0, &mut s, &mut slen)};
assert_eq!(r, 1);
let mut topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
let mut topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "foo");
r = rs_mqtt_tx_get_subscribe_topic(&t, 1, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_subscribe_topic(&t, 1, &mut s, &mut slen)};
assert_eq!(r, 1);
topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "baar");
r = rs_mqtt_tx_get_subscribe_topic(&t, 2, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_subscribe_topic(&t, 2, &mut s, &mut slen)};
assert_eq!(r, 1);
topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "fieee");
r = rs_mqtt_tx_get_subscribe_topic(&t, 3, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_subscribe_topic(&t, 3, &mut s, &mut slen)};
assert_eq!(r, 1);
topic = String::from_utf8_lossy(build_slice!(s, slen as usize));
topic = String::from_utf8_lossy(unsafe{build_slice!(s, slen as usize)});
assert_eq!(topic, "baaaaz");
r = rs_mqtt_tx_get_subscribe_topic(&t, 4, &mut s, &mut slen);
r = unsafe{rs_mqtt_tx_get_subscribe_topic(&t, 4, &mut s, &mut slen)};
assert_eq!(r, 0);
}
}

2
rust/src/mqtt/logger.rs
Unescape Escape View File

@ -297,7 +297,7 @@ fn log_mqtt(tx: &MQTTTransaction, flags: u32, js: &mut JsonBuilder) -> Result<()
}
#[no_mangle]
pub extern "C" fn rs_mqtt_logger_log(_state: &mut MQTTState, tx: *mut std::os::raw::c_void, flags: u32, js: &mut JsonBuilder) -> bool {
pub unsafe extern "C" fn rs_mqtt_logger_log(_state: &mut MQTTState, tx: *mut std::os::raw::c_void, flags: u32, js: &mut JsonBuilder) -> bool {
let tx = cast_pointer!(tx, MQTTTransaction);
log_mqtt(tx, flags, js).is_ok()
}

50
rust/src/mqtt/mqtt.rs
Unescape Escape View File

@ -551,7 +551,7 @@ export_tx_get_detect_state!(rs_mqtt_tx_get_detect_state, MQTTTransaction);
export_tx_set_detect_state!(rs_mqtt_tx_set_detect_state, MQTTTransaction);
#[no_mangle]
pub extern "C" fn rs_mqtt_probing_parser(
pub unsafe extern "C" fn rs_mqtt_probing_parser(
_flow: *const Flow,
_direction: u8,
input: *const u8,
@ -563,16 +563,16 @@ pub extern "C" fn rs_mqtt_probing_parser(
Ok((_, hdr)) => {
// reject unassigned message type
if hdr.message_type == MQTTTypeCode::UNASSIGNED {
return unsafe { ALPROTO_FAILED } ;
return ALPROTO_FAILED;
}
// with 2 being the highest valid QoS level
if hdr.qos_level > 2 {
return unsafe { ALPROTO_FAILED };
return ALPROTO_FAILED;
}
return unsafe { ALPROTO_MQTT };
return ALPROTO_MQTT;
},
Err(nom::Err::Incomplete(_)) => ALPROTO_UNKNOWN,
Err(_) => unsafe { ALPROTO_FAILED }
Err(_) => ALPROTO_FAILED
}
}
@ -589,13 +589,13 @@ pub extern "C" fn rs_mqtt_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_mqtt_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, MQTTState);
state.free_tx(tx_id);
}
#[no_mangle]
pub extern "C" fn rs_mqtt_parse_request(
pub unsafe extern "C" fn rs_mqtt_parse_request(
_flow: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
@ -610,7 +610,7 @@ pub extern "C" fn rs_mqtt_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_parse_response(
pub unsafe extern "C" fn rs_mqtt_parse_response(
_flow: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
@ -625,7 +625,7 @@ pub extern "C" fn rs_mqtt_parse_response(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_get_tx(
pub unsafe extern "C" fn rs_mqtt_state_get_tx(
state: *mut std::os::raw::c_void,
tx_id: u64,
) -> *mut std::os::raw::c_void {
@ -641,13 +641,13 @@ pub extern "C" fn rs_mqtt_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_mqtt_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, MQTTState);
return state.tx_id;
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_is_toclient(tx: *const std::os::raw::c_void) -> std::os::raw::c_int {
pub unsafe extern "C" fn rs_mqtt_tx_is_toclient(tx: *const std::os::raw::c_void) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, MQTTTransaction);
if tx.toclient {
return 1;
@ -656,7 +656,7 @@ pub extern "C" fn rs_mqtt_tx_is_toclient(tx: *const std::os::raw::c_void) -> std
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_alstate_progress(
pub unsafe extern "C" fn rs_mqtt_tx_get_alstate_progress(
tx: *mut std::os::raw::c_void,
direction: u8,
) -> std::os::raw::c_int {
@ -676,7 +676,7 @@ pub extern "C" fn rs_mqtt_tx_get_alstate_progress(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_get_logged(
pub unsafe extern "C" fn rs_mqtt_tx_get_logged(
_state: *mut std::os::raw::c_void,
tx: *mut std::os::raw::c_void,
) -> u32 {
@ -685,7 +685,7 @@ pub extern "C" fn rs_mqtt_tx_get_logged(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_tx_set_logged(
pub unsafe extern "C" fn rs_mqtt_tx_set_logged(
_state: *mut std::os::raw::c_void,
tx: *mut std::os::raw::c_void,
logged: u32,
@ -695,7 +695,7 @@ pub extern "C" fn rs_mqtt_tx_set_logged(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_get_events(
pub unsafe extern "C" fn rs_mqtt_state_get_events(
tx: *mut std::os::raw::c_void,
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, MQTTTransaction);
@ -703,7 +703,7 @@ pub extern "C" fn rs_mqtt_state_get_events(
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_mqtt_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType)
-> i8
@ -720,10 +720,8 @@ pub extern "C" fn rs_mqtt_state_get_event_info_by_id(event_id: std::os::raw::c_i
MQTTEvent::MissingMsgId => { "missing_msg_id\0" },
MQTTEvent::UnassignedMsgtype => { "unassigned_msg_type\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -731,13 +729,13 @@ pub extern "C" fn rs_mqtt_state_get_event_info_by_id(event_id: std::os::raw::c_i
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_get_event_info(event_name: *const std::os::raw::c_char,
pub unsafe extern "C" fn rs_mqtt_state_get_event_info(event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType)
-> std::os::raw::c_int
{
if event_name == std::ptr::null() { return -1; }
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -755,15 +753,13 @@ pub extern "C" fn rs_mqtt_state_get_event_info(event_name: *const std::os::raw::
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe{
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
#[no_mangle]
pub extern "C" fn rs_mqtt_state_get_tx_iterator(
pub unsafe extern "C" fn rs_mqtt_state_get_tx_iterator(
_ipproto: u8,
_alproto: AppProto,
state: *mut std::os::raw::c_void,

116
rust/src/nfs/nfs.rs
Unescape Escape View File

@ -1390,7 +1390,7 @@ pub extern "C" fn rs_nfs_state_free(state: *mut std::os::raw::c_void) {
/// C binding parse a NFS TCP request. Returns 1 on success, -1 on failure.
#[no_mangle]
pub extern "C" fn rs_nfs_parse_request(flow: *const Flow,
pub unsafe extern "C" fn rs_nfs_parse_request(flow: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -1401,13 +1401,13 @@ pub extern "C" fn rs_nfs_parse_request(flow: *const Flow,
{
let state = cast_pointer!(state, NFSState);
let flow = cast_pointer!(flow, Flow);
let file_flags = unsafe { FileFlowToFlags(flow, STREAM_TOSERVER) };
let file_flags = FileFlowToFlags(flow, STREAM_TOSERVER);
rs_nfs_setfileflags(STREAM_TOSERVER, state, file_flags);
if input.is_null() == true && input_len > 0 {
return rs_nfs_parse_request_tcp_gap(state, input_len);
}
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
SCLogDebug!("parsing {} bytes of request data", input_len);
state.update_ts(flow.get_last_time().as_secs());
@ -1424,7 +1424,7 @@ pub extern "C" fn rs_nfs_parse_request_tcp_gap(
}
#[no_mangle]
pub extern "C" fn rs_nfs_parse_response(flow: *const Flow,
pub unsafe extern "C" fn rs_nfs_parse_response(flow: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -1435,14 +1435,14 @@ pub extern "C" fn rs_nfs_parse_response(flow: *const Flow,
{
let state = cast_pointer!(state, NFSState);
let flow = cast_pointer!(flow, Flow);
let file_flags = unsafe { FileFlowToFlags(flow, STREAM_TOCLIENT) };
let file_flags = FileFlowToFlags(flow, STREAM_TOCLIENT);
rs_nfs_setfileflags(STREAM_TOCLIENT, state, file_flags);
if input.is_null() == true && input_len > 0 {
return rs_nfs_parse_response_tcp_gap(state, input_len);
}
SCLogDebug!("parsing {} bytes of response data", input_len);
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
state.update_ts(flow.get_last_time().as_secs());
state.parse_tcp_data_tc(buf)
@ -1459,7 +1459,7 @@ pub extern "C" fn rs_nfs_parse_response_tcp_gap(
/// C binding to parse an NFS/UDP request. Returns 1 on success, -1 on failure.
#[no_mangle]
pub extern "C" fn rs_nfs_parse_request_udp(f: *const Flow,
pub unsafe extern "C" fn rs_nfs_parse_request_udp(f: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -1468,16 +1468,16 @@ pub extern "C" fn rs_nfs_parse_request_udp(f: *const Flow,
_flags: u8) -> AppLayerResult
{
let state = cast_pointer!(state, NFSState);
let file_flags = unsafe { FileFlowToFlags(f, STREAM_TOSERVER) };
let file_flags = FileFlowToFlags(f, STREAM_TOSERVER);
rs_nfs_setfileflags(STREAM_TOSERVER, state, file_flags);
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
SCLogDebug!("parsing {} bytes of request data", input_len);
state.parse_udp_ts(buf)
}
#[no_mangle]
pub extern "C" fn rs_nfs_parse_response_udp(f: *const Flow,
pub unsafe extern "C" fn rs_nfs_parse_response_udp(f: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -1486,15 +1486,15 @@ pub extern "C" fn rs_nfs_parse_response_udp(f: *const Flow,
_flags: u8) -> AppLayerResult
{
let state = cast_pointer!(state, NFSState);
let file_flags = unsafe { FileFlowToFlags(f, STREAM_TOCLIENT) };
let file_flags = FileFlowToFlags(f, STREAM_TOCLIENT);
rs_nfs_setfileflags(STREAM_TOCLIENT, state, file_flags);
SCLogDebug!("parsing {} bytes of response data", input_len);
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
state.parse_udp_tc(buf)
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_tx_count(state: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_nfs_state_get_tx_count(state: *mut std::os::raw::c_void)
-> u64
{
let state = cast_pointer!(state, NFSState);
@ -1503,7 +1503,7 @@ pub extern "C" fn rs_nfs_state_get_tx_count(state: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_tx(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_nfs_state_get_tx(state: *mut std::os::raw::c_void,
tx_id: u64)
-> *mut std::os::raw::c_void
{
@ -1520,7 +1520,7 @@ pub extern "C" fn rs_nfs_state_get_tx(state: *mut std::os::raw::c_void,
// for use with the C API call StateGetTxIterator
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_tx_iterator(
pub unsafe extern "C" fn rs_nfs_state_get_tx_iterator(
_ipproto: u8,
_alproto: AppProto,
state: *mut std::os::raw::c_void,
@ -1543,7 +1543,7 @@ pub extern "C" fn rs_nfs_state_get_tx_iterator(
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_tx_free(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_nfs_state_tx_free(state: *mut std::os::raw::c_void,
tx_id: u64)
{
let state = cast_pointer!(state, NFSState);
@ -1551,7 +1551,7 @@ pub extern "C" fn rs_nfs_state_tx_free(state: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_nfs_tx_get_alstate_progress(tx: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_nfs_tx_get_alstate_progress(tx: *mut std::os::raw::c_void,
direction: u8)
-> std::os::raw::c_int
{
@ -1569,7 +1569,7 @@ pub extern "C" fn rs_nfs_tx_get_alstate_progress(tx: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_nfs_get_tx_data(
pub unsafe extern "C" fn rs_nfs_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
{
@ -1578,7 +1578,7 @@ pub extern "C" fn rs_nfs_get_tx_data(
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_nfs_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut DetectEngineState) -> i32
{
@ -1588,7 +1588,7 @@ pub extern "C" fn rs_nfs_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_nfs_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void)
-> *mut DetectEngineState
{
@ -1606,7 +1606,7 @@ pub extern "C" fn rs_nfs_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_nfs_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, NFSTransaction);
@ -1614,7 +1614,7 @@ pub extern "C" fn rs_nfs_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_nfs_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut AppLayerEventType)
-> i8
@ -1625,10 +1625,8 @@ pub extern "C" fn rs_nfs_state_get_event_info_by_id(event_id: std::os::raw::c_in
NFSEvent::NonExistingVersion => { "non_existing_version\0" },
NFSEvent::UnsupportedVersion => { "unsupported_version\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -1637,7 +1635,7 @@ pub extern "C" fn rs_nfs_state_get_event_info_by_id(event_id: std::os::raw::c_in
#[no_mangle]
pub extern "C" fn rs_nfs_state_get_event_info(event_name: *const std::os::raw::c_char,
pub unsafe extern "C" fn rs_nfs_state_get_event_info(event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut AppLayerEventType)
-> std::os::raw::c_int
@ -1645,7 +1643,7 @@ pub extern "C" fn rs_nfs_state_get_event_info(event_name: *const std::os::raw::c
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -1655,10 +1653,8 @@ pub extern "C" fn rs_nfs_state_get_event_info(event_name: *const std::os::raw::c
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe{
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
@ -1666,15 +1662,13 @@ pub extern "C" fn rs_nfs_state_get_event_info(event_name: *const std::os::raw::c
/// otherwise get procs from the 'file_additional_procs'.
/// Keep calling until 0 is returned.
#[no_mangle]
pub extern "C" fn rs_nfs_tx_get_procedures(tx: &mut NFSTransaction,
pub unsafe extern "C" fn rs_nfs_tx_get_procedures(tx: &mut NFSTransaction,
i: u16,
procedure: *mut u32)
-> u8
{
if i == 0 {
unsafe {
*procedure = tx.procedure as u32;
}
*procedure = tx.procedure as u32;
return 1;
}
@ -1688,9 +1682,7 @@ pub extern "C" fn rs_nfs_tx_get_procedures(tx: &mut NFSTransaction,
let idx = i as usize - 1;
if idx < tdf.file_additional_procs.len() {
let p = tdf.file_additional_procs[idx];
unsafe {
*procedure = p as u32;
}
*procedure = p as u32;
return 1;
}
}
@ -1698,20 +1690,16 @@ pub extern "C" fn rs_nfs_tx_get_procedures(tx: &mut NFSTransaction,
}
#[no_mangle]
pub extern "C" fn rs_nfs_tx_get_version(tx: &mut NFSTransaction,
pub unsafe extern "C" fn rs_nfs_tx_get_version(tx: &mut NFSTransaction,
version: *mut u32)
{
unsafe {
*version = tx.nfs_version as u32;
}
*version = tx.nfs_version as u32;
}
#[no_mangle]
pub extern "C" fn rs_nfs_init(context: &'static mut SuricataFileContext)
pub unsafe extern "C" fn rs_nfs_init(context: &'static mut SuricataFileContext)
{
unsafe {
SURICATA_NFS_FILE_CONFIG = Some(context);
}
SURICATA_NFS_FILE_CONFIG = Some(context);
}
fn nfs_probe_dir(i: &[u8], rdir: *mut u8) -> i8 {
@ -1826,7 +1814,7 @@ pub fn nfs_probe_udp(i: &[u8], direction: u8) -> i32 {
/// MIDSTREAM
#[no_mangle]
pub extern "C" fn rs_nfs_probe_ms(
pub unsafe extern "C" fn rs_nfs_probe_ms(
_flow: *const Flow,
direction: u8, input: *const u8,
len: u32, rdir: *mut u8) -> AppProto
@ -1845,25 +1833,25 @@ pub extern "C" fn rs_nfs_probe_ms(
1 => {
SCLogDebug!("nfs_probe success: dir {:02x} adir {:02x}", direction, adirection);
if (direction & (STREAM_TOSERVER|STREAM_TOCLIENT)) != adirection {
unsafe { *rdir = adirection; }
*rdir = adirection;
}
unsafe { ALPROTO_NFS }
ALPROTO_NFS
},
0 => { ALPROTO_UNKNOWN },
_ => { unsafe { ALPROTO_FAILED } },
_ => { ALPROTO_FAILED },
}
},
0 => {
ALPROTO_UNKNOWN
},
_ => {
unsafe { ALPROTO_FAILED }
ALPROTO_FAILED
}
}
}
#[no_mangle]
pub extern "C" fn rs_nfs_probe(_f: *const Flow,
pub unsafe extern "C" fn rs_nfs_probe(_f: *const Flow,
direction: u8,
input: *const u8,
len: u32,
@ -1873,15 +1861,15 @@ pub extern "C" fn rs_nfs_probe(_f: *const Flow,
let slice: &[u8] = build_slice!(input, len as usize);
SCLogDebug!("rs_nfs_probe: running probe");
match nfs_probe(slice, direction) {
1 => { unsafe { ALPROTO_NFS } },
-1 => { unsafe { ALPROTO_FAILED } },
1 => { ALPROTO_NFS },
-1 => { ALPROTO_FAILED },
_ => { ALPROTO_UNKNOWN },
}
}
/// TOSERVER probe function
#[no_mangle]
pub extern "C" fn rs_nfs_probe_udp_ts(_f: *const Flow,
pub unsafe extern "C" fn rs_nfs_probe_udp_ts(_f: *const Flow,
_direction: u8,
input: *const u8,
len: u32,
@ -1890,15 +1878,15 @@ pub extern "C" fn rs_nfs_probe_udp_ts(_f: *const Flow,
{
let slice: &[u8] = build_slice!(input, len as usize);
match nfs_probe_udp(slice, STREAM_TOSERVER) {
1 => { unsafe { ALPROTO_NFS } },
-1 => { unsafe { ALPROTO_FAILED } },
1 => { ALPROTO_NFS },
-1 => { ALPROTO_FAILED },
_ => { ALPROTO_UNKNOWN },
}
}
/// TOCLIENT probe function
#[no_mangle]
pub extern "C" fn rs_nfs_probe_udp_tc(_f: *const Flow,
pub unsafe extern "C" fn rs_nfs_probe_udp_tc(_f: *const Flow,
_direction: u8,
input: *const u8,
len: u32,
@ -1907,22 +1895,22 @@ pub extern "C" fn rs_nfs_probe_udp_tc(_f: *const Flow,
{
let slice: &[u8] = build_slice!(input, len as usize);
match nfs_probe_udp(slice, STREAM_TOCLIENT) {
1 => { unsafe { ALPROTO_NFS } },
-1 => { unsafe { ALPROTO_FAILED } },
1 => { ALPROTO_NFS },
-1 => { ALPROTO_FAILED },
_ => { ALPROTO_UNKNOWN },
}
}
#[no_mangle]
pub extern "C" fn rs_nfs_getfiles(ptr: *mut std::ffi::c_void, direction: u8) -> * mut FileContainer {
pub unsafe extern "C" fn rs_nfs_getfiles(ptr: *mut std::ffi::c_void, direction: u8) -> * mut FileContainer {
if ptr.is_null() { panic!("NULL ptr"); };
let parser = cast_pointer!(ptr, NFSState);
parser.getfiles(direction)
}
#[no_mangle]
pub extern "C" fn rs_nfs_setfileflags(direction: u8, ptr: *mut NFSState, flags: u16) {
pub unsafe extern "C" fn rs_nfs_setfileflags(direction: u8, ptr: *mut NFSState, flags: u16) {
if ptr.is_null() { panic!("NULL ptr"); };
let parser = unsafe { &mut *ptr };
let parser = &mut *ptr;
SCLogDebug!("direction {} flags {}", direction, flags);
parser.setfileflags(direction, flags)
}

34
rust/src/ntp/ntp.rs
Unescape Escape View File

@ -190,7 +190,7 @@ pub extern "C" fn rs_ntp_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_ntp_parse_request(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_ntp_parse_request(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -206,7 +206,7 @@ pub extern "C" fn rs_ntp_parse_request(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_ntp_parse_response(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_ntp_parse_response(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -222,7 +222,7 @@ pub extern "C" fn rs_ntp_parse_response(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_get_tx(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_ntp_state_get_tx(state: *mut std::os::raw::c_void,
tx_id: u64)
-> *mut std::os::raw::c_void
{
@ -234,7 +234,7 @@ pub extern "C" fn rs_ntp_state_get_tx(state: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_get_tx_count(state: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_ntp_state_get_tx_count(state: *mut std::os::raw::c_void)
-> u64
{
let state = cast_pointer!(state,NTPState);
@ -242,7 +242,7 @@ pub extern "C" fn rs_ntp_state_get_tx_count(state: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_tx_free(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_ntp_state_tx_free(state: *mut std::os::raw::c_void,
tx_id: u64)
{
let state = cast_pointer!(state,NTPState);
@ -258,7 +258,7 @@ pub extern "C" fn rs_ntp_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_ntp_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut core::DetectEngineState) -> std::os::raw::c_int
{
@ -268,7 +268,7 @@ pub extern "C" fn rs_ntp_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_ntp_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void)
-> *mut core::DetectEngineState
{
@ -280,7 +280,7 @@ pub extern "C" fn rs_ntp_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_ntp_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType)
-> i8
@ -292,10 +292,8 @@ pub extern "C" fn rs_ntp_state_get_event_info_by_id(event_id: std::os::raw::c_in
NTPEvent::NotRequest => { "not_request\0" },
NTPEvent::NotResponse => { "not_response\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -303,7 +301,7 @@ pub extern "C" fn rs_ntp_state_get_event_info_by_id(event_id: std::os::raw::c_in
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_ntp_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, NTPTransaction);
@ -311,13 +309,13 @@ pub extern "C" fn rs_ntp_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_ntp_state_get_event_info(event_name: *const std::os::raw::c_char,
pub unsafe extern "C" fn rs_ntp_state_get_event_info(event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType)
-> std::os::raw::c_int
{
if event_name == std::ptr::null() { return -1; }
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -327,10 +325,8 @@ pub extern "C" fn rs_ntp_state_get_event_info(event_name: *const std::os::raw::c
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe{
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}

14
rust/src/rdp/rdp.rs
Unescape Escape View File

@ -79,7 +79,7 @@ impl Drop for RdpTransaction {
}
#[no_mangle]
pub extern "C" fn rs_rdp_state_get_tx(
pub unsafe extern "C" fn rs_rdp_state_get_tx(
state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, RdpState);
@ -94,7 +94,7 @@ pub extern "C" fn rs_rdp_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_rdp_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_rdp_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, RdpState);
return state.next_id;
}
@ -384,7 +384,7 @@ pub extern "C" fn rs_rdp_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_rdp_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_rdp_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, RdpState);
state.free_tx(tx_id);
}
@ -407,7 +407,7 @@ fn probe_rdp(input: &[u8]) -> bool {
/// probe for T.123 message, whether to client or to server
#[no_mangle]
pub extern "C" fn rs_rdp_probe_ts_tc(
pub unsafe extern "C" fn rs_rdp_probe_ts_tc(
_flow: *const Flow, _direction: u8, input: *const u8, input_len: u32, _rdir: *mut u8,
) -> AppProto {
if input != std::ptr::null_mut() {
@ -418,7 +418,7 @@ pub extern "C" fn rs_rdp_probe_ts_tc(
// https://wiki.wireshark.org/SampleCaptures?action=AttachFile&do=view&target=rdp-ssl.pcap.gz
// but this callback will not be exercised, so `probe_tls_handshake` not needed here.
if probe_rdp(slice) {
return unsafe { ALPROTO_RDP };
return ALPROTO_RDP;
}
}
return ALPROTO_UNKNOWN;
@ -434,7 +434,7 @@ fn probe_tls_handshake(input: &[u8]) -> bool {
//
#[no_mangle]
pub extern "C" fn rs_rdp_parse_ts(
pub unsafe extern "C" fn rs_rdp_parse_ts(
_flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
@ -445,7 +445,7 @@ pub extern "C" fn rs_rdp_parse_ts(
}
#[no_mangle]
pub extern "C" fn rs_rdp_parse_tc(
pub unsafe extern "C" fn rs_rdp_parse_tc(
_flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {

2
rust/src/rfb/logger.rs
Unescape Escape View File

@ -113,7 +113,7 @@ fn log_rfb(tx: &RFBTransaction, js: &mut JsonBuilder) -> Result<(), JsonError> {
}
#[no_mangle]
pub extern "C" fn rs_rfb_logger_log(_state: &mut RFBState,
pub unsafe extern "C" fn rs_rfb_logger_log(_state: &mut RFBState,
tx: *mut std::os::raw::c_void,
js: &mut JsonBuilder) -> bool {
let tx = cast_pointer!(tx, RFBTransaction);

16
rust/src/rfb/rfb.rs
Unescape Escape View File

@ -530,7 +530,7 @@ pub extern "C" fn rs_rfb_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_rfb_state_tx_free(
pub unsafe extern "C" fn rs_rfb_state_tx_free(
state: *mut std::os::raw::c_void,
tx_id: u64,
) {
@ -539,7 +539,7 @@ pub extern "C" fn rs_rfb_state_tx_free(
}
#[no_mangle]
pub extern "C" fn rs_rfb_parse_request(
pub unsafe extern "C" fn rs_rfb_parse_request(
_flow: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
@ -554,7 +554,7 @@ pub extern "C" fn rs_rfb_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_rfb_parse_response(
pub unsafe extern "C" fn rs_rfb_parse_response(
_flow: *const Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
@ -569,7 +569,7 @@ pub extern "C" fn rs_rfb_parse_response(
}
#[no_mangle]
pub extern "C" fn rs_rfb_state_get_tx(
pub unsafe extern "C" fn rs_rfb_state_get_tx(
state: *mut std::os::raw::c_void,
tx_id: u64,
) -> *mut std::os::raw::c_void {
@ -585,7 +585,7 @@ pub extern "C" fn rs_rfb_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_rfb_state_get_tx_count(
pub unsafe extern "C" fn rs_rfb_state_get_tx_count(
state: *mut std::os::raw::c_void,
) -> u64 {
let state = cast_pointer!(state, RFBState);
@ -593,7 +593,7 @@ pub extern "C" fn rs_rfb_state_get_tx_count(
}
#[no_mangle]
pub extern "C" fn rs_rfb_tx_get_alstate_progress(
pub unsafe extern "C" fn rs_rfb_tx_get_alstate_progress(
tx: *mut std::os::raw::c_void,
_direction: u8,
) -> std::os::raw::c_int {
@ -605,7 +605,7 @@ pub extern "C" fn rs_rfb_tx_get_alstate_progress(
}
#[no_mangle]
pub extern "C" fn rs_rfb_state_get_events(
pub unsafe extern "C" fn rs_rfb_state_get_events(
tx: *mut std::os::raw::c_void
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, RFBTransaction);
@ -629,7 +629,7 @@ pub extern "C" fn rs_rfb_state_get_event_info_by_id(_event_id: std::os::raw::c_i
return -1;
}
#[no_mangle]
pub extern "C" fn rs_rfb_state_get_tx_iterator(
pub unsafe extern "C" fn rs_rfb_state_get_tx_iterator(
_ipproto: u8,
_alproto: AppProto,
state: *mut std::os::raw::c_void,

42
rust/src/sip/sip.rs
Unescape Escape View File

@ -182,7 +182,7 @@ pub extern "C" fn rs_sip_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_sip_state_get_tx(
pub unsafe extern "C" fn rs_sip_state_get_tx(
state: *mut std::os::raw::c_void,
tx_id: u64,
) -> *mut std::os::raw::c_void {
@ -194,13 +194,13 @@ pub extern "C" fn rs_sip_state_get_tx(
}
#[no_mangle]
pub extern "C" fn rs_sip_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
pub unsafe extern "C" fn rs_sip_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, SIPState);
state.tx_id
}
#[no_mangle]
pub extern "C" fn rs_sip_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
pub unsafe extern "C" fn rs_sip_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, SIPState);
state.free_tx(tx_id);
}
@ -214,7 +214,7 @@ pub extern "C" fn rs_sip_tx_get_alstate_progress(
}
#[no_mangle]
pub extern "C" fn rs_sip_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_sip_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut core::DetectEngineState,
) -> std::os::raw::c_int {
@ -224,7 +224,7 @@ pub extern "C" fn rs_sip_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_sip_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_sip_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void,
) -> *mut core::DetectEngineState {
let tx = cast_pointer!(tx, SIPTransaction);
@ -235,7 +235,7 @@ pub extern "C" fn rs_sip_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_sip_state_get_events(
pub unsafe extern "C" fn rs_sip_state_get_events(
tx: *mut std::os::raw::c_void,
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, SIPTransaction);
@ -243,7 +243,7 @@ pub extern "C" fn rs_sip_state_get_events(
}
#[no_mangle]
pub extern "C" fn rs_sip_state_get_event_info(
pub unsafe extern "C" fn rs_sip_state_get_event_info(
event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType,
@ -251,7 +251,7 @@ pub extern "C" fn rs_sip_state_get_event_info(
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -262,15 +262,13 @@ pub extern "C" fn rs_sip_state_get_event_info(
}
Err(_) => -1, // UTF-8 conversion failed
};
unsafe {
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
#[no_mangle]
pub extern "C" fn rs_sip_state_get_event_info_by_id(
pub unsafe extern "C" fn rs_sip_state_get_event_info_by_id(
event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType,
@ -280,10 +278,8 @@ pub extern "C" fn rs_sip_state_get_event_info_by_id(
SIPEvent::IncompleteData => "incomplete_data\0",
SIPEvent::InvalidData => "invalid_data\0",
};
unsafe {
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -293,7 +289,7 @@ pub extern "C" fn rs_sip_state_get_event_info_by_id(
static mut ALPROTO_SIP: AppProto = ALPROTO_UNKNOWN;
#[no_mangle]
pub extern "C" fn rs_sip_probing_parser_ts(
pub unsafe extern "C" fn rs_sip_probing_parser_ts(
_flow: *const Flow,
_direction: u8,
input: *const u8,
@ -302,13 +298,13 @@ pub extern "C" fn rs_sip_probing_parser_ts(
) -> AppProto {
let buf = build_slice!(input, input_len as usize);
if sip_parse_request(buf).is_ok() {
return unsafe { ALPROTO_SIP };
return ALPROTO_SIP;
}
return ALPROTO_UNKNOWN;
}
#[no_mangle]
pub extern "C" fn rs_sip_probing_parser_tc(
pub unsafe extern "C" fn rs_sip_probing_parser_tc(
_flow: *const Flow,
_direction: u8,
input: *const u8,
@ -317,13 +313,13 @@ pub extern "C" fn rs_sip_probing_parser_tc(
) -> AppProto {
let buf = build_slice!(input, input_len as usize);
if sip_parse_response(buf).is_ok() {
return unsafe { ALPROTO_SIP };
return ALPROTO_SIP;
}
return ALPROTO_UNKNOWN;
}
#[no_mangle]
pub extern "C" fn rs_sip_parse_request(
pub unsafe extern "C" fn rs_sip_parse_request(
_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
@ -338,7 +334,7 @@ pub extern "C" fn rs_sip_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_sip_parse_response(
pub unsafe extern "C" fn rs_sip_parse_response(
_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,

48
rust/src/smb/detect.rs
Unescape Escape View File

@ -21,7 +21,7 @@ use crate::smb::smb::*;
use crate::dcerpc::detect::{DCEIfaceData, DCEOpnumData, DETECT_DCE_OPNUM_RANGE_UNINITIALIZED};
#[no_mangle]
pub extern "C" fn rs_smb_tx_get_share(tx: &mut SMBTransaction,
pub unsafe extern "C" fn rs_smb_tx_get_share(tx: &mut SMBTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32)
-> u8
@ -30,26 +30,22 @@ pub extern "C" fn rs_smb_tx_get_share(tx: &mut SMBTransaction,
Some(SMBTransactionTypeData::TREECONNECT(ref x)) => {
SCLogDebug!("is_pipe {}", x.is_pipe);
if !x.is_pipe {
unsafe {
*buffer = x.share_name.as_ptr();
*buffer_len = x.share_name.len() as u32;
return 1;
}
*buffer = x.share_name.as_ptr();
*buffer_len = x.share_name.len() as u32;
return 1;
}
}
_ => {
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_smb_tx_get_named_pipe(tx: &mut SMBTransaction,
pub unsafe extern "C" fn rs_smb_tx_get_named_pipe(tx: &mut SMBTransaction,
buffer: *mut *const u8,
buffer_len: *mut u32)
-> u8
@ -58,26 +54,22 @@ pub extern "C" fn rs_smb_tx_get_named_pipe(tx: &mut SMBTransaction,
Some(SMBTransactionTypeData::TREECONNECT(ref x)) => {
SCLogDebug!("is_pipe {}", x.is_pipe);
if x.is_pipe {
unsafe {
*buffer = x.share_name.as_ptr();
*buffer_len = x.share_name.len() as u32;
return 1;
}
*buffer = x.share_name.as_ptr();
*buffer_len = x.share_name.len() as u32;
return 1;
}
}
_ => {
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_smb_tx_get_stub_data(tx: &mut SMBTransaction,
pub unsafe extern "C" fn rs_smb_tx_get_stub_data(tx: &mut SMBTransaction,
direction: u8,
buffer: *mut *const u8,
buffer_len: *mut u32)
@ -91,21 +83,17 @@ pub extern "C" fn rs_smb_tx_get_stub_data(tx: &mut SMBTransaction,
&x.stub_data_tc
};
if vref.len() > 0 {
unsafe {
*buffer = vref.as_ptr();
*buffer_len = vref.len() as u32;
return 1;
}
*buffer = vref.as_ptr();
*buffer_len = vref.len() as u32;
return 1;
}
}
_ => {
}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}

6
rust/src/smb/files.rs
Unescape Escape View File

@ -190,16 +190,16 @@ impl SMBState {
}
#[no_mangle]
pub extern "C" fn rs_smb_getfiles(ptr: *mut std::ffi::c_void, direction: u8) -> * mut FileContainer {
pub unsafe extern "C" fn rs_smb_getfiles(ptr: *mut std::ffi::c_void, direction: u8) -> * mut FileContainer {
if ptr.is_null() { panic!("NULL ptr"); };
let parser = cast_pointer!(ptr, SMBState);
parser.getfiles(direction)
}
#[no_mangle]
pub extern "C" fn rs_smb_setfileflags(direction: u8, ptr: *mut SMBState, flags: u16) {
pub unsafe extern "C" fn rs_smb_setfileflags(direction: u8, ptr: *mut SMBState, flags: u16) {
if ptr.is_null() { panic!("NULL ptr"); };
let parser = unsafe { &mut *ptr };
let parser = &mut *ptr;
SCLogDebug!("direction {} flags {}", direction, flags);
parser.setfileflags(direction, flags)
}

76
rust/src/smb/smb.rs
Unescape Escape View File

@ -1811,7 +1811,7 @@ pub extern "C" fn rs_smb_state_free(state: *mut std::os::raw::c_void) {
/// C binding parse a SMB request. Returns 1 on success, -1 on failure.
#[no_mangle]
pub extern "C" fn rs_smb_parse_request_tcp(flow: *const Flow,
pub unsafe extern "C" fn rs_smb_parse_request_tcp(flow: *const Flow,
state: *mut ffi::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -1820,10 +1820,10 @@ pub extern "C" fn rs_smb_parse_request_tcp(flow: *const Flow,
flags: u8)
-> AppLayerResult
{
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
let mut state = cast_pointer!(state, SMBState);
let flow = cast_pointer!(flow, Flow);
let file_flags = unsafe { FileFlowToFlags(flow, STREAM_TOSERVER) };
let file_flags = FileFlowToFlags(flow, STREAM_TOSERVER);
rs_smb_setfileflags(STREAM_TOSERVER, state, file_flags|FILE_USE_DETECT);
SCLogDebug!("parsing {} bytes of request data", input_len);
@ -1850,7 +1850,7 @@ pub extern "C" fn rs_smb_parse_request_tcp_gap(
#[no_mangle]
pub extern "C" fn rs_smb_parse_response_tcp(flow: *const Flow,
pub unsafe extern "C" fn rs_smb_parse_response_tcp(flow: *const Flow,
state: *mut ffi::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -1861,14 +1861,14 @@ pub extern "C" fn rs_smb_parse_response_tcp(flow: *const Flow,
{
let mut state = cast_pointer!(state, SMBState);
let flow = cast_pointer!(flow, Flow);
let file_flags = unsafe { FileFlowToFlags(flow, STREAM_TOCLIENT) };
let file_flags = FileFlowToFlags(flow, STREAM_TOCLIENT);
rs_smb_setfileflags(STREAM_TOCLIENT, state, file_flags|FILE_USE_DETECT);
if input.is_null() && input_len > 0 {
return rs_smb_parse_response_tcp_gap(state, input_len);
}
SCLogDebug!("parsing {} bytes of response data", input_len);
let buf = unsafe{std::slice::from_raw_parts(input, input_len as usize)};
let buf = std::slice::from_raw_parts(input, input_len as usize);
/* START with MISTREAM set: record might be starting the middle. */
if flags & (STREAM_START|STREAM_MIDSTREAM) == (STREAM_START|STREAM_MIDSTREAM) {
@ -1954,7 +1954,7 @@ fn smb_probe_tcp_midstream(direction: u8, slice: &[u8], rdir: *mut u8) -> i8
// probing parser
// return 1 if found, 0 is not found
#[no_mangle]
pub extern "C" fn rs_smb_probe_tcp(_f: *const Flow,
pub unsafe extern "C" fn rs_smb_probe_tcp(_f: *const Flow,
flags: u8, input: *const u8, len: u32, rdir: *mut u8)
-> AppProto
{
@ -1964,14 +1964,14 @@ pub extern "C" fn rs_smb_probe_tcp(_f: *const Flow,
let slice = build_slice!(input, len as usize);
if flags & STREAM_MIDSTREAM == STREAM_MIDSTREAM {
if smb_probe_tcp_midstream(flags, slice, rdir) == 1 {
return unsafe { ALPROTO_SMB };
return ALPROTO_SMB;
}
}
match parse_nbss_record_partial(slice) {
Ok((_, ref hdr)) => {
if hdr.is_smb() {
SCLogDebug!("smb found");
return unsafe { ALPROTO_SMB };
return ALPROTO_SMB;
} else if hdr.needs_more(){
return 0;
} else if hdr.is_valid() &&
@ -1984,7 +1984,7 @@ pub extern "C" fn rs_smb_probe_tcp(_f: *const Flow,
Ok((_, ref hdr2)) => {
if hdr2.is_smb() {
SCLogDebug!("smb found");
return unsafe { ALPROTO_SMB };
return ALPROTO_SMB;
}
}
_ => {}
@ -1999,11 +1999,11 @@ pub extern "C" fn rs_smb_probe_tcp(_f: *const Flow,
_ => { },
}
SCLogDebug!("no smb");
return unsafe { ALPROTO_FAILED };
return ALPROTO_FAILED;
}
#[no_mangle]
pub extern "C" fn rs_smb_state_get_tx_count(state: *mut ffi::c_void)
pub unsafe extern "C" fn rs_smb_state_get_tx_count(state: *mut ffi::c_void)
-> u64
{
let state = cast_pointer!(state, SMBState);
@ -2012,7 +2012,7 @@ pub extern "C" fn rs_smb_state_get_tx_count(state: *mut ffi::c_void)
}
#[no_mangle]
pub extern "C" fn rs_smb_state_get_tx(state: *mut ffi::c_void,
pub unsafe extern "C" fn rs_smb_state_get_tx(state: *mut ffi::c_void,
tx_id: u64)
-> *mut ffi::c_void
{
@ -2029,7 +2029,7 @@ pub extern "C" fn rs_smb_state_get_tx(state: *mut ffi::c_void,
// for use with the C API call StateGetTxIterator
#[no_mangle]
pub extern "C" fn rs_smb_state_get_tx_iterator(
pub unsafe extern "C" fn rs_smb_state_get_tx_iterator(
_ipproto: u8,
_alproto: AppProto,
state: *mut std::os::raw::c_void,
@ -2052,7 +2052,7 @@ pub extern "C" fn rs_smb_state_get_tx_iterator(
}
#[no_mangle]
pub extern "C" fn rs_smb_state_tx_free(state: *mut ffi::c_void,
pub unsafe extern "C" fn rs_smb_state_tx_free(state: *mut ffi::c_void,
tx_id: u64)
{
let state = cast_pointer!(state, SMBState);
@ -2061,7 +2061,7 @@ pub extern "C" fn rs_smb_state_tx_free(state: *mut ffi::c_void,
}
#[no_mangle]
pub extern "C" fn rs_smb_tx_get_alstate_progress(tx: *mut ffi::c_void,
pub unsafe extern "C" fn rs_smb_tx_get_alstate_progress(tx: *mut ffi::c_void,
direction: u8)
-> i32
{
@ -2081,7 +2081,7 @@ pub extern "C" fn rs_smb_tx_get_alstate_progress(tx: *mut ffi::c_void,
#[no_mangle]
pub extern "C" fn rs_smb_get_tx_data(
pub unsafe extern "C" fn rs_smb_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
{
@ -2090,7 +2090,7 @@ pub extern "C" fn rs_smb_get_tx_data(
}
#[no_mangle]
pub extern "C" fn rs_smb_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_smb_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void)
-> *mut DetectEngineState
{
@ -2106,7 +2106,7 @@ pub extern "C" fn rs_smb_state_get_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_smb_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_smb_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut DetectEngineState) -> std::os::raw::c_int
{
@ -2116,7 +2116,7 @@ pub extern "C" fn rs_smb_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_smb_state_truncate(
pub unsafe extern "C" fn rs_smb_state_truncate(
state: *mut std::ffi::c_void,
direction: u8)
{
@ -2129,7 +2129,7 @@ pub extern "C" fn rs_smb_state_truncate(
}
#[no_mangle]
pub extern "C" fn rs_smb_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_smb_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, SMBTransaction);
@ -2137,7 +2137,7 @@ pub extern "C" fn rs_smb_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_smb_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_smb_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut AppLayerEventType)
-> i8
@ -2153,10 +2153,8 @@ pub extern "C" fn rs_smb_state_get_event_info_by_id(event_id: std::os::raw::c_in
SMBEvent::NegotiateMalformedDialects => { "netogiate_malformed_dialects\0" },
SMBEvent::FileOverlap => { "file_overlap\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -2164,7 +2162,7 @@ pub extern "C" fn rs_smb_state_get_event_info_by_id(event_id: std::os::raw::c_in
}
#[no_mangle]
pub extern "C" fn rs_smb_state_get_event_info(event_name: *const std::os::raw::c_char,
pub unsafe extern "C" fn rs_smb_state_get_event_info(event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut AppLayerEventType)
-> i32
@ -2172,27 +2170,25 @@ pub extern "C" fn rs_smb_state_get_event_info(event_name: *const std::os::raw::c
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
smb_str_to_event(s)
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe {
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
if event == -1 {
return -1;
}
0
}
pub extern "C" fn smb3_probe_tcp(f: *const Flow, dir: u8, input: *const u8, len: u32, rdir: *mut u8) -> u16 {
pub unsafe extern "C" fn smb3_probe_tcp(f: *const Flow, dir: u8, input: *const u8, len: u32, rdir: *mut u8) -> u16 {
let retval = rs_smb_probe_tcp(f, dir, input, len, rdir);
let f = cast_pointer!(f, Flow);
if unsafe { retval != ALPROTO_SMB } {
if retval != ALPROTO_SMB {
return retval;
}
let (sp, dp) = f.get_ports();
@ -2200,15 +2196,13 @@ pub extern "C" fn smb3_probe_tcp(f: *const Flow, dir: u8, input: *const u8, len:
let fsp = if (flags & FLOW_DIR_REVERSED) != 0 { dp } else { sp };
let fdp = if (flags & FLOW_DIR_REVERSED) != 0 { sp } else { dp };
if fsp == 445 && fdp != 445 {
unsafe {
if dir & STREAM_TOSERVER != 0 {
*rdir = STREAM_TOCLIENT;
} else {
*rdir = STREAM_TOSERVER;
}
if dir & STREAM_TOSERVER != 0 {
*rdir = STREAM_TOCLIENT;
} else {
*rdir = STREAM_TOSERVER;
}
}
return unsafe { ALPROTO_SMB };
return ALPROTO_SMB;
}
fn register_pattern_probe() -> i8 {

30
rust/src/snmp/detect.rs
Unescape Escape View File

@ -20,43 +20,37 @@
use crate::snmp::snmp::SNMPTransaction;
#[no_mangle]
pub extern "C" fn rs_snmp_tx_get_version(tx: &mut SNMPTransaction,
pub unsafe extern "C" fn rs_snmp_tx_get_version(tx: &mut SNMPTransaction,
version: *mut u32)
{
debug_assert!(tx.version != 0, "SNMP version is 0");
unsafe {
*version = tx.version as u32;
}
*version = tx.version as u32;
}
#[no_mangle]
pub extern "C" fn rs_snmp_tx_get_community(tx: &mut SNMPTransaction,
pub unsafe extern "C" fn rs_snmp_tx_get_community(tx: &mut SNMPTransaction,
buf: *mut *const u8,
len: *mut u32)
{
match tx.community {
Some(ref c) => {
unsafe {
*buf = (&c).as_ptr();
*len = c.len() as u32;
}
*buf = (&c).as_ptr();
*len = c.len() as u32;
},
None => ()
}
}
#[no_mangle]
pub extern "C" fn rs_snmp_tx_get_pdu_type(tx: &mut SNMPTransaction,
pub unsafe extern "C" fn rs_snmp_tx_get_pdu_type(tx: &mut SNMPTransaction,
pdu_type: *mut u32)
{
unsafe {
match tx.info {
Some(ref info) => {
*pdu_type = info.pdu_type.0 as u32;
},
None => {
*pdu_type = 0xffffffff;
}
match tx.info {
Some(ref info) => {
*pdu_type = info.pdu_type.0 as u32;
},
None => {
*pdu_type = 0xffffffff;
}
}
}

44
rust/src/snmp/snmp.rs
Unescape Escape View File

@ -311,7 +311,7 @@ pub extern "C" fn rs_snmp_state_free(state: *mut std::os::raw::c_void) {
}
#[no_mangle]
pub extern "C" fn rs_snmp_parse_request(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_snmp_parse_request(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -324,7 +324,7 @@ pub extern "C" fn rs_snmp_parse_request(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_snmp_parse_response(_flow: *const core::Flow,
pub unsafe extern "C" fn rs_snmp_parse_response(_flow: *const core::Flow,
state: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void,
input: *const u8,
@ -337,7 +337,7 @@ pub extern "C" fn rs_snmp_parse_response(_flow: *const core::Flow,
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_get_tx(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_snmp_state_get_tx(state: *mut std::os::raw::c_void,
tx_id: u64)
-> *mut std::os::raw::c_void
{
@ -349,7 +349,7 @@ pub extern "C" fn rs_snmp_state_get_tx(state: *mut std::os::raw::c_void,
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_get_tx_count(state: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_snmp_state_get_tx_count(state: *mut std::os::raw::c_void)
-> u64
{
let state = cast_pointer!(state,SNMPState);
@ -357,7 +357,7 @@ pub extern "C" fn rs_snmp_state_get_tx_count(state: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_tx_free(state: *mut std::os::raw::c_void,
pub unsafe extern "C" fn rs_snmp_state_tx_free(state: *mut std::os::raw::c_void,
tx_id: u64)
{
let state = cast_pointer!(state,SNMPState);
@ -373,7 +373,7 @@ pub extern "C" fn rs_snmp_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_set_tx_detect_state(
pub unsafe extern "C" fn rs_snmp_state_set_tx_detect_state(
tx: *mut std::os::raw::c_void,
de_state: &mut core::DetectEngineState) -> std::os::raw::c_int
{
@ -383,7 +383,7 @@ pub extern "C" fn rs_snmp_state_set_tx_detect_state(
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_get_tx_detect_state(
pub unsafe extern "C" fn rs_snmp_state_get_tx_detect_state(
tx: *mut std::os::raw::c_void)
-> *mut core::DetectEngineState
{
@ -396,7 +396,7 @@ pub extern "C" fn rs_snmp_state_get_tx_detect_state(
#[no_mangle]
pub extern "C" fn rs_snmp_state_get_events(tx: *mut std::os::raw::c_void)
pub unsafe extern "C" fn rs_snmp_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
{
let tx = cast_pointer!(tx, SNMPTransaction);
@ -404,7 +404,7 @@ pub extern "C" fn rs_snmp_state_get_events(tx: *mut std::os::raw::c_void)
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_get_event_info_by_id(event_id: std::os::raw::c_int,
pub unsafe extern "C" fn rs_snmp_state_get_event_info_by_id(event_id: std::os::raw::c_int,
event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType)
-> i8
@ -415,10 +415,8 @@ pub extern "C" fn rs_snmp_state_get_event_info_by_id(event_id: std::os::raw::c_i
SNMPEvent::UnknownSecurityModel => { "unknown_security_model\0" },
SNMPEvent::VersionMismatch => { "version_mismatch\0" },
};
unsafe{
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -426,13 +424,13 @@ pub extern "C" fn rs_snmp_state_get_event_info_by_id(event_id: std::os::raw::c_i
}
#[no_mangle]
pub extern "C" fn rs_snmp_state_get_event_info(event_name: *const std::os::raw::c_char,
pub unsafe extern "C" fn rs_snmp_state_get_event_info(event_name: *const std::os::raw::c_char,
event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType)
-> std::os::raw::c_int
{
if event_name == std::ptr::null() { return -1; }
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -444,10 +442,8 @@ pub extern "C" fn rs_snmp_state_get_event_info(event_name: *const std::os::raw::
},
Err(_) => -1, // UTF-8 conversion failed
};
unsafe{
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
@ -473,7 +469,7 @@ pub extern "C" fn rs_snmp_state_get_tx_iterator(
// for use with the C API call StateGetTxIterator
#[no_mangle]
pub extern "C" fn rs_snmp_get_tx_iterator(_ipproto: u8,
pub unsafe extern "C" fn rs_snmp_get_tx_iterator(_ipproto: u8,
_alproto: AppProto,
alstate: *mut std::os::raw::c_void,
min_tx_id: u64,
@ -524,18 +520,18 @@ fn parse_pdu_enveloppe_version(i:&[u8]) -> IResult<&[u8],u32> {
}
#[no_mangle]
pub extern "C" fn rs_snmp_probing_parser(_flow: *const Flow,
pub unsafe extern "C" fn rs_snmp_probing_parser(_flow: *const Flow,
_direction: u8,
input:*const u8,
input_len: u32,
_rdir: *mut u8) -> AppProto {
let slice = build_slice!(input,input_len as usize);
let alproto = unsafe{ ALPROTO_SNMP };
if slice.len() < 4 { return unsafe{ALPROTO_FAILED}; }
let alproto = ALPROTO_SNMP;
if slice.len() < 4 { return ALPROTO_FAILED; }
match parse_pdu_enveloppe_version(slice) {
Ok((_,_)) => alproto,
Err(nom::Err::Incomplete(_)) => ALPROTO_UNKNOWN,
_ => unsafe{ALPROTO_FAILED},
_ => ALPROTO_FAILED,
}
}

80
rust/src/ssh/detect.rs
Unescape Escape View File

@ -20,7 +20,7 @@ use crate::core::{STREAM_TOCLIENT, STREAM_TOSERVER};
use std::ptr;
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_protocol(
pub unsafe extern "C" fn rs_ssh_tx_get_protocol(
tx: *mut std::os::raw::c_void, buffer: *mut *const u8, buffer_len: *mut u32, direction: u8,
) -> u8 {
let tx = cast_pointer!(tx, SSHTransaction);
@ -28,35 +28,29 @@ pub extern "C" fn rs_ssh_tx_get_protocol(
STREAM_TOSERVER => {
let m = &tx.cli_hdr.protover;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
STREAM_TOCLIENT => {
let m = &tx.srv_hdr.protover;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
_ => {}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_software(
pub unsafe extern "C" fn rs_ssh_tx_get_software(
tx: *mut std::os::raw::c_void, buffer: *mut *const u8, buffer_len: *mut u32, direction: u8,
) -> u8 {
let tx = cast_pointer!(tx, SSHTransaction);
@ -64,35 +58,29 @@ pub extern "C" fn rs_ssh_tx_get_software(
STREAM_TOSERVER => {
let m = &tx.cli_hdr.swver;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
STREAM_TOCLIENT => {
let m = &tx.srv_hdr.swver;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
_ => {}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_hassh(
pub unsafe extern "C" fn rs_ssh_tx_get_hassh(
tx: *mut std::os::raw::c_void,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -103,35 +91,29 @@ pub extern "C" fn rs_ssh_tx_get_hassh(
STREAM_TOSERVER => {
let m = &tx.cli_hdr.hassh;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
STREAM_TOCLIENT => {
let m = &tx.srv_hdr.hassh;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
_ => {}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_hassh_string(
pub unsafe extern "C" fn rs_ssh_tx_get_hassh_string(
tx: *mut std::os::raw::c_void,
buffer: *mut *const u8,
buffer_len: *mut u32,
@ -142,29 +124,23 @@ pub extern "C" fn rs_ssh_tx_get_hassh_string(
STREAM_TOSERVER => {
let m = &tx.cli_hdr.hassh_string;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
STREAM_TOCLIENT => {
let m = &tx.srv_hdr.hassh_string;
if m.len() > 0 {
unsafe {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
}
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
}
_ => {}
}
unsafe {
*buffer = ptr::null();
*buffer_len = 0;
}
*buffer = ptr::null();
*buffer_len = 0;
return 0;
}

2
rust/src/ssh/logger.rs
Unescape Escape View File

@ -62,7 +62,7 @@ fn log_ssh(tx: &SSHTransaction, js: &mut JsonBuilder) -> Result<bool, JsonError>
}
#[no_mangle]
pub extern "C" fn rs_ssh_log_json(tx: *mut std::os::raw::c_void, js: &mut JsonBuilder) -> bool {
pub unsafe extern "C" fn rs_ssh_log_json(tx: *mut std::os::raw::c_void, js: &mut JsonBuilder) -> bool {
let tx = cast_pointer!(tx, SSHTransaction);
if let Ok(x) = log_ssh(tx, js) {
return x;

36
rust/src/ssh/ssh.rs
Unescape Escape View File

@ -369,7 +369,7 @@ export_tx_set_detect_state!(rs_ssh_tx_set_detect_state, SSHTransaction);
export_tx_data_get!(rs_ssh_get_tx_data, SSHTransaction);
#[no_mangle]
pub extern "C" fn rs_ssh_state_get_events(
pub unsafe extern "C" fn rs_ssh_state_get_events(
tx: *mut std::os::raw::c_void,
) -> *mut core::AppLayerDecoderEvents {
let tx = cast_pointer!(tx, SSHTransaction);
@ -377,14 +377,14 @@ pub extern "C" fn rs_ssh_state_get_events(
}
#[no_mangle]
pub extern "C" fn rs_ssh_state_get_event_info(
pub unsafe extern "C" fn rs_ssh_state_get_event_info(
event_name: *const std::os::raw::c_char, event_id: *mut std::os::raw::c_int,
event_type: *mut core::AppLayerEventType,
) -> std::os::raw::c_int {
if event_name == std::ptr::null() {
return -1;
}
let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
let c_event_name: &CStr = CStr::from_ptr(event_name);
let event = match c_event_name.to_str() {
Ok(s) => {
match s {
@ -397,15 +397,13 @@ pub extern "C" fn rs_ssh_state_get_event_info(
}
Err(_) => -1, // UTF-8 conversion failed
};
unsafe {
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
};
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
*event_id = event as std::os::raw::c_int;
0
}
#[no_mangle]
pub extern "C" fn rs_ssh_state_get_event_info_by_id(
pub unsafe extern "C" fn rs_ssh_state_get_event_info_by_id(
event_id: std::os::raw::c_int, event_name: *mut *const std::os::raw::c_char,
event_type: *mut core::AppLayerEventType,
) -> i8 {
@ -416,10 +414,8 @@ pub extern "C" fn rs_ssh_state_get_event_info_by_id(
SSHEvent::InvalidRecord => "invalid_record\0",
SSHEvent::LongKexRecord => "long_kex_record\0",
};
unsafe {
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
};
*event_name = estr.as_ptr() as *const std::os::raw::c_char;
*event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
0
} else {
-1
@ -434,8 +430,8 @@ pub extern "C" fn rs_ssh_state_new(_orig_state: *mut std::os::raw::c_void, _orig
}
#[no_mangle]
pub extern "C" fn rs_ssh_state_free(state: *mut std::os::raw::c_void) {
std::mem::drop(unsafe { Box::from_raw(state as *mut SSHState) });
pub unsafe extern "C" fn rs_ssh_state_free(state: *mut std::os::raw::c_void) {
std::mem::drop(Box::from_raw(state as *mut SSHState));
}
#[no_mangle]
@ -444,7 +440,7 @@ pub extern "C" fn rs_ssh_state_tx_free(_state: *mut std::os::raw::c_void, _tx_id
}
#[no_mangle]
pub extern "C" fn rs_ssh_parse_request(
pub unsafe extern "C" fn rs_ssh_parse_request(
_flow: *const Flow, state: *mut std::os::raw::c_void, pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
@ -459,7 +455,7 @@ pub extern "C" fn rs_ssh_parse_request(
}
#[no_mangle]
pub extern "C" fn rs_ssh_parse_response(
pub unsafe extern "C" fn rs_ssh_parse_response(
_flow: *const Flow, state: *mut std::os::raw::c_void, pstate: *mut std::os::raw::c_void,
input: *const u8, input_len: u32, _data: *const std::os::raw::c_void, _flags: u8,
) -> AppLayerResult {
@ -474,7 +470,7 @@ pub extern "C" fn rs_ssh_parse_response(
}
#[no_mangle]
pub extern "C" fn rs_ssh_state_get_tx(
pub unsafe extern "C" fn rs_ssh_state_get_tx(
state: *mut std::os::raw::c_void, _tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, SSHState);
@ -487,7 +483,7 @@ pub extern "C" fn rs_ssh_state_get_tx_count(_state: *mut std::os::raw::c_void) -
}
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_flags(
pub unsafe extern "C" fn rs_ssh_tx_get_flags(
tx: *mut std::os::raw::c_void, direction: u8,
) -> SSHConnectionState {
let tx = cast_pointer!(tx, SSHTransaction);
@ -499,7 +495,7 @@ pub extern "C" fn rs_ssh_tx_get_flags(
}
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_alstate_progress(
pub unsafe extern "C" fn rs_ssh_tx_get_alstate_progress(
tx: *mut std::os::raw::c_void, direction: u8,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, SSHTransaction);
@ -588,7 +584,7 @@ pub extern "C" fn rs_ssh_hassh_is_enabled() -> bool {
}
#[no_mangle]
pub extern "C" fn rs_ssh_tx_get_log_condition( tx: *mut std::os::raw::c_void) -> bool {
pub unsafe extern "C" fn rs_ssh_tx_get_log_condition( tx: *mut std::os::raw::c_void) -> bool {
let tx = cast_pointer!(tx, SSHTransaction);
if rs_ssh_hassh_is_enabled() {

6
rust/src/tftp/tftp.rs
Unescape Escape View File

@ -153,10 +153,10 @@ fn parse_tftp_request(input: &[u8]) -> Option<TFTPTransaction> {
}
#[no_mangle]
pub extern "C" fn rs_tftp_request(state: &mut TFTPState,
pub unsafe extern "C" fn rs_tftp_request(state: &mut TFTPState,
input: *const u8,
len: u32) -> i64 {
let buf = unsafe{std::slice::from_raw_parts(input, len as usize)};
let buf = std::slice::from_raw_parts(input, len as usize);
match parse_tftp_request(buf) {
Some(mut tx) => {
state.tx_id += 1;
@ -171,7 +171,7 @@ pub extern "C" fn rs_tftp_request(state: &mut TFTPState,
}
#[no_mangle]
pub extern "C" fn rs_tftp_get_tx_data(
pub unsafe extern "C" fn rs_tftp_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
{

6
rust/src/x509/mod.rs
Unescape Escape View File

@ -66,7 +66,7 @@ pub unsafe extern "C" fn rs_x509_decode(
}
#[no_mangle]
pub extern "C" fn rs_x509_get_subject(ptr: *const X509) -> *mut c_char {
pub unsafe extern "C" fn rs_x509_get_subject(ptr: *const X509) -> *mut c_char {
if ptr.is_null() {
return std::ptr::null_mut();
}
@ -76,7 +76,7 @@ pub extern "C" fn rs_x509_get_subject(ptr: *const X509) -> *mut c_char {
}
#[no_mangle]
pub extern "C" fn rs_x509_get_issuer(ptr: *const X509) -> *mut c_char {
pub unsafe extern "C" fn rs_x509_get_issuer(ptr: *const X509) -> *mut c_char {
if ptr.is_null() {
return std::ptr::null_mut();
}
@ -86,7 +86,7 @@ pub extern "C" fn rs_x509_get_issuer(ptr: *const X509) -> *mut c_char {
}
#[no_mangle]
pub extern "C" fn rs_x509_get_serial(ptr: *const X509) -> *mut c_char {
pub unsafe extern "C" fn rs_x509_get_serial(ptr: *const X509) -> *mut c_char {
if ptr.is_null() {
return std::ptr::null_mut();
}

Write Preview
Loading…
Cancel
Save