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

rust: fix prototype for AppLayerParserTriggerRawStreamInspection

Browse Source 
Ticket: 7762

As it modifies the flow indeed
pull/13483/head
Philippe Antoine 10 months ago committed by Victor Julien
parent f8168493f6
commit bca6cbfb04
20 changed files with 101 additions and 101 deletions
Show Stats Download Patch File Download Diff File

4
rust/src/core.rs
Unescape Escape View File

@ -95,7 +95,7 @@ pub type DetectEngineStateFreeFunc =
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);
@ -222,7 +222,7 @@ pub fn sc_generic_var_free(gvar: *mut GenericVar)
}
/// 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);

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

@ -331,7 +331,7 @@ pub struct DCERPCState {
tc_gap: bool,
ts_ssn_gap: bool,
tc_ssn_gap: bool,
pub flow: Option<*const Flow>,
pub flow: Option<*mut Flow>,
state_data: AppLayerStateData,
}

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

@ -702,7 +702,7 @@ impl DNSState {
///
/// 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 {
@ -766,7 +766,7 @@ impl DNSState {
///
/// 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 {
@ -1405,7 +1405,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse_request_tcp(
std::ptr::null(),
std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOSERVER, 0)
)
);
@ -1445,7 +1445,7 @@ mod tests {
assert_eq!(
AppLayerResult::incomplete(0, 52),
state.parse_request_tcp(
std::ptr::null(),
std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOSERVER, 0)
)
);
@ -1490,7 +1490,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse_response_tcp(
std::ptr::null(),
std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOCLIENT, 0)
)
);
@ -1538,7 +1538,7 @@ mod tests {
assert_eq!(
AppLayerResult::incomplete(0, 103),
state.parse_response_tcp(
std::ptr::null(),
std::ptr::null_mut(),
StreamSlice::from_slice(&request, STREAM_TOCLIENT, 0)
)
);
@ -1747,7 +1747,7 @@ mod tests {
];
// A NULL flow.
let flow = std::ptr::null();
let flow = std::ptr::null_mut();
let mut state = DNSState::new();
assert_eq!(
@ -1759,7 +1759,7 @@ mod tests {
#[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]

2
rust/src/enip/enip.rs
Unescape Escape View File

@ -273,7 +273,7 @@ impl EnipState {
}
}
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 {

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

@ -128,7 +128,7 @@ impl KRB5State {
/// 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

2
rust/src/ldap/ldap.rs
Unescape Escape View File

@ -265,7 +265,7 @@ impl LdapState {
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();

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

@ -612,7 +612,7 @@ mod test {
// Read/Write Multiple Registers Request
assert_eq!(
modbus.parse(
std::ptr::null(),
std::ptr::null_mut(),
&[
0x12, 0x34, // Transaction ID
0x00, 0x00, // Protocol ID
@ -985,7 +985,7 @@ mod test {
// Force Listen Only Mode
assert_eq!(
modbus.parse(
std::ptr::null(),
std::ptr::null_mut(),
&[
0x0A, 0x00, // Transaction ID
0x00, 0x00, // Protocol ID
@ -1015,7 +1015,7 @@ mod test {
// 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
@ -1044,7 +1044,7 @@ mod test {
// Unassigned/Unknown function
assert_eq!(
modbus.parse(std::ptr::null(),
modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x0A, // Transaction ID
0x00, 0x00, // Protocol ID
@ -1071,7 +1071,7 @@ mod test {
// Read Coils request
assert_eq!(
modbus.parse(std::ptr::null(),
modbus.parse(std::ptr::null_mut(),
&[
0x00, 0x00, // Transaction ID
0x00, 0x00, // Protocol ID
@ -1176,7 +1176,7 @@ mod test {
// 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
@ -1326,7 +1326,7 @@ mod test {
// 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
@ -1370,7 +1370,7 @@ mod test {
// 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
@ -1412,7 +1412,7 @@ mod test {
// 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

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

@ -185,7 +185,7 @@ impl ModbusState {
}
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() {
@ -996,7 +996,7 @@ mod tests {
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);
@ -1013,7 +1013,7 @@ mod tests {
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);
@ -1028,7 +1028,7 @@ mod tests {
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);
@ -1046,7 +1046,7 @@ mod tests {
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);
@ -1067,7 +1067,7 @@ mod tests {
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);
@ -1091,7 +1091,7 @@ mod tests {
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);
@ -1112,7 +1112,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse(
std::ptr::null(),
std::ptr::null_mut(),
FORCE_LISTEN_ONLY_MODE,
Direction::ToServer
)
@ -1139,7 +1139,7 @@ mod tests {
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);
@ -1153,7 +1153,7 @@ mod tests {
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);
@ -1169,7 +1169,7 @@ mod tests {
assert_eq!(
AppLayerResult::incomplete(15, 4),
state.parse(
std::ptr::null(),
std::ptr::null_mut(),
INVALID_LEN_WR_MULT_REG_REQ,
Direction::ToServer
)
@ -1195,7 +1195,7 @@ mod tests {
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);
@ -1212,7 +1212,7 @@ mod tests {
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);
@ -1234,7 +1234,7 @@ mod tests {
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
)
@ -1242,7 +1242,7 @@ mod tests {
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);
@ -1267,7 +1267,7 @@ mod tests {
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);
@ -1296,7 +1296,7 @@ mod tests {
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);
@ -1323,7 +1323,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse(
std::ptr::null(),
std::ptr::null_mut(),
EXCEEDED_LEN_WR_MULT_REG_REQ,
Direction::ToServer
)
@ -1341,7 +1341,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse(
std::ptr::null(),
std::ptr::null_mut(),
INVALID_PDU_WR_MULT_REG_REQ,
Direction::ToServer
)
@ -1360,7 +1360,7 @@ mod tests {
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);
@ -1378,7 +1378,7 @@ mod tests {
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);
@ -1400,7 +1400,7 @@ mod tests {
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);
@ -1417,7 +1417,7 @@ mod tests {
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);
@ -1439,7 +1439,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse(
std::ptr::null(),
std::ptr::null_mut(),
INVALID_MASK_WR_REG_REQ,
Direction::ToServer
)
@ -1454,7 +1454,7 @@ mod tests {
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);
@ -1477,7 +1477,7 @@ mod tests {
assert_eq!(
AppLayerResult::ok(),
state.parse(
std::ptr::null(),
std::ptr::null_mut(),
INVALID_WR_SINGLE_REG_REQ,
Direction::ToServer
)
@ -1492,7 +1492,7 @@ mod tests {
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);
@ -1513,7 +1513,7 @@ mod tests {
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);

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

@ -221,7 +221,7 @@ impl MQTTState {
// 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) => {
@ -413,7 +413,7 @@ impl MQTTState {
}
}
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;
@ -500,7 +500,7 @@ impl MQTTState {
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;

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

@ -512,7 +512,7 @@ impl NFSState {
// 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;
@ -883,7 +883,7 @@ impl NFSState {
/// 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 {}",
@ -965,7 +965,7 @@ impl NFSState {
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 {
@ -1057,7 +1057,7 @@ impl NFSState {
}
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 {}",
@ -1074,7 +1074,7 @@ impl NFSState {
}
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) {
@ -1132,7 +1132,7 @@ impl NFSState {
// 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 {
@ -1262,7 +1262,7 @@ impl NFSState {
/// 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;
@ -1429,7 +1429,7 @@ impl NFSState {
}
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 {} / {}",
@ -1453,7 +1453,7 @@ impl NFSState {
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();
@ -1467,7 +1467,7 @@ impl NFSState {
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();
@ -1480,7 +1480,7 @@ impl NFSState {
/// 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
@ -1541,7 +1541,7 @@ impl NFSState {
/// 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
@ -1670,7 +1670,7 @@ impl NFSState {
/// 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.
@ -1731,7 +1731,7 @@ impl NFSState {
/// 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
@ -1855,7 +1855,7 @@ impl NFSState {
}
/// 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());
@ -1897,7 +1897,7 @@ impl NFSState {
/// 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());

2
rust/src/nfs/nfs2.rs
Unescape Escape View File

@ -103,7 +103,7 @@ impl NFSState {
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();

4
rust/src/nfs/nfs3.rs
Unescape Escape View File

@ -29,7 +29,7 @@ use nom7::IResult;
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,
@ -196,7 +196,7 @@ impl NFSState {
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();

4
rust/src/nfs/nfs4.rs
Unescape Escape View File

@ -321,7 +321,7 @@ impl NFSState {
}
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;
@ -396,7 +396,7 @@ impl NFSState {
}
}
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;

2
rust/src/pgsql/pgsql.rs
Unescape Escape View File

@ -369,7 +369,7 @@ impl PgsqlState {
}
}
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();

2
rust/src/pop3/pop3.rs
Unescape Escape View File

@ -173,7 +173,7 @@ impl POP3State {
.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();

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

@ -168,7 +168,7 @@ impl RdpState {
}
/// 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();
@ -274,7 +274,7 @@ impl RdpState {
}
/// 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();
@ -581,13 +581,13 @@ mod tests {
// 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 {
@ -609,7 +609,7 @@ mod tests {
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]
@ -620,13 +620,13 @@ mod tests {
// 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 {});
@ -637,7 +637,7 @@ mod tests {
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]

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

@ -184,7 +184,7 @@ impl RFBState {
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.
@ -420,7 +420,7 @@ impl RFBState {
}
}
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() {
@ -971,7 +971,7 @@ mod test {
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),
);
@ -1012,7 +1012,7 @@ mod test {
//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;
@ -1020,21 +1020,21 @@ mod test {
//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;
@ -1043,7 +1043,7 @@ mod test {
//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;
@ -1051,28 +1051,28 @@ mod test {
//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;

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

@ -158,7 +158,7 @@ impl SIPState {
}
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() {
@ -257,7 +257,7 @@ impl SIPState {
}
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() {

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

@ -333,7 +333,7 @@ impl SSHState {
}
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 {

2
rust/src/websocket/websocket.rs
Unescape Escape View File

@ -148,7 +148,7 @@ impl WebSocketState {
}
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

Write Preview
Loading…
Cancel
Save