extern "C" fn(state: *mut DetectEngineState);
pub type AppLayerParserTriggerRawStreamInspectionFunc =
- extern "C" fn (flow: *const Flow, direction: i32);
+ extern "C" fn (flow: *mut Flow, direction: i32);
pub type AppLayerDecoderEventsSetEventRawFunc =
extern "C" fn (events: *mut *mut AppLayerDecoderEvents,
event: u8);
}
/// AppLayerParserTriggerRawStreamInspection wrapper
-pub fn sc_app_layer_parser_trigger_raw_stream_inspection(flow: *const Flow, direction: i32) {
+pub fn sc_app_layer_parser_trigger_raw_stream_inspection(flow: *mut Flow, direction: i32) {
unsafe {
if let Some(c) = SC {
(c.AppLayerParserTriggerRawStreamInspection)(flow, direction);
tc_gap: bool,
ts_ssn_gap: bool,
tc_ssn_gap: bool,
- pub flow: Option<*const Flow>,
+ pub flow: Option<*mut Flow>,
state_data: AppLayerStateData,
}
///
/// Returns the number of messages parsed.
fn parse_request_tcp(
- &mut self, flow: *const Flow, stream_slice: StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: StreamSlice,
) -> AppLayerResult {
let input = stream_slice.as_slice();
if self.gap {
///
/// Returns the number of messages parsed.
fn parse_response_tcp(
- &mut self, flow: *const Flow, stream_slice: StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: StreamSlice,
) -> AppLayerResult {
let input = stream_slice.as_slice();
if self.gap {
assert_eq!(
AppLayerResult::ok(),
state.parse_request_tcp(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOSERVER, 0)
)
);
assert_eq!(
AppLayerResult::incomplete(0, 52),
state.parse_request_tcp(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOSERVER, 0)
)
);
assert_eq!(
AppLayerResult::ok(),
state.parse_response_tcp(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOCLIENT, 0)
)
);
assert_eq!(
AppLayerResult::incomplete(0, 103),
state.parse_response_tcp(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOCLIENT, 0)
)
);
];
// A NULL flow.
- let flow = std::ptr::null();
+ let flow = std::ptr::null_mut();
let mut state = DNSState::new();
assert_eq!(
#[test]
fn test_dns_tcp_parser_split_payload() {
// A NULL flow.
- let flow = std::ptr::null();
+ let flow = std::ptr::null_mut();
/* incomplete payload */
#[rustfmt::skip]
}
}
fn parse_tcp(
- &mut self, stream_slice: StreamSlice, request: bool, flow: *const Flow,
+ &mut self, stream_slice: StreamSlice, request: bool, flow: *mut Flow,
) -> AppLayerResult {
let input = stream_slice.as_slice();
if request {
/// Parse a Kerberos request message
///
/// Returns 0 in case of success, or -1 on error
- fn parse(&mut self, i: &[u8], flow: *const Flow, direction: Direction) -> i32 {
+ fn parse(&mut self, i: &[u8], flow: *mut Flow, direction: Direction) -> i32 {
match der_read_element_header(i) {
Ok((_rem, hdr)) => {
// Kerberos messages start with an APPLICATION header
return AppLayerResult::ok();
}
- fn parse_response(&mut self, flow: *const Flow, stream_slice: StreamSlice) -> AppLayerResult {
+ fn parse_response(&mut self, flow: *mut Flow, stream_slice: StreamSlice) -> AppLayerResult {
let input = stream_slice.as_slice();
if input.is_empty() {
return AppLayerResult::ok();
// Read/Write Multiple Registers Request
assert_eq!(
modbus.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
&[
0x12, 0x34, // Transaction ID
0x00, 0x00, // Protocol ID
// Force Listen Only Mode
assert_eq!(
modbus.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
&[
0x0A, 0x00, // Transaction ID
0x00, 0x00, // Protocol ID
// Encapsulated Interface Transport (MEI)
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x10, // Transaction ID
0x00, 0x00, // Protocol ID
// Unassigned/Unknown function
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x0A, // Transaction ID
0x00, 0x00, // Protocol ID
// Read Coils request
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x00, // Transaction ID
0x00, 0x00, // Protocol ID
// Read Inputs Register request
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x0A, // Transaction ID
0x00, 0x00, // Protocol ID
// Origin: https://github.com/bro/bro/blob/master/testing/btest/Traces/modbus/modbus.trace
// Read Coils Response
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x01, // Transaction ID
0x00, 0x00, // Protocol ID
// Origin: https://github.com/bro/bro/blob/master/testing/btest/Traces/modbus/modbus.trace
// Write Single Register Response
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x01, // Transaction ID
0x00, 0x00, // Protocol ID
// Origin: https://github.com/bro/bro/blob/master/testing/btest/Traces/modbus/modbus.trace
// Write Single Register Response
assert_eq!(
- modbus.parse(std::ptr::null(),
+ modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x00, // Transaction ID
0x00, 0x00, // Protocol ID
}
pub fn parse(
- &mut self, flow: *const Flow, input: &[u8], direction: Direction,
+ &mut self, flow: *mut Flow, input: &[u8], direction: Direction,
) -> AppLayerResult {
let mut rest = input;
while !rest.is_empty() {
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_COILS_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), RD_COILS_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_COILS_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), RD_COILS_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), WR_MULT_REG_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), WR_MULT_REG_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), WR_MULT_REG_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), WR_MULT_REG_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_WR_MULT_REG_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), RD_WR_MULT_REG_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_WR_MULT_REG_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), RD_WR_MULT_REG_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
FORCE_LISTEN_ONLY_MODE,
Direction::ToServer
)
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), INVALID_PROTO_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), INVALID_PROTO_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_COILS_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), RD_COILS_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::incomplete(15, 4),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
INVALID_LEN_WR_MULT_REG_REQ,
Direction::ToServer
)
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_COILS_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), RD_COILS_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_COILS_ERR_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), RD_COILS_ERR_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::incomplete(0, 12),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
&RD_COILS_REQ[0..(RD_COILS_REQ.len() - 3)],
Direction::ToServer
)
assert_eq!(state.transactions.len(), 0);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), RD_COILS_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), RD_COILS_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), &req, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), &req, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 2);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), &resp, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), &resp, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 2);
assert_eq!(
AppLayerResult::ok(),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
EXCEEDED_LEN_WR_MULT_REG_REQ,
Direction::ToServer
)
assert_eq!(
AppLayerResult::ok(),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
INVALID_PDU_WR_MULT_REG_REQ,
Direction::ToServer
)
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), MASK_WR_REG_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), MASK_WR_REG_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), MASK_WR_REG_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), MASK_WR_REG_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), WR_SINGLE_REG_REQ, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), WR_SINGLE_REG_REQ, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), WR_SINGLE_REG_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), WR_SINGLE_REG_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
INVALID_MASK_WR_REG_REQ,
Direction::ToServer
)
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), MASK_WR_REG_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), MASK_WR_REG_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
assert_eq!(
AppLayerResult::ok(),
state.parse(
- std::ptr::null(),
+ std::ptr::null_mut(),
INVALID_WR_SINGLE_REG_REQ,
Direction::ToServer
)
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), WR_SINGLE_REG_RESP, Direction::ToClient)
+ state.parse(std::ptr::null_mut(), WR_SINGLE_REG_RESP, Direction::ToClient)
);
assert_eq!(state.transactions.len(), 1);
let mut state = ModbusState::new();
assert_eq!(
AppLayerResult::ok(),
- state.parse(std::ptr::null(), INVALID_FUNC_CODE, Direction::ToServer)
+ state.parse(std::ptr::null_mut(), INVALID_FUNC_CODE, Direction::ToServer)
);
assert_eq!(state.transactions.len(), 1);
// without having to introduce lifetimes etc.
// This is the reason for the code duplication below. Maybe there is a
// more concise way to do it, but this works for now.
- fn handle_msg(&mut self, flow: *const Flow, msg: MQTTMessage, toclient: bool) {
+ fn handle_msg(&mut self, flow: *mut Flow, msg: MQTTMessage, toclient: bool) {
let tx_len = self.transactions.len();
match msg.op {
MQTTOperation::CONNECT(ref conn) => {
}
}
- fn parse_request(&mut self, flow: *const Flow, stream_slice: StreamSlice) -> AppLayerResult {
+ fn parse_request(&mut self, flow: *mut Flow, stream_slice: StreamSlice) -> AppLayerResult {
let input = stream_slice.as_slice();
let mut current = input;
return AppLayerResult::ok();
}
- fn parse_response(&mut self, flow: *const Flow, stream_slice: StreamSlice) -> AppLayerResult {
+ fn parse_response(&mut self, flow: *mut Flow, stream_slice: StreamSlice) -> AppLayerResult {
let input = stream_slice.as_slice();
let mut current = input;
// TODO maybe not enough users to justify a func
pub fn mark_response_tx_done(
- &mut self, flow: *const Flow, xid: u32, rpc_status: u32, nfs_status: u32, resp_handle: &[u8],
+ &mut self, flow: *mut Flow, xid: u32, rpc_status: u32, nfs_status: u32, resp_handle: &[u8],
) {
if let Some(mytx) = self.get_tx_by_xid(xid) {
mytx.tx_data.updated_tc = true;
/// complete request record
fn process_request_record(
- &mut self, flow: *const Flow, stream_slice: &StreamSlice, r: &RpcPacket,
+ &mut self, flow: *mut Flow, stream_slice: &StreamSlice, r: &RpcPacket,
) {
SCLogDebug!(
"REQUEST {} procedure {} ({}) blob size {}",
return None;
}
- pub fn process_write_record<'b>(&mut self, flow: *const Flow, r: &RpcPacket<'b>, w: &Nfs3RequestWrite<'b>) -> u32 {
+ pub fn process_write_record<'b>(&mut self, flow: *mut Flow, r: &RpcPacket<'b>, w: &Nfs3RequestWrite<'b>) -> u32 {
let mut fill_bytes = 0;
let pad = w.count % 4;
if pad != 0 {
}
fn process_partial_write_request_record<'b>(
- &mut self, flow: *const Flow, r: &RpcPacket<'b>, w: &Nfs3RequestWrite<'b>,
+ &mut self, flow: *mut Flow, r: &RpcPacket<'b>, w: &Nfs3RequestWrite<'b>,
) -> u32 {
SCLogDebug!(
"REQUEST {} procedure {} blob size {}",
}
fn process_reply_record(
- &mut self, flow: *const Flow, stream_slice: &StreamSlice, r: &RpcReplyPacket,
+ &mut self, flow: *mut Flow, stream_slice: &StreamSlice, r: &RpcReplyPacket,
) -> u32 {
let mut xidmap;
match self.requestmap.remove(&r.hdr.xid) {
// update in progress chunks for file transfers
// return how much data we consumed
- fn filetracker_update(&mut self, flow: *const Flow, direction: Direction, data: &[u8], gap_size: u32) -> u32 {
+ fn filetracker_update(&mut self, flow: *mut Flow, direction: Direction, data: &[u8], gap_size: u32) -> u32 {
let mut chunk_left = if direction == Direction::ToServer {
self.ts_chunk_left
} else {
/// xidmapr is an Option as it's already removed from the map if we
/// have a complete record. Otherwise we do a lookup ourselves.
pub fn process_read_record<'b>(
- &mut self, flow: *const Flow, r: &RpcReplyPacket<'b>, reply: &NfsReplyRead<'b>,
+ &mut self, flow: *mut Flow, r: &RpcReplyPacket<'b>, reply: &NfsReplyRead<'b>,
xidmapr: Option<&NFSRequestXidMap>,
) -> u32 {
let file_name;
}
fn process_partial_read_reply_record<'b>(
- &mut self, flow: *const Flow, r: &RpcReplyPacket<'b>, reply: &NfsReplyRead<'b>,
+ &mut self, flow: *mut Flow, r: &RpcReplyPacket<'b>, reply: &NfsReplyRead<'b>,
) -> u32 {
SCLogDebug!(
"REPLY {} to procedure READ blob size {} / {}",
pub fn parse_tcp_data_ts_gap(&mut self, gap_size: u32) -> AppLayerResult {
SCLogDebug!("parse_tcp_data_ts_gap ({})", gap_size);
let gap = vec![0; gap_size as usize];
- let consumed = self.filetracker_update(std::ptr::null(), Direction::ToServer, &gap, gap_size);
+ let consumed = self.filetracker_update(std::ptr::null_mut(), Direction::ToServer, &gap, gap_size);
if consumed > gap_size {
SCLogDebug!("consumed more than GAP size: {} > {}", consumed, gap_size);
return AppLayerResult::ok();
pub fn parse_tcp_data_tc_gap(&mut self, gap_size: u32) -> AppLayerResult {
SCLogDebug!("parse_tcp_data_tc_gap ({})", gap_size);
let gap = vec![0; gap_size as usize];
- let consumed = self.filetracker_update(std::ptr::null(), Direction::ToClient, &gap, gap_size);
+ let consumed = self.filetracker_update(std::ptr::null_mut(), Direction::ToClient, &gap, gap_size);
if consumed > gap_size {
SCLogDebug!("consumed more than GAP size: {} > {}", consumed, gap_size);
return AppLayerResult::ok();
/// Handle partial records
fn parse_tcp_partial_data_ts<'b>(
- &mut self, flow: *const Flow, base_input: &'b [u8], cur_i: &'b [u8], phdr: &RpcRequestPacketPartial,
+ &mut self, flow: *mut Flow, base_input: &'b [u8], cur_i: &'b [u8], phdr: &RpcRequestPacketPartial,
rec_size: usize,
) -> AppLayerResult {
// special case: avoid buffering file write blobs
/// Parsing function, handling TCP chunks fragmentation
pub fn parse_tcp_data_ts(
- &mut self, flow: *const Flow, stream_slice: &StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: &StreamSlice,
) -> AppLayerResult {
let mut cur_i = stream_slice.as_slice();
// take care of in progress file chunk transfers
/// Handle partial records
fn parse_tcp_partial_data_tc<'b>(
- &mut self, flow: *const Flow, base_input: &'b [u8], cur_i: &'b [u8], phdr: &RpcPacketHeader, rec_size: usize,
+ &mut self, flow: *mut Flow, base_input: &'b [u8], cur_i: &'b [u8], phdr: &RpcPacketHeader, rec_size: usize,
) -> AppLayerResult {
// special case: avoid buffering file read blobs
// as these can be large.
/// Parsing function, handling TCP chunks fragmentation
pub fn parse_tcp_data_tc(
- &mut self, flow: *const Flow, stream_slice: &StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: &StreamSlice,
) -> AppLayerResult {
let mut cur_i = stream_slice.as_slice();
// take care of in progress file chunk transfers
}
/// Parsing function
pub fn parse_udp_ts(
- &mut self, flow: *const Flow, stream_slice: &StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: &StreamSlice,
) -> AppLayerResult {
let input = stream_slice.as_slice();
SCLogDebug!("parse_udp_ts ({})", input.len());
/// Parsing function
pub fn parse_udp_tc(
- &mut self, flow: *const Flow, stream_slice: &StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: &StreamSlice,
) -> AppLayerResult {
let input = stream_slice.as_slice();
SCLogDebug!("parse_udp_tc ({})", input.len());
self.requestmap.insert(r.hdr.xid, xidmap);
}
- pub fn process_reply_record_v2(&mut self, flow: *const Flow, r: &RpcReplyPacket, xidmap: &NFSRequestXidMap) {
+ pub fn process_reply_record_v2(&mut self, flow: *mut Flow, r: &RpcReplyPacket, xidmap: &NFSRequestXidMap) {
let mut nfs_status = 0;
let resp_handle = Vec::new();
impl NFSState {
/// complete NFS3 request record
- pub fn process_request_record_v3(&mut self, flow: *const Flow, r: &RpcPacket) {
+ pub fn process_request_record_v3(&mut self, flow: *mut Flow, r: &RpcPacket) {
SCLogDebug!(
"REQUEST {} procedure {} ({}) blob size {}",
r.hdr.xid,
self.requestmap.insert(r.hdr.xid, xidmap);
}
- pub fn process_reply_record_v3(&mut self, flow: *const Flow, r: &RpcReplyPacket, xidmap: &mut NFSRequestXidMap) {
+ pub fn process_reply_record_v3(&mut self, flow: *mut Flow, r: &RpcReplyPacket, xidmap: &mut NFSRequestXidMap) {
let mut nfs_status = 0;
let mut resp_handle = Vec::new();
}
fn compound_response<'b>(
- &mut self, flow: *const Flow, r: &RpcReplyPacket<'b>, cr: &Nfs4ResponseCompoundRecord<'b>,
+ &mut self, flow: *mut Flow, r: &RpcReplyPacket<'b>, cr: &Nfs4ResponseCompoundRecord<'b>,
xidmap: &mut NFSRequestXidMap,
) {
let mut insert_filename_with_getfh = false;
}
}
- pub fn process_reply_record_v4(&mut self, flow: *const Flow, r: &RpcReplyPacket, xidmap: &mut NFSRequestXidMap) {
+ pub fn process_reply_record_v4(&mut self, flow: *mut Flow, r: &RpcReplyPacket, xidmap: &mut NFSRequestXidMap) {
if xidmap.procedure == NFSPROC4_COMPOUND {
let mut data = r.prog_data;
}
}
- fn parse_request(&mut self, flow: *const Flow, input: &[u8]) -> AppLayerResult {
+ fn parse_request(&mut self, flow: *mut Flow, input: &[u8]) -> AppLayerResult {
// We're not interested in empty requests.
if input.is_empty() {
return AppLayerResult::ok();
.find(|tx| tx.response.is_none())
}
- fn parse_request(&mut self, flow: *const Flow, input: &[u8]) -> AppLayerResult {
+ fn parse_request(&mut self, flow: *mut Flow, input: &[u8]) -> AppLayerResult {
// We're not interested in empty requests.
if input.is_empty() {
return AppLayerResult::ok();
}
/// parse buffer captures from client to server
- fn parse_ts(&mut self, flow: *const Flow, input: &[u8]) -> AppLayerResult {
+ fn parse_ts(&mut self, flow: *mut Flow, input: &[u8]) -> AppLayerResult {
// no need to process input buffer
if self.bypass_parsing {
return AppLayerResult::ok();
}
/// parse buffer captures from server to client
- fn parse_tc(&mut self, flow: *const Flow, input: &[u8]) -> AppLayerResult {
+ fn parse_tc(&mut self, flow: *mut Flow, input: &[u8]) -> AppLayerResult {
// no need to process input buffer
if self.bypass_parsing {
return AppLayerResult::ok();
// will consume 0, request length + 1
assert_eq!(
AppLayerResult::incomplete(0, 9),
- state.parse_ts(std::ptr::null(), buf_1)
+ state.parse_ts(std::ptr::null_mut(), buf_1)
);
assert_eq!(0, state.transactions.len());
// exactly aligns with transaction
assert_eq!(
AppLayerResult::ok(),
- state.parse_ts(std::ptr::null(), buf_2)
+ state.parse_ts(std::ptr::null_mut(), buf_2)
);
assert_eq!(1, state.transactions.len());
let item = RdpTransactionItem::X224ConnectionRequest(X224ConnectionRequest {
fn test_parse_ts_other() {
let buf: &[u8] = &[0x03, 0x00, 0x00, 0x01, 0x00];
let mut state = RdpState::new();
- assert_eq!(AppLayerResult::err(), state.parse_ts(std::ptr::null(), buf));
+ assert_eq!(AppLayerResult::err(), state.parse_ts(std::ptr::null_mut(), buf));
}
#[test]
// will consume 0, request length + 1
assert_eq!(
AppLayerResult::incomplete(0, 6),
- state.parse_tc(std::ptr::null(), buf_1)
+ state.parse_tc(std::ptr::null_mut(), buf_1)
);
assert_eq!(0, state.transactions.len());
// exactly aligns with transaction
assert_eq!(
AppLayerResult::ok(),
- state.parse_tc(std::ptr::null(), buf_2)
+ state.parse_tc(std::ptr::null_mut(), buf_2)
);
assert_eq!(1, state.transactions.len());
let item = RdpTransactionItem::McsConnectResponse(McsConnectResponse {});
fn test_parse_tc_other() {
let buf: &[u8] = &[0x03, 0x00, 0x00, 0x01, 0x00];
let mut state = RdpState::new();
- assert_eq!(AppLayerResult::err(), state.parse_tc(std::ptr::null(), buf));
+ assert_eq!(AppLayerResult::err(), state.parse_tc(std::ptr::null_mut(), buf));
}
#[test]
return None;
}
- fn parse_request(&mut self, flow: *const Flow, stream_slice: StreamSlice) -> AppLayerResult {
+ fn parse_request(&mut self, flow: *mut Flow, stream_slice: StreamSlice) -> AppLayerResult {
let input = stream_slice.as_slice();
// We're not interested in empty requests.
}
}
- fn parse_response(&mut self, flow: *const Flow, stream_slice: StreamSlice) -> AppLayerResult {
+ fn parse_response(&mut self, flow: *mut Flow, stream_slice: StreamSlice) -> AppLayerResult {
let input = stream_slice.as_slice();
// We're not interested in empty responses.
if input.is_empty() {
0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e,
];
let r = state.parse_response(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(buf, STREAM_START, 0),
);
//The buffer values correspond to Server Protocol version: 003.008
// Same buffer is used for both functions due to similar values in request and response
init_state.parse_response(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[0..12], STREAM_START, 0),
);
let mut ok_state = parser::RFBGlobalState::TSClientProtocolVersion;
//The buffer values correspond to Client Protocol version: 003.008
init_state.parse_request(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[0..12], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TCSupportedSecurityTypes;
assert_eq!(init_state.state, ok_state);
init_state.parse_response(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[12..14], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TSSecurityTypeSelection;
assert_eq!(init_state.state, ok_state);
init_state.parse_request(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[14..15], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TCVncChallenge;
//The buffer values correspond to Server Authentication challenge: 547b7a6f36a154db03a2575c6f2a4ec5
// Same buffer is used for both functions due to similar values in request and response
init_state.parse_response(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[15..31], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TSVncResponse;
//The buffer values correspond to Client Authentication response: 547b7a6f36a154db03a2575c6f2a4ec5
init_state.parse_request(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[15..31], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TCSecurityResult;
assert_eq!(init_state.state, ok_state);
init_state.parse_response(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[31..35], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TSClientInit;
assert_eq!(init_state.state, ok_state);
init_state.parse_request(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[35..36], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::TCServerInit;
assert_eq!(init_state.state, ok_state);
init_state.parse_response(
- std::ptr::null(),
+ std::ptr::null_mut(),
StreamSlice::from_slice(&buf[36..90], STREAM_START, 0),
);
ok_state = parser::RFBGlobalState::Skip;
}
fn parse_request_tcp(
- &mut self, flow: *const Flow, stream_slice: StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: StreamSlice,
) -> AppLayerResult {
let input = stream_slice.as_slice();
if input.is_empty() {
}
fn parse_response_tcp(
- &mut self, flow: *const Flow, stream_slice: StreamSlice,
+ &mut self, flow: *mut Flow, stream_slice: StreamSlice,
) -> AppLayerResult {
let input = stream_slice.as_slice();
if input.is_empty() {
}
fn parse_banner(
- &mut self, input: &[u8], resp: bool, pstate: *mut AppLayerParserState, flow: *const Flow,
+ &mut self, input: &[u8], resp: bool, pstate: *mut AppLayerParserState, flow: *mut Flow,
stream_slice: &StreamSlice,
) -> AppLayerResult {
let hdr = if !resp {
}
fn parse(
- &mut self, stream_slice: StreamSlice, direction: Direction, flow: *const Flow,
+ &mut self, stream_slice: StreamSlice, direction: Direction, flow: *mut Flow,
) -> AppLayerResult {
let to_skip = if direction == Direction::ToClient {
&mut self.to_skip_tc
projects / thirdparty / suricata.git / commitdiff
