}
#[repr(C)]
-#[derive(Default, Debug,PartialEq)]
+#[derive(Debug, PartialEq)]
pub struct AppLayerTxData {
/// config: log flags
pub config: AppLayerTxConfig,
/// detection engine flags for use by detection engine
detect_flags_ts: u64,
detect_flags_tc: u64,
+
+ de_state: *mut DetectEngineState,
+}
+
+impl Default for AppLayerTxData {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl Drop for AppLayerTxData {
+ fn drop(&mut self) {
+ if self.de_state != std::ptr::null_mut() {
+ core::sc_detect_engine_state_free(self.de_state);
+ }
+ }
}
impl AppLayerTxData {
files_stored: 0,
detect_flags_ts: 0,
detect_flags_tc: 0,
+ de_state: std::ptr::null_mut(),
}
}
pub fn init_files_opened(&mut self) {
/// Function returning the current transaction progress
pub tx_get_progress: StateGetProgressFn,
- /// Function called to get a detection state
- pub get_de_state: GetDetectStateFn,
- /// Function called to set a detection state
- pub set_de_state: SetDetectStateFn,
-
/// Function to get events
pub get_events: Option<GetEventsFn>,
/// Function to get an event id from a description
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;
}
-/// Export a function to get the DetectEngineState on a struct.
-#[macro_export]
-macro_rules!export_tx_get_detect_state {
- ($name:ident, $type:ty) => (
- #[no_mangle]
- pub unsafe extern "C" fn $name(tx: *mut std::os::raw::c_void)
- -> *mut core::DetectEngineState
- {
- let tx = cast_pointer!(tx, $type);
- match tx.de_state {
- Some(ds) => {
- return ds;
- },
- None => {
- return std::ptr::null_mut();
- }
- }
- }
- )
-}
-
-/// Export a function to set the DetectEngineState on a struct.
-#[macro_export]
-macro_rules!export_tx_set_detect_state {
- ($name:ident, $type:ty) => (
- #[no_mangle]
- 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);
- tx.de_state = Some(de_state);
- 0
- }
- )
-}
-
/// AppLayerEvent trait that will be implemented on enums that
/// derive AppLayerEvent.
pub trait AppLayerEvent {
// C exports.
-export_tx_get_detect_state!(
- rs_template_tx_get_detect_state,
- TemplateTransaction
-);
-export_tx_set_detect_state!(
- rs_template_tx_set_detect_state,
- TemplateTransaction
-);
-
/// C entry point for a probing parser.
#[no_mangle]
pub unsafe extern "C" fn rs_template_probing_parser(
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_template_tx_get_alstate_progress,
- get_de_state: rs_template_tx_get_detect_state,
- set_de_state: rs_template_tx_set_detect_state,
get_events: Some(rs_template_state_get_events),
get_eventinfo: Some(TemplateEvent::get_event_info),
get_eventinfo_byid : Some(TemplateEvent::get_event_info_by_id),
pub activityuuid: Vec<u8>,
pub seqnum: u32,
pub tx_data: AppLayerTxData,
- pub de_state: Option<*mut core::DetectEngineState>,
}
impl DCERPCTransaction {
resp_cmd: DCERPC_TYPE_RESPONSE,
activityuuid: Vec::new(),
tx_data: AppLayerTxData::new(),
- de_state: None,
..Default::default()
}
}
- pub fn free(&mut self) {
- match self.de_state {
- Some(state) => {
- sc_detect_engine_state_free(state);
- }
- _ => {}
- }
- }
-
pub fn get_req_ctxid(&self) -> u16 {
self.ctxid
}
}
}
-impl Drop for DCERPCTransaction {
- fn drop(&mut self) {
- self.free();
- }
-}
-
#[derive(Debug)]
pub struct DCERPCRequest {
pub ctxid: u16,
}
}
-#[no_mangle]
-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);
- match dce_tx.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
-#[no_mangle]
-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);
- dce_tx.de_state = Some(de_state);
- 0
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_dcerpc_get_tx(
vtx: *mut std::os::raw::c_void, tx_id: u64,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_dcerpc_get_alstate_progress,
- get_de_state: rs_dcerpc_get_tx_detect_state,
- set_de_state: rs_dcerpc_set_tx_detect_state,
get_events: None,
get_eventinfo: None,
get_eventinfo_byid : None,
dce_state.free_tx(tx_id);
}
-#[no_mangle]
-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);
- match dce_state.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
-#[no_mangle]
-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);
- dce_state.de_state = Some(de_state);
- 0
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_dcerpc_udp_get_tx_data(
tx: *mut std::os::raw::c_void)
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_dcerpc_get_alstate_progress,
- get_de_state: rs_dcerpc_udp_get_tx_detect_state,
- set_de_state: rs_dcerpc_udp_set_tx_detect_state,
get_events: None,
get_eventinfo: None,
get_eventinfo_byid: None,
use crate::applayer::{self, *};
use crate::core;
use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_UDP};
-use crate::core::{sc_detect_engine_state_free, sc_app_layer_decoder_events_free_events};
+use crate::core::sc_app_layer_decoder_events_free_events;
use crate::dhcp::parser::*;
use std;
use std::ffi::CString;
pub struct DHCPTransaction {
tx_id: u64,
pub message: DHCPMessage,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
DHCPTransaction {
tx_id: id,
message: message,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
if !self.events.is_null() {
sc_app_layer_decoder_events_free_events(&mut self.events);
}
- match self.de_state {
- Some(state) => {
- sc_detect_engine_state_free(state);
- }
- _ => {}
- }
}
}
}
}
-export_tx_get_detect_state!(rs_dhcp_tx_get_detect_state, DHCPTransaction);
-export_tx_set_detect_state!(rs_dhcp_tx_set_detect_state, DHCPTransaction);
-
#[derive(Default)]
pub struct DHCPState {
// Internal transaction ID.
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_dhcp_tx_get_alstate_progress,
- get_de_state : rs_dhcp_tx_get_detect_state,
- set_de_state : rs_dhcp_tx_set_detect_state,
get_events : Some(rs_dhcp_state_get_events),
get_eventinfo : Some(DHCPEvent::get_event_info),
get_eventinfo_byid : Some(DHCPEvent::get_event_info_by_id),
pub id: u64,
pub request: Option<DNSRequest>,
pub response: Option<DNSResponse>,
- pub de_state: Option<*mut core::DetectEngineState>,
pub events: *mut core::AppLayerDecoderEvents,
pub tx_data: AppLayerTxData,
}
id: 0,
request: None,
response: None,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- match self.de_state {
- Some(state) => {
- core::sc_detect_engine_state_free(state);
- }
- None => { },
- }
}
/// Get the DNS transactions ID (not the internal tracking ID).
tx.response.is_some()
}
-#[no_mangle]
-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
-{
- let tx = cast_pointer!(tx, DNSTransaction);
- tx.de_state = Some(de_state);
- return 0;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn rs_dns_state_get_tx_detect_state(
- tx: *mut std::os::raw::c_void)
- -> *mut core::DetectEngineState
-{
- let tx = cast_pointer!(tx, DNSTransaction);
- match tx.de_state {
- Some(ds) => {
- return ds;
- },
- None => {
- return std::ptr::null_mut();
- }
- }
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_dns_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
return tx.events;
}
-#[no_mangle]
pub unsafe extern "C" fn rs_dns_state_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
localstorage_free: None,
get_files: None,
get_tx_iterator: Some(crate::applayer::state_get_tx_iterator::<DNSState, DNSTransaction>),
- get_de_state: rs_dns_state_get_tx_detect_state,
- set_de_state: rs_dns_state_set_tx_detect_state,
get_tx_data: rs_dns_state_get_tx_data,
apply_tx_config: Some(rs_dns_apply_tx_config),
flags: APP_LAYER_PARSER_OPT_UNIDIR_TXS,
localstorage_free: None,
get_files: None,
get_tx_iterator: Some(crate::applayer::state_get_tx_iterator::<DNSState, DNSTransaction>),
- get_de_state: rs_dns_state_get_tx_detect_state,
- set_de_state: rs_dns_state_set_tx_detect_state,
get_tx_data: rs_dns_state_get_tx_data,
apply_tx_config: Some(rs_dns_apply_tx_config),
flags: APP_LAYER_PARSER_OPT_ACCEPT_GAPS | APP_LAYER_PARSER_OPT_UNIDIR_TXS,
decoder: decompression::HTTP2Decoder,
pub file_range: *mut HttpRangeContainerBlock,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: AppLayerTxData,
pub ft_tc: FileTransferTracker,
frames_ts: Vec::new(),
decoder: decompression::HTTP2Decoder::new(),
file_range: std::ptr::null_mut(),
- de_state: None,
events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
ft_tc: FileTransferTracker::new(),
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- core::sc_detect_engine_state_free(state);
- }
if !self.file_range.is_null() {
match unsafe { SC } {
None => panic!("BUG no suricata_config"),
// C exports.
-export_tx_get_detect_state!(rs_http2_tx_get_detect_state, HTTP2Transaction);
-export_tx_set_detect_state!(rs_http2_tx_set_detect_state, HTTP2Transaction);
-
export_tx_data_get!(rs_http2_get_tx_data, HTTP2Transaction);
/// C entry point for a probing parser.
tx_comp_st_ts: HTTP2TransactionState::HTTP2StateClosed as i32,
tx_comp_st_tc: HTTP2TransactionState::HTTP2StateClosed as i32,
tx_get_progress: rs_http2_tx_get_alstate_progress,
- get_de_state: rs_http2_tx_get_detect_state,
- set_de_state: rs_http2_tx_set_detect_state,
get_events: Some(rs_http2_state_get_events),
get_eventinfo: Some(HTTP2Event::get_event_info),
get_eventinfo_byid: Some(HTTP2Event::get_event_info_by_id),
pub errors: u32,
logged: LoggerFlags,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
payload_types: Default::default(),
notify_types: vec![],
logged: LoggerFlags::new(),
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
errors: 0,
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- core::sc_detect_engine_state_free(state);
- }
}
/// Set an event.
}
// C exports.
-export_tx_get_detect_state!(rs_ike_tx_get_detect_state, IKETransaction);
-export_tx_set_detect_state!(rs_ike_tx_set_detect_state, IKETransaction);
/// C entry point for a probing parser.
#[no_mangle]
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_ike_tx_get_alstate_progress,
- get_de_state : rs_ike_tx_get_detect_state,
- set_de_state : rs_ike_tx_set_detect_state,
get_events : Some(rs_ike_state_get_events),
get_eventinfo : Some(IkeEvent::get_event_info),
get_eventinfo_byid : Some(IkeEvent::get_event_info_by_id),
use kerberos_parser::krb5_parser;
use kerberos_parser::krb5::{EncryptionType,ErrorCode,MessageType,PrincipalName,Realm};
use crate::applayer::{self, *};
-use crate::core::{self, *};
+use crate::core;
+use crate::core::{AppProto,Flow,ALPROTO_FAILED,ALPROTO_UNKNOWN,Direction};
#[derive(AppLayerEvent)]
pub enum KRB5Event {
/// The internal transaction id
id: u64,
- /// The detection engine state, if present
- de_state: Option<*mut core::DetectEngineState>,
-
/// The events associated with this transaction
events: *mut core::AppLayerDecoderEvents,
etype: None,
error_code: None,
id: id,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- sc_detect_engine_state_free(state);
- }
}
}
1
}
-#[no_mangle]
-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
-{
- let tx = cast_pointer!(tx,KRB5Transaction);
- tx.de_state = Some(de_state);
- 0
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn rs_krb5_state_get_tx_detect_state(
- tx: *mut std::os::raw::c_void)
- -> *mut core::DetectEngineState
-{
- let tx = cast_pointer!(tx,KRB5Transaction);
- match tx.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_krb5_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_krb5_tx_get_alstate_progress,
- get_de_state : rs_krb5_state_get_tx_detect_state,
- set_de_state : rs_krb5_state_set_tx_detect_state,
get_events : Some(rs_krb5_state_get_events),
get_eventinfo : Some(KRB5Event::get_event_info),
get_eventinfo_byid : Some(KRB5Event::get_event_info_by_id),
pub response: Option<Message>,
pub events: *mut core::AppLayerDecoderEvents,
- pub de_state: Option<*mut core::DetectEngineState>,
pub tx_data: AppLayerTxData,
}
request: None,
response: None,
events: std::ptr::null_mut(),
- de_state: None,
tx_data: AppLayerTxData::new(),
}
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
-
- if let Some(state) = self.de_state {
- core::sc_detect_engine_state_free(state);
- }
}
}
tx.events
}
-#[no_mangle]
-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);
- match tx.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
-#[no_mangle]
-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);
- tx.de_state = Some(de_state);
- 0
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_modbus_state_get_tx_data(
tx: *mut std::os::raw::c_void,
localstorage_free: None,
get_files: None,
get_tx_iterator: Some(applayer::state_get_tx_iterator::<ModbusState, ModbusTransaction>),
- get_de_state: rs_modbus_state_get_tx_detect_state,
- set_de_state: rs_modbus_state_set_tx_detect_state,
get_tx_data: rs_modbus_state_get_tx_data,
apply_tx_config: None,
flags: 0,
toserver: bool,
logged: LoggerFlags,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
msg: Vec::new(),
toclient: false,
toserver: false,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
};
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- core::sc_detect_engine_state_free(state);
- }
}
}
// C exports.
-export_tx_get_detect_state!(rs_mqtt_tx_get_detect_state, MQTTTransaction);
-export_tx_set_detect_state!(rs_mqtt_tx_set_detect_state, MQTTTransaction);
-
#[no_mangle]
pub unsafe extern "C" fn rs_mqtt_probing_parser(
_flow: *const Flow,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_mqtt_tx_get_alstate_progress,
- get_de_state: rs_mqtt_tx_get_detect_state,
- set_de_state: rs_mqtt_tx_set_detect_state,
get_events: Some(rs_mqtt_state_get_events),
get_eventinfo: Some(MQTTEvent::get_event_info),
get_eventinfo_byid: Some(MQTTEvent::get_event_info_by_id),
/// attempt failed.
pub type_data: Option<NFSTransactionTypeData>,
- pub de_state: Option<*mut DetectEngineState>,
pub events: *mut AppLayerDecoderEvents,
pub tx_data: AppLayerTxData,
file_tx_direction: Direction::ToServer,
file_handle:Vec::new(),
type_data: None,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
if !self.events.is_null() {
sc_app_layer_decoder_events_free_events(&mut self.events);
}
- match self.de_state {
- Some(state) => {
- sc_detect_engine_state_free(state);
- }
- _ => {}
- }
}
}
return &mut tx.tx_data;
}
-#[no_mangle]
-pub unsafe extern "C" fn rs_nfs_state_set_tx_detect_state(
- tx: *mut std::os::raw::c_void,
- de_state: &mut DetectEngineState) -> i32
-{
- let tx = cast_pointer!(tx, NFSTransaction);
- tx.de_state = Some(de_state);
- 0
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn rs_nfs_state_get_tx_detect_state(
- tx: *mut std::os::raw::c_void)
- -> *mut DetectEngineState
-{
- let tx = cast_pointer!(tx, NFSTransaction);
- match tx.de_state {
- Some(ds) => {
- SCLogDebug!("{}: getting de_state", tx.id);
- return ds;
- },
- None => {
- SCLogDebug!("{}: getting de_state: have none", tx.id);
- return std::ptr::null_mut();
- }
- }
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_nfs_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut AppLayerDecoderEvents
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_nfs_tx_get_alstate_progress,
- get_de_state: rs_nfs_state_get_tx_detect_state,
- set_de_state: rs_nfs_state_set_tx_detect_state,
get_events: Some(rs_nfs_state_get_events),
get_eventinfo: Some(rs_nfs_state_get_event_info),
get_eventinfo_byid : Some(rs_nfs_state_get_event_info_by_id),
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_nfs_tx_get_alstate_progress,
- get_de_state: rs_nfs_state_get_tx_detect_state,
- set_de_state: rs_nfs_state_set_tx_detect_state,
get_events: Some(rs_nfs_state_get_events),
get_eventinfo: Some(rs_nfs_state_get_event_info),
get_eventinfo_byid : None,
/// The internal transaction id
id: u64,
- /// The detection engine state, if present
- de_state: Option<*mut core::DetectEngineState>,
-
/// The events associated with this transaction
events: *mut core::AppLayerDecoderEvents,
NTPTransaction {
xid: 0,
id: id,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(de_state) = self.de_state {
- core::sc_detect_engine_state_free(de_state);
- }
}
}
1
}
-#[no_mangle]
-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
-{
- let tx = cast_pointer!(tx,NTPTransaction);
- tx.de_state = Some(de_state);
- 0
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn rs_ntp_state_get_tx_detect_state(
- tx: *mut std::os::raw::c_void)
- -> *mut core::DetectEngineState
-{
- let tx = cast_pointer!(tx,NTPTransaction);
- match tx.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_ntp_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_ntp_tx_get_alstate_progress,
- get_de_state : rs_ntp_state_get_tx_detect_state,
- set_de_state : rs_ntp_state_set_tx_detect_state,
get_events : Some(rs_ntp_state_get_events),
get_eventinfo : Some(NTPEvent::get_event_info),
get_eventinfo_byid : Some(NTPEvent::get_event_info_by_id),
//! RDP application layer
use crate::applayer::{self, *};
-use crate::core::{self, AppProto, DetectEngineState, Flow, ALPROTO_UNKNOWN, IPPROTO_TCP};
+use crate::core::{AppProto, Flow, ALPROTO_UNKNOWN, IPPROTO_TCP};
use crate::rdp::parser::*;
use nom;
use std;
pub id: u64,
pub item: RdpTransactionItem,
// managed by macros `export_tx_get_detect_state!` and `export_tx_set_detect_state!`
- de_state: Option<*mut DetectEngineState>,
tx_data: AppLayerTxData,
}
Self {
id,
item,
- de_state: None,
tx_data: AppLayerTxData::new(),
}
}
-
- fn free(&mut self) {
- if let Some(de_state) = self.de_state {
- core::sc_detect_engine_state_free(de_state);
- }
- }
-}
-
-impl Drop for RdpTransaction {
- fn drop(&mut self) {
- self.free();
- }
}
#[no_mangle]
state.free_tx(tx_id);
}
-//
-// detection state
-//
-
-export_tx_get_detect_state!(rs_rdp_tx_get_detect_state, RdpTransaction);
-export_tx_set_detect_state!(rs_rdp_tx_set_detect_state, RdpTransaction);
-
//
// probe
//
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_rdp_tx_get_progress,
- get_de_state: rs_rdp_tx_get_detect_state,
- set_de_state: rs_rdp_tx_set_detect_state,
get_events: None,
get_eventinfo: None,
get_eventinfo_byid: None,
pub tc_failure_reason: Option<parser::FailureReason>,
pub tc_server_init: Option<parser::ServerInit>,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
tc_failure_reason: None,
tc_server_init: None,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- core::sc_detect_engine_state_free(state);
- }
}
}
// C exports.
-export_tx_get_detect_state!(
- rs_rfb_tx_get_detect_state,
- RFBTransaction
-);
-export_tx_set_detect_state!(
- rs_rfb_tx_set_detect_state,
- RFBTransaction
-);
-
#[no_mangle]
pub extern "C" fn rs_rfb_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
let state = RFBState::new();
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_rfb_tx_get_alstate_progress,
- get_de_state: rs_rfb_tx_get_detect_state,
- set_de_state: rs_rfb_tx_set_detect_state,
get_events: Some(rs_rfb_state_get_events),
get_eventinfo: None,
get_eventinfo_byid: None,
use crate::applayer::{self, *};
use crate::core;
-use crate::core::{sc_detect_engine_state_free, AppProto, Flow, ALPROTO_UNKNOWN};
+use crate::core::{AppProto, Flow, ALPROTO_UNKNOWN};
use crate::sip::parser::*;
use nom7::Err;
use std;
pub response: Option<Response>,
pub request_line: Option<String>,
pub response_line: Option<String>,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
pub fn new(id: u64) -> SIPTransaction {
SIPTransaction {
id,
- de_state: None,
request: None,
response: None,
request_line: None,
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- sc_detect_engine_state_free(state);
- }
}
}
1
}
-#[no_mangle]
-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 {
- let tx = cast_pointer!(tx, SIPTransaction);
- tx.de_state = Some(de_state);
- 0
-}
-
-#[no_mangle]
-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);
- match tx.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_sip_state_get_events(
tx: *mut std::os::raw::c_void,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_sip_tx_get_alstate_progress,
- get_de_state: rs_sip_state_get_tx_detect_state,
- set_de_state: rs_sip_state_set_tx_detect_state,
get_events: Some(rs_sip_state_get_events),
get_eventinfo: Some(SIPEvent::get_event_info),
get_eventinfo_byid: Some(SIPEvent::get_event_info_by_id),
/// Command specific data
pub type_data: Option<SMBTransactionTypeData>,
- pub de_state: Option<*mut DetectEngineState>,
pub events: *mut AppLayerDecoderEvents,
pub tx_data: AppLayerTxData,
}
request_done: false,
response_done: false,
type_data: None,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
if !self.events.is_null() {
sc_app_layer_decoder_events_free_events(&mut self.events);
}
- match self.de_state {
- Some(state) => {
- sc_detect_engine_state_free(state);
- }
- _ => {}
- }
}
}
return &mut tx.tx_data;
}
-#[no_mangle]
-pub unsafe extern "C" fn rs_smb_state_get_tx_detect_state(
- tx: *mut std::os::raw::c_void)
- -> *mut DetectEngineState
-{
- let tx = cast_pointer!(tx, SMBTransaction);
- match tx.de_state {
- Some(ds) => {
- return ds;
- },
- None => {
- return std::ptr::null_mut();
- }
- }
-}
-
-#[no_mangle]
-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
-{
- let tx = cast_pointer!(tx, SMBTransaction);
- tx.de_state = Some(de_state);
- 0
-}
#[no_mangle]
pub unsafe extern "C" fn rs_smb_state_truncate(
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_smb_tx_get_alstate_progress,
- get_de_state: rs_smb_state_get_tx_detect_state,
- set_de_state: rs_smb_state_set_tx_detect_state,
get_events: Some(rs_smb_state_get_events),
get_eventinfo: Some(rs_smb_state_get_event_info),
get_eventinfo_byid : Some(rs_smb_state_get_event_info_by_id),
/// The internal transaction id
id: u64,
- /// The detection engine state, if present
- de_state: Option<*mut core::DetectEngineState>,
-
/// The events associated with this transaction
events: *mut core::AppLayerDecoderEvents,
usm: None,
encrypted: false,
id: id,
- de_state: None,
events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(de_state) = self.de_state {
- core::sc_detect_engine_state_free(de_state);
- }
}
}
1
}
-#[no_mangle]
-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
-{
- let tx = cast_pointer!(tx,SNMPTransaction);
- tx.de_state = Some(de_state);
- 0
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn rs_snmp_state_get_tx_detect_state(
- tx: *mut std::os::raw::c_void)
- -> *mut core::DetectEngineState
-{
- let tx = cast_pointer!(tx,SNMPTransaction);
- match tx.de_state {
- Some(ds) => ds,
- None => std::ptr::null_mut(),
- }
-}
-
-
#[no_mangle]
pub unsafe extern "C" fn rs_snmp_state_get_events(tx: *mut std::os::raw::c_void)
-> *mut core::AppLayerDecoderEvents
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_snmp_tx_get_alstate_progress,
- get_de_state : rs_snmp_state_get_tx_detect_state,
- set_de_state : rs_snmp_state_set_tx_detect_state,
get_events : Some(rs_snmp_state_get_events),
get_eventinfo : Some(SNMPEvent::get_event_info),
get_eventinfo_byid : Some(SNMPEvent::get_event_info_by_id),
pub srv_hdr: SshHeader,
pub cli_hdr: SshHeader,
- de_state: Option<*mut core::DetectEngineState>,
events: *mut core::AppLayerDecoderEvents,
tx_data: AppLayerTxData,
}
SSHTransaction {
srv_hdr: SshHeader::new(),
cli_hdr: SshHeader::new(),
- de_state: None,
events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
if !self.events.is_null() {
core::sc_app_layer_decoder_events_free_events(&mut self.events);
}
- if let Some(state) = self.de_state {
- core::sc_detect_engine_state_free(state);
- }
}
}
// C exports.
-export_tx_get_detect_state!(rs_ssh_tx_get_detect_state, SSHTransaction);
-export_tx_set_detect_state!(rs_ssh_tx_set_detect_state, SSHTransaction);
-
export_tx_data_get!(rs_ssh_get_tx_data, SSHTransaction);
#[no_mangle]
tx_comp_st_ts: SSHConnectionState::SshStateFinished as i32,
tx_comp_st_tc: SSHConnectionState::SshStateFinished as i32,
tx_get_progress: rs_ssh_tx_get_alstate_progress,
- get_de_state: rs_ssh_tx_get_detect_state,
- set_de_state: rs_ssh_tx_set_detect_state,
get_events: Some(rs_ssh_state_get_events),
get_eventinfo: Some(SSHEvent::get_event_info),
get_eventinfo_byid: Some(SSHEvent::get_event_info_by_id),
AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
- if (tx->de_state != NULL) {
- DetectEngineStateFree(tx->de_state);
+ if (tx->tx_data.de_state != NULL) {
+ DetectEngineStateFree(tx->tx_data.de_state);
}
DNP3TxFreeObjectList(&tx->request_objects);
return 0;
}
-/**
- * \brief App-layer support.
- */
-static DetectEngineState *DNP3GetTxDetectState(void *vtx)
-{
- DNP3Transaction *tx = vtx;
- return tx->de_state;
-}
-
-/**
- * \brief App-layer support.
- */
-static int DNP3SetTxDetectState(void *vtx, DetectEngineState *s)
-{
- DNP3Transaction *tx = vtx;
- tx->de_state = s;
- return 0;
-}
-
static AppLayerTxData *DNP3GetTxData(void *vtx)
{
DNP3Transaction *tx = (DNP3Transaction *)vtx;
AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_DNP3,
DNP3GetEvents);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_DNP3,
- DNP3GetTxDetectState, DNP3SetTxDetectState);
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_DNP3, DNP3GetTx);
AppLayerParserRegisterGetTxCnt(IPPROTO_TCP, ALPROTO_DNP3, DNP3GetTxCnt);
AppLayerDecoderEvents *decoder_events; /**< Per transcation
* decoder events. */
- DetectEngineState *de_state;
TAILQ_ENTRY(DNP3Transaction_) next;
} DNP3Transaction;
AppLayerDecoderEvents *decoder_events; /**< per tx events */
TAILQ_ENTRY(ENIPTransaction_) next;
- DetectEngineState *de_state;
AppLayerTxData tx_data;
} ENIPTransaction;
return 1;
}
-static DetectEngineState *ENIPGetTxDetectState(void *vtx)
-{
- ENIPTransaction *tx = (ENIPTransaction *)vtx;
- return tx->de_state;
-}
-
-static int ENIPSetTxDetectState(void *vtx, DetectEngineState *s)
-{
- ENIPTransaction *tx = (ENIPTransaction *)vtx;
- tx->de_state = s;
- return 0;
-}
-
static AppLayerTxData *ENIPGetTxData(void *vtx)
{
ENIPTransaction *tx = (ENIPTransaction *)vtx;
AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
- if (tx->de_state != NULL)
- {
- DetectEngineStateFree(tx->de_state);
+ if (tx->tx_data.de_state != NULL) {
+ DetectEngineStateFree(tx->tx_data.de_state);
state->tx_with_detect_state_cnt--;
}
AppLayerParserRegisterGetEventsFunc(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetEvents);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_UDP, ALPROTO_ENIP,
- ENIPGetTxDetectState, ENIPSetTxDetectState);
-
AppLayerParserRegisterGetTx(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetTxData);
AppLayerParserRegisterGetTxCnt(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetTxCnt);
AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetEvents);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_ENIP,
- ENIPGetTxDetectState, ENIPSetTxDetectState);
-
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetTxData);
AppLayerParserRegisterGetTxCnt(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetTxCnt);
{
SCEnter();
- if (tx->de_state != NULL) {
- DetectEngineStateFree(tx->de_state);
+ if (tx->tx_data.de_state != NULL) {
+ DetectEngineStateFree(tx->tx_data.de_state);
}
if (tx->request) {
#endif
}
-static int FTPSetTxDetectState(void *vtx, DetectEngineState *de_state)
-{
- FTPTransaction *tx = (FTPTransaction *)vtx;
- tx->de_state = de_state;
- return 0;
-}
-
/**
* \brief This function returns the oldest open transaction; if none
* are open, then the oldest transaction is returned
return NULL;
}
-static DetectEngineState *FTPGetTxDetectState(void *vtx)
-{
- FTPTransaction *tx = (FTPTransaction *)vtx;
- return tx->de_state;
-}
-
-
static AppLayerTxData *FTPGetTxData(void *vtx)
{
FTPTransaction *tx = (FTPTransaction *)vtx;
{
FtpDataState *fstate = (FtpDataState *) s;
- if (fstate->de_state != NULL) {
- DetectEngineStateFree(fstate->de_state);
+ if (fstate->tx_data.de_state != NULL) {
+ DetectEngineStateFree(fstate->tx_data.de_state);
}
if (fstate->file_name != NULL) {
FTPFree(fstate->file_name, fstate->file_len + 1);
#endif
}
-static int FTPDataSetTxDetectState(void *vtx, DetectEngineState *de_state)
-{
- FtpDataState *ftp_state = (FtpDataState *)vtx;
- ftp_state->de_state = de_state;
- return 0;
-}
-
-static DetectEngineState *FTPDataGetTxDetectState(void *vtx)
-{
- FtpDataState *ftp_state = (FtpDataState *)vtx;
- return ftp_state->de_state;
-}
-
static AppLayerTxData *FTPDataGetTxData(void *vtx)
{
FtpDataState *ftp_state = (FtpDataState *)vtx;
AppLayerParserRegisterTxFreeFunc(IPPROTO_TCP, ALPROTO_FTP, FTPStateTransactionFree);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_FTP,
- FTPGetTxDetectState, FTPSetTxDetectState);
-
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_FTP, FTPGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_FTP, FTPGetTxData);
AppLayerParserRegisterStateFuncs(IPPROTO_TCP, ALPROTO_FTPDATA, FTPDataStateAlloc, FTPDataStateFree);
AppLayerParserRegisterParserAcceptableDataDirection(IPPROTO_TCP, ALPROTO_FTPDATA, STREAM_TOSERVER | STREAM_TOCLIENT);
AppLayerParserRegisterTxFreeFunc(IPPROTO_TCP, ALPROTO_FTPDATA, FTPDataStateTransactionFree);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_FTPDATA,
- FTPDataGetTxDetectState, FTPDataSetTxDetectState);
AppLayerParserRegisterGetFilesFunc(IPPROTO_TCP, ALPROTO_FTPDATA, FTPDataStateGetFiles);
/* Handle multiple responses */
TAILQ_HEAD(, FTPString_) response_list;
- DetectEngineState *de_state;
-
TAILQ_ENTRY(FTPTransaction_) next;
} FTPTransaction;
uint8_t *input;
uint8_t *file_name;
FileContainer *files;
- DetectEngineState *de_state;
int32_t input_len;
int16_t file_len;
FtpRequestCommand command;
AppLayerDecoderEventsFreeEvents(&htud->decoder_events);
if (htud->boundary)
HTPFree(htud->boundary, htud->boundary_len);
- if (htud->de_state != NULL) {
- DetectEngineStateFree(htud->de_state);
+ if (htud->tx_data.de_state != NULL) {
+ DetectEngineStateFree(htud->tx_data.de_state);
}
HTPFree(htud, sizeof(HtpTxUserData));
}
static void FlagDetectStateNewFile(HtpTxUserData *tx, int dir)
{
SCEnter();
- if (tx && tx->de_state) {
+ if (tx && tx->tx_data.de_state) {
if (dir == STREAM_TOSERVER) {
SCLogDebug("DETECT_ENGINE_STATE_FLAG_FILE_NEW set");
- tx->de_state->dir_state[0].flags |= DETECT_ENGINE_STATE_FLAG_FILE_NEW;
+ tx->tx_data.de_state->dir_state[0].flags |= DETECT_ENGINE_STATE_FLAG_FILE_NEW;
} else if (STREAM_TOCLIENT) {
SCLogDebug("DETECT_ENGINE_STATE_FLAG_FILE_NEW set");
- tx->de_state->dir_state[1].flags |= DETECT_ENGINE_STATE_FLAG_FILE_NEW;
+ tx->tx_data.de_state->dir_state[1].flags |= DETECT_ENGINE_STATE_FLAG_FILE_NEW;
}
}
}
}
}
-static DetectEngineState *HTPGetTxDetectState(void *vtx)
-{
- htp_tx_t *tx = (htp_tx_t *)vtx;
- HtpTxUserData *tx_ud = htp_tx_get_user_data(tx);
- return tx_ud ? tx_ud->de_state : NULL;
-}
-
-static int HTPSetTxDetectState(void *vtx, DetectEngineState *s)
-{
- htp_tx_t *tx = (htp_tx_t *)vtx;
- HtpTxUserData *tx_ud = htp_tx_get_user_data(tx);
- if (tx_ud == NULL) {
- return -ENOMEM;
- }
- tx_ud->de_state = s;
- return 0;
-}
-
static AppLayerTxData *HTPGetTxData(void *vtx)
{
htp_tx_t *tx = (htp_tx_t *)vtx;
IPPROTO_TCP, ALPROTO_HTTP1, HTPStateGetEventInfoById);
AppLayerParserRegisterTruncateFunc(IPPROTO_TCP, ALPROTO_HTTP1, HTPStateTruncate);
- AppLayerParserRegisterDetectStateFuncs(
- IPPROTO_TCP, ALPROTO_HTTP1, HTPGetTxDetectState, HTPSetTxDetectState);
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_HTTP1, HTPGetTxData);
AppLayerParserRegisterSetStreamDepthFlag(
uint8_t request_body_type;
- DetectEngineState *de_state;
AppLayerTxData tx_data;
} HtpTxUserData;
int (*StateGetEventInfo)(const char *event_name,
int *event_id, AppLayerEventType *event_type);
- DetectEngineState *(*GetTxDetectState)(void *tx);
- int (*SetTxDetectState)(void *tx, DetectEngineState *);
-
AppLayerTxData *(*GetTxData)(void *tx);
bool (*ApplyTxConfig)(void *state, void *tx, int mode, AppLayerTxConfig);
SCReturn;
}
-void AppLayerParserRegisterDetectStateFuncs(uint8_t ipproto, AppProto alproto,
- DetectEngineState *(*GetTxDetectState)(void *tx),
- int (*SetTxDetectState)(void *tx, DetectEngineState *))
-{
- SCEnter();
-
- alp_ctx.ctxs[FlowGetProtoMapping(ipproto)][alproto].GetTxDetectState = GetTxDetectState;
- alp_ctx.ctxs[FlowGetProtoMapping(ipproto)][alproto].SetTxDetectState = SetTxDetectState;
-
- SCReturn;
-}
-
void AppLayerParserRegisterTxDataFunc(uint8_t ipproto, AppProto alproto,
AppLayerTxData *(*GetTxData)(void *tx))
{
DetectEngineState *AppLayerParserGetTxDetectState(uint8_t ipproto, AppProto alproto, void *tx)
{
SCEnter();
- DetectEngineState *s = alp_ctx.ctxs[FlowGetProtoMapping(ipproto)][alproto].GetTxDetectState(tx);
+ AppLayerTxData *d = AppLayerParserGetTxData(ipproto, alproto, tx);
+ DetectEngineState *s = d->de_state;
SCReturnPtr(s, "DetectEngineState");
}
void *tx, DetectEngineState *s)
{
SCEnter();
- int r = alp_ctx.ctxs[f->protomap][f->alproto].SetTxDetectState(tx, s);
- SCReturnInt(r);
+ AppLayerTxData *d = alp_ctx.ctxs[f->protomap][f->alproto].GetTxData(tx);
+ d->de_state = s;
+ SCReturnInt(0);
}
AppLayerTxData *AppLayerParserGetTxData(uint8_t ipproto, AppProto alproto, void *tx)
ctx->StateGetTx, ctx->StateGetTxCnt, ctx->StateTransactionFree);
printf("- GetTxData %p\n", ctx->GetTxData);
printf("- StateGetProgress %p\n", ctx->StateGetProgress);
- printf("- GetTxDetectState %p SetTxDetectState %p\n", ctx->GetTxDetectState, ctx->SetTxDetectState);
printf("Optional:\n");
printf("- LocalStorageAlloc %p LocalStorageFree %p\n", ctx->LocalStorageAlloc, ctx->LocalStorageFree);
printf("- StateGetEvents %p StateGetEventInfo %p StateGetEventInfoById %p\n", ctx->StateGetEvents, ctx->StateGetEventInfo,
if (!(BOTH_SET_OR_BOTH_UNSET(ctx->LocalStorageAlloc, ctx->LocalStorageFree))) {
goto bad;
}
- if (!(BOTH_SET(ctx->GetTxDetectState, ctx->SetTxDetectState))) {
- goto bad;
- }
if (ctx->GetTxData == NULL) {
goto bad;
}
void AppLayerParserRegisterGetEventInfoById(uint8_t ipproto, AppProto alproto,
int (*StateGetEventInfoById)(int event_id, const char **event_name,
AppLayerEventType *event_type));
-void AppLayerParserRegisterDetectStateFuncs(uint8_t ipproto, AppProto alproto,
- DetectEngineState *(*GetTxDetectState)(void *tx),
- int (*SetTxDetectState)(void *tx, DetectEngineState *));
void AppLayerParserRegisterGetStreamDepth(uint8_t ipproto,
AppProto alproto,
uint32_t (*GetStreamDepth)(void));
AppLayerParserRegisterGetTx(p->ip_proto, alproto,
p->StateGetTx);
- /* What is this being registered for? */
- AppLayerParserRegisterDetectStateFuncs(p->ip_proto, alproto,
- p->GetTxDetectState, p->SetTxDetectState);
-
if (p->StateGetEventInfo) {
AppLayerParserRegisterGetEventInfo(p->ip_proto, alproto,
p->StateGetEventInfo);
const int complete_tc;
int (*StateGetProgress)(void *alstate, uint8_t direction);
- DetectEngineState *(*GetTxDetectState)(void *tx);
- int (*SetTxDetectState)(void *tx, DetectEngineState *);
-
AppLayerDecoderEvents *(*StateGetEvents)(void *);
int (*StateGetEventInfo)(const char *event_name,
int *event_id, AppLayerEventType *event_type);
static void FlagDetectStateNewFile(SMTPTransaction *tx)
{
- if (tx && tx->de_state) {
+ if (tx && tx->tx_data.de_state) {
SCLogDebug("DETECT_ENGINE_STATE_FLAG_FILE_NEW set");
- tx->de_state->dir_state[0].flags |= DETECT_ENGINE_STATE_FLAG_FILE_NEW;
+ tx->tx_data.de_state->dir_state[0].flags |= DETECT_ENGINE_STATE_FLAG_FILE_NEW;
} else if (tx == NULL) {
SCLogDebug("DETECT_ENGINE_STATE_FLAG_FILE_NEW NOT set, no TX");
- } else if (tx->de_state == NULL) {
+ } else if (tx->tx_data.de_state == NULL) {
SCLogDebug("DETECT_ENGINE_STATE_FLAG_FILE_NEW NOT set, no TX DESTATE");
}
}
if (tx->decoder_events != NULL)
AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
- if (tx->de_state != NULL)
- DetectEngineStateFree(tx->de_state);
+ if (tx->tx_data.de_state != NULL)
+ DetectEngineStateFree(tx->tx_data.de_state);
if (tx->mail_from)
SCFree(tx->mail_from);
return ((SMTPTransaction *)tx)->decoder_events;
}
-static DetectEngineState *SMTPGetTxDetectState(void *vtx)
-{
- SMTPTransaction *tx = (SMTPTransaction *)vtx;
- return tx->de_state;
-}
-
-static int SMTPSetTxDetectState(void *vtx, DetectEngineState *s)
-{
- SMTPTransaction *tx = (SMTPTransaction *)vtx;
- tx->de_state = s;
- return 0;
-}
-
static AppLayerTxData *SMTPGetTxData(void *vtx)
{
SMTPTransaction *tx = (SMTPTransaction *)vtx;
AppLayerParserRegisterGetEventInfo(IPPROTO_TCP, ALPROTO_SMTP, SMTPStateGetEventInfo);
AppLayerParserRegisterGetEventInfoById(IPPROTO_TCP, ALPROTO_SMTP, SMTPStateGetEventInfoById);
AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_SMTP, SMTPGetEvents);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_SMTP,
- SMTPGetTxDetectState, SMTPSetTxDetectState);
AppLayerParserRegisterLocalStorageFunc(IPPROTO_TCP, ALPROTO_SMTP, SMTPLocalStorageAlloc,
SMTPLocalStorageFree);
MimeDecParseState *mime_state;
AppLayerDecoderEvents *decoder_events; /**< per tx events */
- DetectEngineState *de_state;
/* MAIL FROM parameters */
uint8_t *mail_from;
return ssl_state->decoder_events;
}
-static int SSLSetTxDetectState(void *vtx, DetectEngineState *de_state)
-{
- SSLState *ssl_state = (SSLState *)vtx;
- ssl_state->de_state = de_state;
- return 0;
-}
-
-static DetectEngineState *SSLGetTxDetectState(void *vtx)
-{
- SSLState *ssl_state = (SSLState *)vtx;
- return ssl_state->de_state;
-}
-
static void *SSLGetTx(void *state, uint64_t tx_id)
{
SSLState *ssl_state = (SSLState *)state;
AppLayerDecoderEventsFreeEvents(&ssl_state->decoder_events);
- if (ssl_state->de_state != NULL) {
- DetectEngineStateFree(ssl_state->de_state);
+ if (ssl_state->tx_data.de_state != NULL) {
+ DetectEngineStateFree(ssl_state->tx_data.de_state);
}
/* Free certificate chain */
AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetEvents);
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_TLS,
- SSLGetTxDetectState, SSLSetTxDetectState);
-
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_TLS, SSLGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetTxData);
SSLStateConnp client_connp;
SSLStateConnp server_connp;
- DetectEngineState *de_state;
AppLayerDecoderEvents *decoder_events;
} SSLState;
return &tx->tx_data;
}
-/**
- * \brief retrieve the detection engine per tx state
- */
-static DetectEngineState *TemplateGetTxDetectState(void *vtx)
-{
- TemplateTransaction *tx = vtx;
- return tx->de_state;
-}
-
-/**
- * \brief get the detection engine per tx state
- */
-static int TemplateSetTxDetectState(void *vtx,
- DetectEngineState *s)
-{
- TemplateTransaction *tx = vtx;
- tx->de_state = s;
- return 0;
-}
-
void RegisterTemplateParsers(void)
{
const char *proto_name = "template";
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_TEMPLATE,
TemplateGetTxData);
- /* What is this being registered for? */
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_TCP, ALPROTO_TEMPLATE,
- TemplateGetTxDetectState, TemplateSetTxDetectState);
-
AppLayerParserRegisterGetEventInfo(IPPROTO_TCP, ALPROTO_TEMPLATE,
TemplateStateGetEventInfo);
AppLayerParserRegisterGetEventInfoById(IPPROTO_TCP, ALPROTO_TEMPLATE,
uint8_t response_done; /*<< Flag to be set when the response is
* seen. */
- DetectEngineState *de_state;
-
AppLayerTxData tx_data;
TAILQ_ENTRY(TemplateTransaction) next;
return 1;
}
-static DetectEngineState *TFTPGetTxDetectState(void *vtx)
-{
- return NULL;
-}
-
-static int TFTPSetTxDetectState(void *vtx,
- DetectEngineState *s)
-{
- return 0;
-}
-
void RegisterTFTPParsers(void)
{
const char *proto_name = "tftp";
AppLayerParserRegisterGetTx(IPPROTO_UDP, ALPROTO_TFTP,
TFTPGetTx);
- /* What is this being registered for? */
- AppLayerParserRegisterDetectStateFuncs(IPPROTO_UDP, ALPROTO_TFTP,
- TFTPGetTxDetectState,
- TFTPSetTxDetectState);
-
AppLayerParserRegisterGetEventInfo(IPPROTO_UDP, ALPROTO_TFTP,
TFTPStateGetEventInfo);
AppLayerParserRegisterGetEventsFunc(IPPROTO_UDP, ALPROTO_TFTP,
projects / people / ms / suricata.git / commitdiff
