/// 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
/// 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,
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,
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);
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);
}
#[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()
}
/// 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,
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;
}
#[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,
) {
}
#[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,
_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 {
}
#[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,
_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);
}
#[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 {
}
#[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);
}
#[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 {
}
#[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);
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,
/// 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,
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;
}
}
/// 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,
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;
}
}
/// 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() {
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);
}
#[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 {
}
#[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 {
}
#[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;
}
#[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);
}
#[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);
}
#[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);
}
#[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 {
}
#[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
{
}
}
-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 {
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 {
}
#[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 {
}
#[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);
}
#[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);
}
#[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);
}
#[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
{
}
#[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);
}
#[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
}
}
}
-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 {
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 {
}
#[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,
let slice = build_slice!(input, input_len as usize);
match parse_header(slice) {
Ok((_, _)) => {
- return unsafe { ALPROTO_DHCP };
+ return ALPROTO_DHCP;
}
_ => {
return ALPROTO_UNKNOWN;
}
#[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) {
}
#[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,
}
#[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)
{
}
#[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
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);
}
#[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)
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 {
},
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,
}
#[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);
}
#[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);
}
#[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
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;
}
#[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);
/// 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,
_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 {
}
#[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,
_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 {
/// 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,
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);
}
#[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,
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);
}
#[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);
}
#[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
{
}
#[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
{
}
#[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
{
}
#[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);
}
#[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
{
}
#[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)
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;
}
}
}
#[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
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;
}
}
}
#[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,
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 {
} 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,
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 {
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
) {
#[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)) => {
#[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;
);
#[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)) => {
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;
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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)
}
}
#[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);
/// 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() {
|| 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 ;
}
}
}
);
}
+// 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 {
}
#[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);
}
#[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);
}
#[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 {
}
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 {
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 {
}
#[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);
}
#[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;
/// 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]
}
#[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 {
}
#[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 {
}
#[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);
}
#[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;
}
}
#[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);
}
#[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);
}
#[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);
}
#[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 {
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
}
#[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 {
}
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 {
}
#[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);
}
#[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
{
}
#[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);
}
#[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);
}
#[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
{
}
#[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
{
}
#[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
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
}
#[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);
}
#[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 {
},
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 {
}
}
}
- 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);
},
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,
}
#[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,
}
#[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,
}
#[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,
}
#[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();
}
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);
}
#[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);
}
#[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);
}
#[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 {
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
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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);
}
#[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;
}
#[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,
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,
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,
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,
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,
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;
}
}
}
#[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,
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,
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)
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 {
}
}
- 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)
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 {
}
}
- 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 {
| 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;
}
}
});
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);
}
});
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);
}
}
}
#[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()
}
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,
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
}
}
}
#[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,
}
#[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,
}
#[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 {
}
#[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;
}
#[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 {
}
#[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 {
}
#[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,
}
#[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);
}
#[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
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
}
#[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 {
},
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,
/// 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,
{
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());
}
#[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,
{
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)
/// 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,
_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,
_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);
}
#[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
{
// 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,
}
#[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);
}
#[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
{
}
#[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
{
}
#[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
{
}
#[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
{
}
#[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);
}
#[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
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
#[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
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 {
},
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
}
/// 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;
}
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;
}
}
}
#[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 {
/// 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
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,
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,
{
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,
{
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)
}
}
#[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,
}
#[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,
}
#[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
{
}
#[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);
}
#[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);
}
#[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
{
}
#[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
{
}
#[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
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
}
#[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);
}
#[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 {
},
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_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);
}
#[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;
}
}
#[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);
}
/// 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() {
// 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;
//
#[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 {
}
#[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 {
}
#[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);
}
#[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,
) {
}
#[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,
}
#[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,
}
#[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 {
}
#[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);
}
#[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 {
}
#[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);
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,
}
#[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 {
}
#[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);
}
}
#[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 {
}
#[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);
}
#[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);
}
#[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,
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 {
}
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,
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
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,
) -> 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,
) -> 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,
}
#[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,
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
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
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)
&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;
}
}
#[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)
}
/// 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,
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);
#[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,
{
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) {
// 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
{
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() &&
Ok((_, ref hdr2)) => {
if hdr2.is_smb() {
SCLogDebug!("smb found");
- return unsafe { ALPROTO_SMB };
+ return ALPROTO_SMB;
}
}
_ => {}
_ => { },
}
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);
}
#[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
{
// 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,
}
#[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);
}
#[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
{
#[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
{
}
#[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
{
}
#[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
{
}
#[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)
{
}
#[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);
}
#[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
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
}
#[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
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();
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 {
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;
}
}
}
}
#[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,
}
#[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,
}
#[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
{
}
#[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);
}
#[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);
}
#[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
{
}
#[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
{
#[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);
}
#[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
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
}
#[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 {
},
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
}
// 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,
}
#[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,
}
}
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);
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);
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,
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,
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;
}
}
#[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;
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);
}
#[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 {
}
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 {
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
}
#[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]
}
#[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 {
}
#[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 {
}
#[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);
}
#[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);
}
#[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);
}
#[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() {
}
#[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;
}
#[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
{
}
#[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();
}
}
#[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();
}
}
#[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();
}
projects / people / ms / suricata.git / commitdiff
