//! Parser registration functions and common interface
use std;
-use crate::core::{self,DetectEngineState,Flow,AppLayerEventType,AppLayerDecoderEvents,AppProto};
+use crate::core::{self,DetectEngineState,Flow,AppLayerEventType,AppProto};
use crate::filecontainer::FileContainer;
use crate::applayer;
use std::os::raw::{c_void,c_char,c_int};
detect_flags_tc: u64,
de_state: *mut DetectEngineState,
+ pub events: *mut core::AppLayerDecoderEvents,
}
impl Default for AppLayerTxData {
if self.de_state != std::ptr::null_mut() {
core::sc_detect_engine_state_free(self.de_state);
}
+ if self.events != std::ptr::null_mut() {
+ core::sc_app_layer_decoder_events_free_events(&mut self.events);
+ }
}
}
detect_flags_ts: 0,
detect_flags_tc: 0,
de_state: std::ptr::null_mut(),
+ events: std::ptr::null_mut(),
}
}
pub fn init_files_opened(&mut self) {
pub fn incr_files_opened(&mut self) {
self.files_opened += 1;
}
+
+ pub fn set_event(&mut self, event: u8) {
+ core::sc_app_layer_decoder_events_set_event_raw(&mut self.events, event as u8);
+ }
}
#[macro_export]
/// Function returning the current transaction progress
pub tx_get_progress: StateGetProgressFn,
- /// Function to get events
- pub get_events: Option<GetEventsFn>,
/// Function to get an event id from a description
pub get_eventinfo: Option<GetEventInfoFn>,
/// Function to get an event description from an event id
pub type StateGetProgressFn = unsafe extern "C" fn (*mut c_void, u8) -> 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 = unsafe
*/
use std;
-use crate::core::{self, ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP};
+use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP};
use crate::applayer::{self, *};
use std::ffi::CString;
use nom;
pub request: Option<String>,
pub response: Option<String>,
- de_state: Option<*mut core::DetectEngineState>,
- events: *mut core::AppLayerDecoderEvents,
tx_data: AppLayerTxData,
}
tx_id: 0,
request: None,
response: None,
- de_state: None,
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
}
-
- pub fn free(&mut self) {
- 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);
- }
- }
}
impl Transaction for TemplateTransaction {
}
}
-impl Drop for TemplateTransaction {
- fn drop(&mut self) {
- self.free();
- }
-}
-
pub struct TemplateState {
tx_id: u64,
transactions: Vec<TemplateTransaction>,
return 0;
}
-#[no_mangle]
-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 tx.events;
-}
-
/// Get the request buffer for a transaction from C.
///
/// No required for parsing, but an example function for retrieving a
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_template_tx_get_alstate_progress,
- 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),
localstorage_new: None,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_dcerpc_get_alstate_progress,
- get_events: None,
get_eventinfo: None,
get_eventinfo_byid : None,
localstorage_new: None,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_dcerpc_get_alstate_progress,
- get_events: None,
get_eventinfo: None,
get_eventinfo_byid: None,
localstorage_new: None,
use crate::applayer::{self, *};
use crate::core;
use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_UDP};
-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,
- events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
DHCPTransaction {
tx_id: id,
message: message,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
}
-
- pub fn free(&mut self) {
- if !self.events.is_null() {
- sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-
}
impl Transaction for DHCPTransaction {
}
}
-impl Drop for DHCPTransaction {
- fn drop(&mut self) {
- self.free();
- }
-}
-
#[derive(Default)]
pub struct DHCPState {
// Internal transaction ID.
fn set_event(&mut self, event: DHCPEvent) {
if let Some(tx) = self.transactions.last_mut() {
- core::sc_app_layer_decoder_events_set_event_raw(
- &mut tx.events, event as u8);
+ tx.tx_data.set_event(event as u8);
self.events += 1;
}
}
std::mem::drop(Box::from_raw(state as *mut DHCPState));
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
export_tx_data_get!(rs_dhcp_get_tx_data, DHCPTransaction);
const PARSER_NAME: &'static [u8] = b"dhcp\0";
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_dhcp_tx_get_alstate_progress,
- 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),
localstorage_new : None,
pub id: u64,
pub request: Option<DNSRequest>,
pub response: Option<DNSResponse>,
- pub events: *mut core::AppLayerDecoderEvents,
pub tx_data: AppLayerTxData,
}
id: 0,
request: None,
response: None,
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
}
- pub fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-
/// Get the DNS transactions ID (not the internal tracking ID).
pub fn tx_id(&self) -> u16 {
if let &Some(ref request) = &self.request {
}
-impl Drop for DNSTransaction {
- fn drop(&mut self) {
- self.free();
- }
-}
-
struct ConfigTracker {
map: HashMap<u16, AppLayerTxConfig>,
queue: VecDeque<u16>,
}
let tx = &mut self.transactions[len - 1];
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events,
- event as u8);
+ tx.tx_data.set_event(event as u8);
self.events += 1;
}
tx.response.is_some()
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
pub unsafe extern "C" fn rs_dns_state_get_tx_data(
tx: *mut std::os::raw::c_void)
-> *mut AppLayerTxData
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_dns_tx_get_alstate_progress,
- get_events: Some(rs_dns_state_get_events),
get_eventinfo: Some(DNSEvent::get_event_info),
get_eventinfo_byid: Some(DNSEvent::get_event_info_by_id),
localstorage_new: None,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_dns_tx_get_alstate_progress,
- get_events: Some(rs_dns_state_get_events),
get_eventinfo: Some(DNSEvent::get_event_info),
get_eventinfo_byid: Some(DNSEvent::get_event_info_by_id),
localstorage_new: None,
use super::range;
use crate::applayer::{self, *};
-use crate::core::{self, *};
+use crate::core::*;
use crate::filecontainer::*;
use crate::filetracker::*;
use nom;
decoder: decompression::HTTP2Decoder,
pub file_range: *mut HttpRangeContainerBlock,
- events: *mut core::AppLayerDecoderEvents,
tx_data: AppLayerTxData,
pub ft_tc: FileTransferTracker,
ft_ts: FileTransferTracker,
frames_ts: Vec::new(),
decoder: decompression::HTTP2Decoder::new(),
file_range: std::ptr::null_mut(),
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
ft_tc: FileTransferTracker::new(),
ft_ts: FileTransferTracker::new(),
}
pub fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
if !self.file_range.is_null() {
match unsafe { SC } {
None => panic!("BUG no suricata_config"),
}
pub fn set_event(&mut self, event: HTTP2Event) {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut self.events, ev);
+ self.tx_data.set_event(event as u8);
}
fn handle_headers(&mut self, blocks: &Vec<parser::HTTP2FrameHeaderBlock>, dir: Direction) {
return;
}
let tx = &mut self.transactions[len - 1];
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.tx_data.set_event(event as u8);
}
// Free a transaction by ID.
return rs_http2_tx_get_state(tx) as i32;
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_http2_getfiles(
state: *mut std::os::raw::c_void, direction: u8,
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_events: Some(rs_http2_state_get_events),
get_eventinfo: Some(HTTP2Event::get_event_info),
get_eventinfo_byid: Some(HTTP2Event::get_event_info_by_id),
localstorage_new: None,
pub errors: u32,
logged: LoggerFlags,
- events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
payload_types: Default::default(),
notify_types: vec![],
logged: LoggerFlags::new(),
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
errors: 0,
}
}
- pub fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-
/// Set an event.
pub fn set_event(&mut self, event: IkeEvent) {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut self.events, ev);
- }
-}
-
-impl Drop for IKETransaction {
- fn drop(&mut self) {
- self.free();
+ self.tx_data.set_event(event as u8);
}
}
/// Set an event. The event is set on the most recent transaction.
pub fn set_event(&mut self, event: IkeEvent) {
if let Some(tx) = self.transactions.last_mut() {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.set_event(event);
} else {
SCLogDebug!(
"IKE: trying to set event {} on non-existing transaction",
tx.logged.set(logged);
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
static mut ALPROTO_IKE : AppProto = ALPROTO_UNKNOWN;
// Parser name as a C style string.
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_ike_tx_get_alstate_progress,
- 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),
localstorage_new : None,
/// The internal transaction id
id: u64,
- /// The events associated with this transaction
- events: *mut core::AppLayerDecoderEvents,
-
tx_data: applayer::AppLayerTxData,
}
/// Set an event. The event is set on the most recent transaction.
fn set_event(&mut self, event: KRB5Event) {
if let Some(tx) = self.transactions.last_mut() {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.tx_data.set_event(event as u8);
}
}
}
etype: None,
error_code: None,
id: id,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
}
}
-impl Drop for KRB5Transaction {
- fn drop(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
/// Return true if Kerberos `EncryptionType` is weak
pub fn test_weak_encryption(alg:EncryptionType) -> bool {
match alg {
1
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
static mut ALPROTO_KRB5 : AppProto = ALPROTO_UNKNOWN;
#[no_mangle]
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_krb5_tx_get_alstate_progress,
- 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),
localstorage_new : None,
pub request: Option<Message>,
pub response: Option<Message>,
- pub events: *mut core::AppLayerDecoderEvents,
pub tx_data: AppLayerTxData,
}
id,
request: None,
response: None,
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
}
fn set_event(&mut self, event: ModbusEvent) {
- core::sc_app_layer_decoder_events_set_event_raw(&mut self.events, event as u8);
+ self.tx_data.set_event(event as u8);
}
fn set_events_from_flags(&mut self, flags: &Flags<ErrorFlags>) {
}
}
-impl Drop for ModbusTransaction {
- fn drop(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
pub struct ModbusState {
pub transactions: Vec<ModbusTransaction>,
tx_id: u64,
tx.response.is_some() as std::os::raw::c_int
}
-#[no_mangle]
-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);
- tx.events
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_modbus_state_get_tx_data(
tx: *mut std::os::raw::c_void,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_modbus_tx_get_alstate_progress,
- get_events: Some(rs_modbus_state_get_events),
get_eventinfo: Some(ModbusEvent::get_event_info),
get_eventinfo_byid: Some(ModbusEvent::get_event_info_by_id),
localstorage_new: None,
use super::parser::*;
use crate::applayer::{self, LoggerFlags};
use crate::applayer::*;
-use crate::core::{self, *};
+use crate::core::*;
use nom7::Err;
use std;
use std::ffi::CString;
toserver: bool,
logged: LoggerFlags,
- events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
msg: Vec::new(),
toclient: false,
toserver: false,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
};
m.msg.push(msg);
return m;
}
-
- pub fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
-impl Drop for MQTTTransaction {
- fn drop(&mut self) {
- self.free();
- }
}
impl Transaction for MQTTTransaction {
}
fn set_event(tx: &mut MQTTTransaction, event: MQTTEvent) {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.tx_data.set_event(event as u8);
}
}
tx.logged.set(logged);
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
// Parser name as a C style string.
const PARSER_NAME: &'static [u8] = b"mqtt\0";
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_mqtt_tx_get_alstate_progress,
- 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),
localstorage_new: None,
/// attempt failed.
pub type_data: Option<NFSTransactionTypeData>,
- pub events: *mut AppLayerDecoderEvents,
-
pub tx_data: AppLayerTxData,
}
file_tx_direction: Direction::ToServer,
file_handle:Vec::new(),
type_data: None,
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
}
pub fn free(&mut self) {
debug_validate_bug_on!(self.tx_data.files_opened > 1);
debug_validate_bug_on!(self.tx_data.files_logged > 1);
- if !self.events.is_null() {
- sc_app_layer_decoder_events_free_events(&mut self.events);
- }
}
}
}
let tx = &mut self.transactions[len - 1];
- sc_app_layer_decoder_events_set_event_raw(&mut tx.events, event as u8);
+ tx.tx_data.set_event(event as u8);
self.events += 1;
}
return &mut tx.tx_data;
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
#[no_mangle]
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,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_nfs_tx_get_alstate_progress,
- 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),
localstorage_new: None,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_nfs_tx_get_alstate_progress,
- get_events: Some(rs_nfs_state_get_events),
get_eventinfo: Some(rs_nfs_state_get_event_info),
get_eventinfo_byid : None,
localstorage_new: None,
/// The internal transaction id
id: u64,
- /// The events associated with this transaction
- events: *mut core::AppLayerDecoderEvents,
-
tx_data: applayer::AppLayerTxData,
}
/// Set an event. The event is set on the most recent transaction.
pub fn set_event(&mut self, event: NTPEvent) {
if let Some(tx) = self.transactions.last_mut() {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.tx_data.set_event(event as u8);
self.events += 1;
}
}
NTPTransaction {
xid: 0,
id: id,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
}
-
- fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
-impl Drop for NTPTransaction {
- fn drop(&mut self) {
- self.free();
- }
}
/// Returns *mut NTPState
1
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
static mut ALPROTO_NTP : AppProto = ALPROTO_UNKNOWN;
#[no_mangle]
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_ntp_tx_get_alstate_progress,
- 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),
localstorage_new : None,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_rdp_tx_get_progress,
- get_events: None,
get_eventinfo: None,
get_eventinfo_byid: None,
localstorage_new: None,
use std;
use std::ffi::CString;
-use crate::core::{self, ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP};
+use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP};
use crate::applayer;
use crate::applayer::*;
use nom;
pub tc_failure_reason: Option<parser::FailureReason>,
pub tc_server_init: Option<parser::ServerInit>,
- events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
tc_failure_reason: None,
tc_server_init: None,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
}
-
- pub fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
-impl Drop for RFBTransaction {
- fn drop(&mut self) {
- self.free();
- }
}
pub struct RFBState {
return 0;
}
-#[no_mangle]
-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 tx.events;
-}
-
// Parser name as a C style string.
const PARSER_NAME: &'static [u8] = b"rfb\0";
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_rfb_tx_get_alstate_progress,
- get_events: Some(rs_rfb_state_get_events),
get_eventinfo: None,
get_eventinfo_byid: None,
localstorage_new: None,
pub response: Option<Response>,
pub request_line: Option<String>,
pub response_line: Option<String>,
- events: *mut core::AppLayerDecoderEvents,
tx_data: applayer::AppLayerTxData,
}
fn set_event(&mut self, event: SIPEvent) {
if let Some(tx) = self.transactions.last_mut() {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.tx_data.set_event(event as u8);
}
}
response: None,
request_line: None,
response_line: None,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
}
}
-impl Drop for SIPTransaction {
- fn drop(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
#[no_mangle]
pub extern "C" fn rs_sip_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
let state = SIPState::new();
1
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
static mut ALPROTO_SIP: AppProto = ALPROTO_UNKNOWN;
#[no_mangle]
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_sip_tx_get_alstate_progress,
- 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),
localstorage_new: None,
* 02110-1301, USA.
*/
-use crate::core::*;
use crate::smb::smb::*;
#[derive(AppLayerEvent)]
impl SMBTransaction {
/// Set event.
pub fn set_event(&mut self, e: SMBEvent) {
- sc_app_layer_decoder_events_set_event_raw(&mut self.events, e as u8);
+ self.tx_data.set_event(e as u8);
}
/// Set events from vector of events.
pub fn set_events(&mut self, events: Vec<SMBEvent>) {
for e in events {
- sc_app_layer_decoder_events_set_event_raw(&mut self.events, e as u8);
+ self.tx_data.set_event(e as u8);
}
}
}
let tx = &mut self.transactions[len - 1];
tx.set_event(event);
- //sc_app_layer_decoder_events_set_event_raw(&mut tx.events, event as u8);
}
}
/// Command specific data
pub type_data: Option<SMBTransactionTypeData>,
- pub events: *mut AppLayerDecoderEvents,
pub tx_data: AppLayerTxData,
}
request_done: false,
response_done: false,
type_data: None,
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
}
pub fn free(&mut self) {
debug_validate_bug_on!(self.tx_data.files_opened > 1);
debug_validate_bug_on!(self.tx_data.files_logged > 1);
- if !self.events.is_null() {
- sc_app_layer_decoder_events_free_events(&mut self.events);
- }
}
}
}
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
#[no_mangle]
pub unsafe extern "C" fn rs_smb_state_get_event_info_by_id(
event_id: std::os::raw::c_int,
tx_comp_st_ts: 1,
tx_comp_st_tc: 1,
tx_get_progress: rs_smb_tx_get_alstate_progress,
- 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),
localstorage_new: None,
/// The internal transaction id
id: u64,
- /// The events associated with this transaction
- events: *mut core::AppLayerDecoderEvents,
-
tx_data: applayer::AppLayerTxData,
}
/// Set an event. The event is set on the most recent transaction.
fn set_event(&mut self, event: SNMPEvent) {
if let Some(tx) = self.transactions.last_mut() {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, ev);
+ tx.tx_data.set_event(event as u8);
}
}
/// Set an event on a specific transaction.
fn set_event_tx(&self, tx: &mut SNMPTransaction, event: SNMPEvent) {
- core::sc_app_layer_decoder_events_set_event_raw(&mut tx.events, event as u8);
+ tx.tx_data.set_event(event as u8);
}
}
usm: None,
encrypted: false,
id: id,
- events: std::ptr::null_mut(),
tx_data: applayer::AppLayerTxData::new(),
}
}
-
- fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
}
-impl<'a> Drop for SNMPTransaction<'a> {
- fn drop(&mut self) {
- self.free();
- }
-}
-
-
-
-
-
-
/// Returns *mut SNMPState
#[no_mangle]
pub extern "C" fn rs_snmp_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
1
}
-#[no_mangle]
-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);
- return tx.events;
-}
-
static mut ALPROTO_SNMP : AppProto = ALPROTO_UNKNOWN;
// Read PDU sequence and extract version, if similar to SNMP definition
tx_comp_st_ts : 1,
tx_comp_st_tc : 1,
tx_get_progress : rs_snmp_tx_get_alstate_progress,
- 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),
localstorage_new : None,
use super::parser;
use crate::applayer::*;
-use crate::core::{self, *};
+use crate::core::*;
use nom7::Err;
use std::ffi::CString;
use std::sync::atomic::{AtomicBool, Ordering};
pub srv_hdr: SshHeader,
pub cli_hdr: SshHeader,
- events: *mut core::AppLayerDecoderEvents,
tx_data: AppLayerTxData,
}
SSHTransaction {
srv_hdr: SshHeader::new(),
cli_hdr: SshHeader::new(),
- events: std::ptr::null_mut(),
tx_data: AppLayerTxData::new(),
}
}
-
- pub fn free(&mut self) {
- if !self.events.is_null() {
- core::sc_app_layer_decoder_events_free_events(&mut self.events);
- }
- }
-}
-
-impl Drop for SSHTransaction {
- fn drop(&mut self) {
- self.free();
- }
}
pub struct SSHState {
}
fn set_event(&mut self, event: SSHEvent) {
- let ev = event as u8;
- core::sc_app_layer_decoder_events_set_event_raw(&mut self.transaction.events, ev);
+ self.transaction.tx_data.set_event(event as u8);
}
fn parse_record(
export_tx_data_get!(rs_ssh_get_tx_data, SSHTransaction);
-#[no_mangle]
-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);
- return tx.events;
-}
-
#[no_mangle]
pub extern "C" fn rs_ssh_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
let state = SSHState::new();
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_events: Some(rs_ssh_state_get_events),
get_eventinfo: Some(SSHEvent::get_event_info),
get_eventinfo_byid: Some(SSHEvent::get_event_info_by_id),
localstorage_new: None,
static void DNP3SetEvent(DNP3State *dnp3, uint8_t event)
{
if (dnp3 && dnp3->curr) {
- AppLayerDecoderEventsSetEventRaw(&dnp3->curr->decoder_events, event);
+ AppLayerDecoderEventsSetEventRaw(&dnp3->curr->tx_data.events, event);
dnp3->events++;
}
else {
*/
static void DNP3SetEventTx(DNP3Transaction *tx, uint8_t event)
{
- AppLayerDecoderEventsSetEventRaw(&tx->decoder_events, event);
+ AppLayerDecoderEventsSetEventRaw(&tx->tx_data.events, event);
tx->dnp3->events++;
}
SCReturnStruct(APP_LAYER_ERROR);
}
-static AppLayerDecoderEvents *DNP3GetEvents(void *tx)
-{
- return ((DNP3Transaction *) tx)->decoder_events;
-}
-
static void *DNP3GetTx(void *alstate, uint64_t tx_id)
{
SCEnter();
SCFree(tx->response_buffer);
}
- AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
+ AppLayerDecoderEventsFreeEvents(&tx->tx_data.events);
if (tx->tx_data.de_state != NULL) {
DetectEngineStateFree(tx->tx_data.de_state);
dnp3->curr = NULL;
}
- if (tx->decoder_events != NULL) {
- if (tx->decoder_events->cnt <= dnp3->events) {
- dnp3->events -= tx->decoder_events->cnt;
- }
- else {
+ if (tx->tx_data.events != NULL) {
+ if (tx->tx_data.events->cnt <= dnp3->events) {
+ dnp3->events -= tx->tx_data.events->cnt;
+ } else {
dnp3->events = 0;
}
}
AppLayerParserRegisterStateFuncs(IPPROTO_TCP, ALPROTO_DNP3,
DNP3StateAlloc, DNP3StateFree);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_DNP3,
- DNP3GetEvents);
-
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_DNP3, DNP3GetTx);
AppLayerParserRegisterGetTxCnt(IPPROTO_TCP, ALPROTO_DNP3, DNP3GetTxCnt);
AppLayerParserRegisterTxFreeFunc(IPPROTO_TCP, ALPROTO_DNP3,
* we do not know. */
DNP3ObjectList response_objects;
- AppLayerDecoderEvents *decoder_events; /**< Per transcation
- * decoder events. */
-
TAILQ_ENTRY(DNP3Transaction_) next;
} DNP3Transaction;
TAILQ_HEAD(, CIPServiceEntry_) service_list; /**< list for CIP */
- AppLayerDecoderEvents *decoder_events; /**< per tx events */
-
TAILQ_ENTRY(ENIPTransaction_) next;
AppLayerTxData tx_data;
} ENIPTransaction;
return ((ENIPState *)alstate)->transaction_max;
}
-static AppLayerDecoderEvents *ENIPGetEvents(void *tx)
-{
- return ((ENIPTransaction *)tx)->decoder_events;
-}
-
static int ENIPStateGetEventInfo(const char *event_name, int *event_id, AppLayerEventType *event_type)
{
*event_id = SCMapEnumNameToValue(event_name, enip_decoder_event_table);
SCFree(svc);
}
- AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
+ AppLayerDecoderEventsFreeEvents(&tx->tx_data.events);
if (tx->tx_data.de_state != NULL) {
DetectEngineStateFree(tx->tx_data.de_state);
if (tx == enip_state->curr)
enip_state->curr = NULL;
- if (tx->decoder_events != NULL)
- {
- if (tx->decoder_events->cnt <= enip_state->events)
- enip_state->events -= tx->decoder_events->cnt;
+ if (tx->tx_data.events != NULL) {
+ if (tx->tx_data.events->cnt <= enip_state->events)
+ enip_state->events -= tx->tx_data.events->cnt;
else
- enip_state->events = 0;
+ enip_state->events = 0;
}
TAILQ_REMOVE(&enip_state->tx_list, tx, next);
AppLayerParserRegisterStateFuncs(IPPROTO_UDP, ALPROTO_ENIP,
ENIPStateAlloc, ENIPStateFree);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetEvents);
-
AppLayerParserRegisterGetTx(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetTxData);
AppLayerParserRegisterGetTxCnt(IPPROTO_UDP, ALPROTO_ENIP, ENIPGetTxCnt);
AppLayerParserRegisterStateFuncs(IPPROTO_TCP, ALPROTO_ENIP,
ENIPStateAlloc, ENIPStateFree);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetEvents);
-
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetTxData);
AppLayerParserRegisterGetTxCnt(IPPROTO_TCP, ALPROTO_ENIP, ENIPGetTxCnt);
if (fstate->line_state[1].db)
FTPFree(fstate->line_state[1].db, fstate->line_state[1].db_len);
- //AppLayerDecoderEventsFreeEvents(&s->decoder_events);
-
FTPTransaction *tx = NULL;
while ((tx = TAILQ_FIRST(&fstate->tx_list))) {
TAILQ_REMOVE(&fstate->tx_list, tx, next);
{
int r = HTPParseContentRange(rawvalue, range);
if (r != 0) {
- AppLayerDecoderEventsSetEventRaw(&htud->decoder_events, HTTP_DECODER_EVENT_RANGE_INVALID);
+ AppLayerDecoderEventsSetEventRaw(&htud->tx_data.events, HTTP_DECODER_EVENT_RANGE_INVALID);
s->events++;
SCLogDebug("parsing range failed, going back to normal file");
return r;
SCLogDebug("range without all information");
return -3;
} else if (range->start > range->end) {
- AppLayerDecoderEventsSetEventRaw(&htud->decoder_events, HTTP_DECODER_EVENT_RANGE_INVALID);
+ AppLayerDecoderEventsSetEventRaw(&htud->tx_data.events, HTTP_DECODER_EVENT_RANGE_INVALID);
s->events++;
SCLogDebug("invalid range");
return -4;
SCLogDebug("setting event %u", e);
if (htud) {
- AppLayerDecoderEventsSetEventRaw(&htud->decoder_events, e);
+ AppLayerDecoderEventsSetEventRaw(&htud->tx_data.events, e);
s->events++;
return;
}
if (tx != NULL) {
htud = (HtpTxUserData *) htp_tx_get_user_data(tx);
if (htud != NULL) {
- AppLayerDecoderEventsSetEventRaw(&htud->decoder_events, e);
+ AppLayerDecoderEventsSetEventRaw(&htud->tx_data.events, e);
s->events++;
return;
}
SCLogDebug("couldn't set event %u", e);
}
-static AppLayerDecoderEvents *HTPGetEvents(void *tx)
-{
- SCLogDebug("get HTTP events for TX %p", tx);
-
- HtpTxUserData *htud = (HtpTxUserData *) htp_tx_get_user_data(tx);
- if (htud != NULL) {
- SCLogDebug("has htud, htud->decoder_events %p", htud->decoder_events);
- return htud->decoder_events;
- }
-
- return NULL;
-}
-
/** \brief Function to allocates the HTTP state memory and also creates the HTTP
* connection parser to be used by the HTP library
*/
HTPFree(htud->request_headers_raw, htud->request_headers_raw_len);
if (htud->response_headers_raw)
HTPFree(htud->response_headers_raw, htud->response_headers_raw_len);
- AppLayerDecoderEventsFreeEvents(&htud->decoder_events);
+ AppLayerDecoderEventsFreeEvents(&htud->tx_data.events);
if (htud->boundary)
HTPFree(htud->boundary, htud->boundary_len);
if (htud->tx_data.de_state != NULL) {
AppLayerParserRegisterStateProgressCompletionStatus(
ALPROTO_HTTP1, HTP_REQUEST_COMPLETE, HTP_RESPONSE_COMPLETE);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_HTTP1, HTPGetEvents);
AppLayerParserRegisterGetEventInfo(IPPROTO_TCP, ALPROTO_HTTP1, HTPStateGetEventInfo);
AppLayerParserRegisterGetEventInfoById(
IPPROTO_TCP, ALPROTO_HTTP1, HTPStateGetEventInfoById);
uint32_t request_headers_raw_len;
uint32_t response_headers_raw_len;
- AppLayerDecoderEvents *decoder_events; /**< per tx events */
-
/** Holds the boundary identification string if any (used on
* multipart/form-data only)
*/
void (*Truncate)(void *, uint8_t);
FileContainer *(*StateGetFiles)(void *, uint8_t);
- AppLayerDecoderEvents *(*StateGetEvents)(void *);
int (*StateGetProgress)(void *alstate, uint8_t direction);
uint64_t (*StateGetTxCnt)(void *alstate);
SCReturn;
}
-void AppLayerParserRegisterGetEventsFunc(uint8_t ipproto, AppProto alproto,
- AppLayerDecoderEvents *(*StateGetEvents)(void *))
-{
- SCEnter();
-
- alp_ctx.ctxs[FlowGetProtoMapping(ipproto)][alproto].StateGetEvents =
- StateGetEvents;
-
- SCReturn;
-}
-
void AppLayerParserRegisterLoggerBits(uint8_t ipproto, AppProto alproto, LoggerId bits)
{
SCEnter();
AppLayerDecoderEvents *ptr = NULL;
- if (alp_ctx.ctxs[FlowGetProtoMapping(ipproto)][alproto].
- StateGetEvents != NULL)
- {
- ptr = alp_ctx.ctxs[FlowGetProtoMapping(ipproto)][alproto].
- StateGetEvents(tx);
+ /* Access events via the tx_data. */
+ AppLayerTxData *txd = AppLayerParserGetTxData(ipproto, alproto, tx);
+ if (txd != NULL && txd->events != NULL) {
+ ptr = txd->events;
}
SCReturnPtr(ptr, "AppLayerDecoderEvents *");
printf("- StateGetProgress %p\n", ctx->StateGetProgress);
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,
+ printf("- StateGetEventInfo %p StateGetEventInfoById %p\n", ctx->StateGetEventInfo,
ctx->StateGetEventInfoById);
}
void (*LocalStorageFree)(void *));
void AppLayerParserRegisterGetFilesFunc(uint8_t ipproto, AppProto alproto,
FileContainer *(*StateGetFiles)(void *, uint8_t));
-void AppLayerParserRegisterGetEventsFunc(uint8_t ipproto, AppProto proto,
- AppLayerDecoderEvents *(*StateGetEvents)(void *) __attribute__((nonnull)));
+// void AppLayerParserRegisterGetEventsFunc(uint8_t ipproto, AppProto proto,
+// AppLayerDecoderEvents *(*StateGetEvents)(void *) __attribute__((nonnull)));
void AppLayerParserRegisterLoggerFuncs(uint8_t ipproto, AppProto alproto,
LoggerId (*StateGetTxLogged)(void *, void *),
void (*StateSetTxLogged)(void *, void *, LoggerId));
AppLayerParserRegisterGetEventInfoById(p->ip_proto, alproto,
p->StateGetEventInfoById);
}
- if (p->StateGetEvents) {
- AppLayerParserRegisterGetEventsFunc(p->ip_proto, alproto,
- p->StateGetEvents);
- }
if (p->LocalStorageAlloc && p->LocalStorageFree) {
AppLayerParserRegisterLocalStorageFunc(p->ip_proto, alproto,
p->LocalStorageAlloc, p->LocalStorageFree);
const int complete_tc;
int (*StateGetProgress)(void *alstate, uint8_t direction);
- AppLayerDecoderEvents *(*StateGetEvents)(void *);
int (*StateGetEventInfo)(const char *event_name,
int *event_id, AppLayerEventType *event_type);
int (*StateGetEventInfoById)(int event_id, const char **event_name,
SCLogDebug("setting event %u", e);
if (s->curr_tx != NULL) {
- AppLayerDecoderEventsSetEventRaw(&s->curr_tx->decoder_events, e);
-// s->events++;
+ AppLayerDecoderEventsSetEventRaw(&s->curr_tx->tx_data.events, e);
+ // s->events++;
return;
}
SCLogDebug("couldn't set event %u", e);
/* Free list of MIME message recursively */
MimeDecFreeEntity(tx->msg_head);
- if (tx->decoder_events != NULL)
- AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
+ if (tx->tx_data.events != NULL)
+ AppLayerDecoderEventsFreeEvents(&tx->tx_data.events);
if (tx->tx_data.de_state != NULL)
DetectEngineStateFree(tx->tx_data.de_state);
TAILQ_REMOVE(&tx->rcpt_to_list, str, next);
SMTPStringFree(str);
}
-#if 0
- if (tx->decoder_events->cnt <= smtp_state->events)
- smtp_state->events -= tx->decoder_events->cnt;
- else
- smtp_state->events = 0;
-#endif
SCFree(tx);
}
}
}
-static AppLayerDecoderEvents *SMTPGetEvents(void *tx)
-{
- SCLogDebug("get SMTP events for TX %p", tx);
-
- return ((SMTPTransaction *)tx)->decoder_events;
-}
-
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);
AppLayerParserRegisterLocalStorageFunc(IPPROTO_TCP, ALPROTO_SMTP, SMTPLocalStorageAlloc,
SMTPLocalStorageFree);
/** the mime decoding parser state */
MimeDecParseState *mime_state;
- AppLayerDecoderEvents *decoder_events; /**< per tx events */
-
/* MAIL FROM parameters */
uint8_t *mail_from;
uint16_t mail_from_len;
return;
}
- AppLayerDecoderEventsSetEventRaw(&ssl_state->decoder_events, event);
+ AppLayerDecoderEventsSetEventRaw(&ssl_state->tx_data.events, event);
ssl_state->events++;
}
-static AppLayerDecoderEvents *SSLGetEvents(void *tx)
-{
- /* for TLS, TX == state, see GetTx */
- SSLState *ssl_state = (SSLState *)tx;
- return ssl_state->decoder_events;
-}
-
static void *SSLGetTx(void *state, uint64_t tx_id)
{
SSLState *ssl_state = (SSLState *)state;
if (ssl_state->server_connp.ja3_hash)
SCFree(ssl_state->server_connp.ja3_hash);
- AppLayerDecoderEventsFreeEvents(&ssl_state->decoder_events);
+ AppLayerDecoderEventsFreeEvents(&ssl_state->tx_data.events);
if (ssl_state->tx_data.de_state != NULL) {
DetectEngineStateFree(ssl_state->tx_data.de_state);
AppLayerParserRegisterTxFreeFunc(IPPROTO_TCP, ALPROTO_TLS, SSLStateTransactionFree);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetEvents);
-
AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_TLS, SSLGetTx);
AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetTxData);
SSLStateConnp client_connp;
SSLStateConnp server_connp;
-
- AppLayerDecoderEvents *decoder_events;
} SSLState;
void RegisterSSLParsers(void);
SCFree(tx->response_buffer);
}
- AppLayerDecoderEventsFreeEvents(&tx->decoder_events);
+ AppLayerDecoderEventsFreeEvents(&tx->tx_data.events);
SCFree(tx);
}
return 0;
}
-static AppLayerDecoderEvents *TemplateGetEvents(void *tx)
-{
- return ((TemplateTransaction *)tx)->decoder_events;
-}
-
/**
* \brief Probe the input to server to see if it looks like template.
*
if ((input_len == 1 && tx->request_buffer[0] == '\n') ||
(input_len == 2 && tx->request_buffer[0] == '\r')) {
SCLogNotice("Creating event for empty message.");
- AppLayerDecoderEventsSetEventRaw(&tx->decoder_events,
- TEMPLATE_DECODER_EVENT_EMPTY_MESSAGE);
+ AppLayerDecoderEventsSetEventRaw(&tx->tx_data.events, TEMPLATE_DECODER_EVENT_EMPTY_MESSAGE);
}
end:
TemplateStateGetEventInfo);
AppLayerParserRegisterGetEventInfoById(IPPROTO_TCP, ALPROTO_TEMPLATE,
TemplateStateGetEventInfoById);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_TCP, ALPROTO_TEMPLATE,
- TemplateGetEvents);
/* Leave this is if your parser can handle gaps, otherwise
* remove. */
/** Internal transaction ID. */
uint64_t tx_id;
- /** Application layer events that occurred
- * while parsing this transaction. */
- AppLayerDecoderEvents *decoder_events;
-
uint8_t *request_buffer;
uint32_t request_buffer_len;
return -1;
}
-static AppLayerDecoderEvents *TFTPGetEvents(void *tx)
-{
- return NULL;
-}
-
/**
* \brief Probe the input to see if it looks like tftp.
*
AppLayerParserRegisterGetEventInfo(IPPROTO_UDP, ALPROTO_TFTP,
TFTPStateGetEventInfo);
- AppLayerParserRegisterGetEventsFunc(IPPROTO_UDP, ALPROTO_TFTP,
- TFTPGetEvents);
AppLayerParserRegisterTxDataFunc(IPPROTO_UDP, ALPROTO_TFTP,
rs_tftp_get_tx_data);
projects / people / ms / suricata.git / commitdiff
