fn parse_request(&mut self, input: &[u8]) -> AppLayerResult {
// We're not interested in empty requests.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
}
let mut start = input;
- while start.len() > 0 {
+ while !start.is_empty() {
match parser::parse_message(start) {
Ok((rem, request)) => {
start = rem;
fn parse_response(&mut self, input: &[u8]) -> AppLayerResult {
// We're not interested in empty responses.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
self.response_gap = false;
}
let mut start = input;
- while start.len() > 0 {
+ while !start.is_empty() {
match parser::parse_message(start) {
Ok((rem, response)) => {
start = rem;
{
let tx = cast_pointer!(tx, TemplateTransaction);
if let Some(ref request) = tx.request {
- if request.len() > 0 {
+ if !request.is_empty() {
*len = request.len() as u32;
*buf = request.as_ptr();
return 1;
{
let tx = cast_pointer!(tx, TemplateTransaction);
if let Some(ref response) = tx.response {
- if response.len() > 0 {
+ if !response.is_empty() {
*len = response.len() as u32;
*buf = response.as_ptr();
return 1;
}
pub fn handle_gap_ts(&mut self) -> u8 {
- if self.buffer_ts.len() > 0 {
+ if !self.buffer_ts.is_empty() {
self.buffer_ts.clear();
}
return 0;
}
pub fn handle_gap_tc(&mut self) -> u8 {
- if self.buffer_tc.len() > 0 {
+ if !self.buffer_tc.is_empty() {
self.buffer_tc.clear();
}
return 0;
}
};
- if self.data_needed_for_dir != direction && buffer.len() != 0 {
+ if self.data_needed_for_dir != direction && !buffer.is_empty() {
return AppLayerResult::err();
}
&DHCPOptionWrapper::Generic(ref option) => {
match code {
DHCP_OPT_TYPE => {
- if option.data.len() > 0 {
+ if !option.data.is_empty() {
return Some(option.data[0]);
}
}
}
}
DHCP_OPT_HOSTNAME => {
- if option.data.len() > 0 {
+ if !option.data.is_empty() {
js.set_string_from_bytes("hostname",
&option.data)?;
}
}
fn log_opt_type(&self, js: &mut JsonBuilder, option: &DHCPOptGeneric) -> Result<(), JsonError> {
- if option.data.len() > 0 {
+ if !option.data.is_empty() {
let dhcp_type = match option.data[0] {
DHCP_TYPE_DISCOVER => "discover",
DHCP_TYPE_OFFER => "offer",
DHCP_PARAM_TFTP_SERVER_IP => "tftp_server_ip",
_ => ""
};
- if param.len() > 0 {
+ if !param.is_empty() {
js.append_string(param)?;
}
}
let mut cur_i = input;
let mut consumed = 0;
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
if cur_i.len() == 1 {
return AppLayerResult::incomplete(consumed as u32, 2 as u32);
}
let mut cur_i = input;
let mut consumed = 0;
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
if cur_i.len() == 1 {
return AppLayerResult::incomplete(consumed as u32, 2 as u32);
}
if let &Some(ref request) = &tx.request {
if (i as usize) < request.queries.len() {
let query = &request.queries[i as usize];
- if query.name.len() > 0 {
+ if !query.name.is_empty() {
*len = query.name.len() as u32;
*buf = query.name.as_ptr();
return 1;
if let &Some(ref request) = &tx.request {
if (i as usize) < request.queries.len() {
let query = &request.queries[i as usize];
- if query.name.len() > 0 {
+ if !query.name.is_empty() {
*rrtype = query.rrtype;
return 1;
}
}
js.set_string("rcode", &dns_rcode_string(header.flags))?;
- if response.answers.len() > 0 {
+ if !response.answers.is_empty() {
let mut js_answers = JsonBuilder::new_array();
// For grouped answers we use a HashMap keyed by the rrtype.
}
- if response.authorities.len() > 0 {
+ if !response.authorities.is_empty() {
js.open_array("authorities")?;
for auth in &response.authorities {
let auth_detail = dns_log_json_answer_detail(auth)?;
let mut count = 0;
loop {
- if pos.len() == 0 {
+ if pos.is_empty() {
break;
}
break;
} else if len & 0b1100_0000 == 0 {
let (rem, label) = length_data(be_u8)(pos)?;
- if name.len() > 0 {
+ if !name.is_empty() {
name.push(b'.');
}
name.extend(label);
// For now we have some remainder data as there is an
// additional record type we don't parse yet.
- assert!(rem.len() > 0);
+ assert!(!rem.is_empty());
assert_eq!(request.header, DNSHeader {
tx_id: 0x8d32,
// For now we have some remainder data as there is an
// additional record type we don't parse yet.
- assert!(rem.len() > 0);
+ assert!(!rem.is_empty());
assert_eq!(response.header, DNSHeader{
tx_id: 0x8295,
pub fn file_append(&mut self, track_id: &u32, data: &[u8], is_gap: bool) -> i32 {
SCLogDebug!("FILECONTAINER: append {}", data.len());
- if data.len() == 0 {
+ if data.is_empty() {
return 0
}
match unsafe {SC} {
}
}
}
- if vec.len() > 0 {
+ if !vec.is_empty() {
tx.escaped.push(vec);
let idx = tx.escaped.len() - 1;
let value = &tx.escaped[idx];
}
}
}
- if vec.len() > 0 {
+ if !vec.is_empty() {
tx.escaped.push(vec);
let idx = tx.escaped.len() - 1;
let value = &tx.escaped[idx];
match parser::http2_parse_frame_headers(input, hflags, dyn_headers) {
Ok((hrem, hs)) => {
self.process_headers(&hs.blocks, dir);
- if hrem.len() > 0 {
+ if !hrem.is_empty() {
SCLogDebug!("Remaining data for HTTP2 headers");
self.set_event(HTTP2Event::ExtraHeaderData);
}
fn parse_frames(
&mut self, mut input: &[u8], il: usize, dir: Direction, flow: *const Flow,
) -> AppLayerResult {
- while input.len() > 0 {
+ while !input.is_empty() {
match parser::http2_parse_frame_header(input) {
Ok((rem, head)) => {
let hl = head.length as usize;
61 => ("www-authenticate", ""),
_ => ("", ""),
};
- if name.len() > 0 {
+ if !name.is_empty() {
return Some(HTTP2FrameHeaderBlock {
name: name.as_bytes().to_vec(),
value: value.as_bytes().to_vec(),
} else {
dyn_headers.table.push(headcopy);
}
- while dyn_headers.current_size > dyn_headers.max_size && dyn_headers.table.len() > 0
+ while dyn_headers.current_size > dyn_headers.max_size && !dyn_headers.table.is_empty()
{
dyn_headers.current_size -=
32 + dyn_headers.table[0].name.len() + dyn_headers.table[0].value.len();
if (maxsize2 as usize) < dyn_headers.max_size {
//dyn_headers.max_size is updated later with all headers
//may evict entries
- while dyn_headers.current_size > (maxsize2 as usize) && dyn_headers.table.len() > 0 {
+ while dyn_headers.current_size > (maxsize2 as usize) && !dyn_headers.table.is_empty() {
// we check dyn_headers.table as we may be in best effort
// because the previous maxsize was too big for us to retain all the headers
dyn_headers.current_size -=
) -> IResult<&'a [u8], Vec<HTTP2FrameHeaderBlock>> {
let mut blocks = Vec::new();
let mut i3 = input;
- while i3.len() > 0 {
+ while !i3.is_empty() {
match http2_parse_headers_block(i3, dyn_headers) {
Ok((rem, b)) => {
blocks.push(b);
if let Ok(sa) = sa_type_s {
if tx.ike_version == 1 {
- if tx.hdr.ikev1_transforms.len() >= 1 {
+ if !tx.hdr.ikev1_transforms.is_empty() {
// there should be only one chosen server_transform, check event
if let Some(server_transform) = tx.hdr.ikev1_transforms.first() {
for attr in server_transform {
fn handle_input(&mut self, input: &[u8], direction: Direction) -> AppLayerResult {
// We're not interested in empty requests.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
) {
self.key_exchange = key_exchange.clone();
self.nonce = nonce.clone();
- if self.nb_transforms == 0 && transforms.len() > 0 {
+ if self.nb_transforms == 0 && !transforms.is_empty() {
self.transform.extend(transforms[0].iter().cloned());
}
self.nb_transforms += transforms.len() as u64;
);
}
- if rem.len() > 0 {
+ if !rem.is_empty() {
// more data left unread than should be
SCLogDebug!("Unread Payload Data");
state.set_event(IkeEvent::PayloadExtraData);
// client data
jb.open_object("client")?;
- if state.ikev1_container.client.key_exchange.len() > 0 {
+ if !state.ikev1_container.client.key_exchange.is_empty() {
jb.set_string(
"key_exchange_payload",
&state.ikev1_container.client.key_exchange,
jb.set_uint("key_exchange_payload_length", client_key_length / 2)?;
}
}
- if state.ikev1_container.client.nonce.len() > 0 {
+ if !state.ikev1_container.client.nonce.is_empty() {
jb.set_string("nonce_payload", &state.ikev1_container.client.nonce)?;
if let Ok(client_nonce_length) = u64::try_from(state.ikev1_container.client.nonce.len())
{
}
}
- if tx.direction == Direction::ToServer && tx.hdr.ikev1_transforms.len() > 0 {
+ if tx.direction == Direction::ToServer && !tx.hdr.ikev1_transforms.is_empty() {
jb.open_array("proposals")?;
for client_transform in &tx.hdr.ikev1_transforms {
jb.start_object()?;
// server data
jb.open_object("server")?;
- if state.ikev1_container.server.key_exchange.len() > 0 {
+ if !state.ikev1_container.server.key_exchange.is_empty() {
jb.set_string(
"key_exchange_payload",
&state.ikev1_container.server.key_exchange,
jb.set_uint("key_exchange_payload_length", server_key_length / 2)?;
}
}
- if state.ikev1_container.server.nonce.len() > 0 {
+ if !state.ikev1_container.server.nonce.is_empty() {
jb.set_string("nonce_payload", &state.ikev1_container.server.nonce)?;
if let Ok(server_nonce_length) = u64::try_from(state.ikev1_container.server.nonce.len())
{
}
jb.close()?; // server
- if tx.hdr.ikev1_header.vendor_ids.len() > 0 {
+ if !tx.hdr.ikev1_header.vendor_ids.is_empty() {
jb.open_array("vendor_ids")?;
for vendor in &tx.hdr.ikev1_header.vendor_ids {
jb.append_string(vendor)?;
}
};
let mut cur_i = tcp_buffer;
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
if state.record_ts == 0 {
match be_u32(cur_i) as IResult<&[u8],u32> {
Ok((rem,record)) => {
}
};
let mut cur_i = tcp_buffer;
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
if state.record_tc == 0 {
match be_u32(cur_i) as IResult<&[u8],_> {
Ok((rem,record)) => {
fn mime_parse_header_tokens(input: &[u8]) -> IResult<&[u8], MIMEHeaderTokens> {
let (mut input, _) = take_until_and_consume(b";")(input)?;
let mut tokens = HashMap::new();
- while input.len() > 0 {
+ while !input.is_empty() {
match mime_parse_header_token(input) {
Ok((rem, t)) => {
tokens.insert(t.0, t.1);
pub fn parse(&mut self, input: &[u8], direction: Direction) -> AppLayerResult {
let mut rest = input;
- while rest.len() > 0 {
+ while !rest.is_empty() {
match MODBUS_PARSER.parse(rest, direction.clone()) {
Ok((inner_rest, Some(mut msg))) => {
match direction {
_data: *const std::os::raw::c_void,
) -> AppLayerResult {
let buf = stream_slice.as_slice();
- if buf.len() == 0 {
+ if buf.is_empty() {
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS) > 0 {
return AppLayerResult::ok();
} else {
_data: *const std::os::raw::c_void,
) -> AppLayerResult {
let buf = stream_slice.as_slice();
- if buf.len() == 0 {
+ if buf.is_empty() {
if AppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC) > 0 {
return AppLayerResult::ok();
} else {
for msg in tx.msg.iter() {
if let MQTTOperation::CONNECT(ref cv) = msg.op {
let p = &cv.client_id;
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
for msg in tx.msg.iter() {
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.username {
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
for msg in tx.msg.iter() {
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.password {
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
for msg in tx.msg.iter() {
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.will_topic {
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
for msg in tx.msg.iter() {
if let MQTTOperation::CONNECT(ref cv) = msg.op {
if let Some(p) = &cv.will_message {
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
for msg in tx.msg.iter() {
if let MQTTOperation::PUBLISH(ref pubv) = msg.op {
let p = &pubv.topic;
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
for msg in tx.msg.iter() {
if let MQTTOperation::PUBLISH(ref pubv) = msg.op {
let p = &pubv.message;
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
if let MQTTOperation::SUBSCRIBE(ref subv) = msg.op {
if (i as usize) < subv.topics.len() + offset {
let topic = &subv.topics[(i as usize) - offset];
- if topic.topic_name.len() > 0 {
+ if !topic.topic_name.is_empty() {
*len = topic.topic_name.len() as u32;
*buf = topic.topic_name.as_ptr();
return 1;
if let MQTTOperation::UNSUBSCRIBE(ref unsubv) = msg.op {
if (i as usize) < unsubv.topics.len() + offset {
let topic = &unsubv.topics[(i as usize) - offset];
- if topic.len() > 0 {
+ if !topic.is_empty() {
*len = topic.len() as u32;
*buf = topic.as_ptr();
return 1;
log_mqtt_header(js, &msg.header)?;
js.set_uint("message_id", unsuback.message_id as u64)?;
if let Some(codes) = &unsuback.reason_codes {
- if codes.len() > 0 {
+ if !codes.is_empty() {
js.open_array("reason_codes")?;
for t in codes {
js.append_uint(*t as u64)?;
fn parse_request(&mut self, input: &[u8]) -> AppLayerResult {
let mut current = input;
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
}
}
- while current.len() > 0 {
+ while !current.is_empty() {
SCLogDebug!("request: handling {}", current.len());
match parse_message(current, self.protocol_version, self.max_msg_len) {
Ok((rem, msg)) => {
fn parse_response(&mut self, input: &[u8]) -> AppLayerResult {
let mut current = input;
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
}
}
- while current.len() > 0 {
+ while !current.is_empty() {
SCLogDebug!("response: handling {}", current.len());
match parse_message(current, self.protocol_version, self.max_msg_len as usize) {
Ok((rem, msg)) => {
// parse properties
let mut props = Vec::<MQTTProperty>::new();
let (rem, mut newrem) = take(proplen as usize)(rem)?;
- while newrem.len() > 0 {
+ while !newrem.is_empty() {
match parse_property(newrem) {
Ok((rem2, val)) => {
props.push(val);
let file_name = String::from_utf8_lossy(&tx.file_name);
js.set_string("filename", &file_name)?;
- if tx.file_handle.len() > 0 {
+ if !tx.file_handle.is_empty() {
//js.set_string("handle", &nfs_handle2hex(&tx.file_handle));
let c = nfs_handle2crc(&tx.file_handle);
let s = format!("{:x}", c);
mytx.response_done = true;
mytx.rpc_response_status = rpc_status;
mytx.nfs_response_status = nfs_status;
- if mytx.file_handle.len() == 0 && resp_handle.len() > 0 {
+ if mytx.file_handle.is_empty() && !resp_handle.is_empty() {
mytx.file_handle = resp_handle.to_vec();
}
}
cur_i = &cur_i[consumed as usize..];
}
- if cur_i.len() == 0 {
+ if cur_i.is_empty() {
return AppLayerResult::ok();
}
if self.ts_gap {
SCLogDebug!("TS trying to catch up after GAP (input {})", cur_i.len());
let mut _cnt = 0;
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
_cnt += 1;
match nfs_probe(cur_i, Direction::ToServer) {
1 => {
},
-1 => {
cur_i = &cur_i[1..];
- if cur_i.len() == 0 {
+ if cur_i.is_empty() {
SCLogDebug!("all post-GAP data in this chunk was bad. Looped {} times.", _cnt);
}
},
SCLogDebug!("TS GAP handling done (input {})", cur_i.len());
}
- while cur_i.len() > 0 { // min record size
+ while !cur_i.is_empty() { // min record size
self.add_rpc_tcp_ts_pdu(flow, stream_slice, cur_i, cur_i.len() as i64);
match parse_rpc_request_partial(cur_i) {
Ok((_, ref rpc_phdr)) => {
}
cur_i = &cur_i[consumed as usize..];
}
- if cur_i.len() == 0 {
+ if cur_i.is_empty() {
return AppLayerResult::ok();
}
if self.tc_gap {
SCLogDebug!("TC trying to catch up after GAP (input {})", cur_i.len());
let mut _cnt = 0;
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
_cnt += 1;
match nfs_probe(cur_i, Direction::ToClient) {
1 => {
},
-1 => {
cur_i = &cur_i[1..];
- if cur_i.len() == 0 {
+ if cur_i.is_empty() {
SCLogDebug!("all post-GAP data in this chunk was bad. Looped {} times.", _cnt);
}
},
SCLogDebug!("TC GAP handling done (input {})", cur_i.len());
}
- while cur_i.len() > 0 {
+ while !cur_i.is_empty() {
self.add_rpc_tcp_tc_pdu(flow, stream_slice, cur_i, cur_i.len() as i64);
match parse_rpc_packet_header(cur_i) {
Ok((_, ref rpc_phdr)) => {
let input = stream_slice.as_slice();
SCLogDebug!("parse_udp_ts ({})", input.len());
self.add_rpc_udp_ts_pdu(flow, stream_slice, input, input.len() as i64);
- if input.len() > 0 {
+ if !input.is_empty() {
match parse_rpc_udp_request(input) {
Ok((_, ref rpc_record)) => {
self.is_udp = true;
let input = stream_slice.as_slice();
SCLogDebug!("parse_udp_tc ({})", input.len());
self.add_rpc_udp_tc_pdu(flow, stream_slice, input, input.len() as i64);
- if input.len() > 0 {
+ if !input.is_empty() {
match parse_rpc_udp_reply(input) {
Ok((_, ref rpc_record)) => {
self.is_udp = true;
}
}
&Nfs4ResponseContent::PutRootFH(s) => {
- if s == NFS4_OK && xidmap.file_name.len() == 0 {
+ if s == NFS4_OK && xidmap.file_name.is_empty() {
xidmap.file_name = b"<mount_root>".to_vec();
SCLogDebug!("filename {:?}", xidmap.file_name);
}
fn parse_request(&mut self, input: &[u8]) -> AppLayerResult {
// We're not interested in empty requests.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
}
let mut start = input;
- while start.len() > 0 {
+ while !start.is_empty() {
SCLogDebug!(
"In 'parse_request' State Progress is: {:?}",
&self.state_progress
fn parse_response(&mut self, input: &[u8], flow: *const Flow) -> AppLayerResult {
// We're not interested in empty responses.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
}
let mut start = input;
- while start.len() > 0 {
+ while !start.is_empty() {
match PgsqlState::state_based_resp_parsing(self.state_progress, start) {
Ok((rem, response)) => {
start = rem;
js.set_string("ua", &String::from_utf8_lossy(ua))?;
}
}
- if tx.cyu.len() > 0 {
+ if !tx.cyu.is_empty() {
js.open_array("cyu")?;
for cyu in &tx.cyu {
js.start_object()?;
js.set_string("string", ja3)?;
js.close()?;
}
- if tx.extv.len() > 0 {
+ if !tx.extv.is_empty() {
js.open_array("extensions")?;
for e in &tx.extv {
js.start_object()?;
}
js.set_uint("type", etype.into())?;
- if e.values.len() > 0 {
+ if !e.values.is_empty() {
js.open_array("values")?;
for i in 0..e.values.len() {
js.append_string(&String::from_utf8_lossy(&e.values[i]))?;
Frame::Crypto(c) => {
ja3 = Some(c.ja3.clone());
for e in &c.extv {
- if e.etype == TlsExtensionType::ServerName && e.values.len() > 0 {
+ if e.etype == TlsExtensionType::ServerName && !e.values.is_empty() {
sni = Some(e.values[0].to_vec());
}
}
fn parse(&mut self, input: &[u8], to_server: bool) -> bool {
// so as to loop over multiple quic headers in one packet
let mut buf = input;
- while buf.len() > 0 {
+ while !buf.is_empty() {
match QuicHeader::from_bytes(buf, DEFAULT_DCID_LEN) {
Ok((rest, header)) => {
if (to_server && self.hello_ts) || (!to_server && self.hello_tc) {
&windows::os_to_string(&client.client_build, &unknown),
)?;
- if client.client_name.len() > 0 {
+ if !client.client_name.is_empty() {
js.set_string("client_name", &client.client_name)?;
}
js.set_uint("function_keys", client.keyboard_function_key as u64)?;
}
- if client.ime_file_name.len() > 0 {
+ if !client.ime_file_name.is_empty() {
js.set_string("ime", &client.ime_file_name)?;
}
}
if let Some(ref id) = client.client_dig_product_id {
- if id.len() > 0 {
+ if !id.is_empty() {
js.set_string("id", id)?;
}
}
}
McsConnectRequestChild::CsNet(ref net) => {
- if net.channels.len() > 0 {
+ if !net.channels.is_empty() {
js.open_array("channels")?;
for channel in &net.channels {
js.append_string(channel)?;
};
let (j1, cookie) = {
- if data.len() > 0 {
+ if !data.is_empty() {
match opt(parse_rdp_cookie)(data) {
Ok((remainder, opt)) => (remainder, opt),
Err(e) => return Err(e),
};
let (j2, negotiation_request) = {
- if j1.len() > 0 {
+ if !j1.is_empty() {
match opt(parse_negotiation_request)(j1) {
Ok((remainder, opt)) => (remainder, opt),
Err(e) => return Err(e),
Err(Err::Incomplete(i)) => return Err(Err::Incomplete(i)),
Err(Err::Failure(_)) | Err(Err::Error(_)) => break,
};
- if remainder.len() == 0 {
+ if remainder.is_empty() {
break;
}
}
let mut available = input;
loop {
- if available.len() == 0 {
+ if available.is_empty() {
return AppLayerResult::ok();
}
if self.tls_parsing {
let mut available = input;
loop {
- if available.len() == 0 {
+ if available.is_empty() {
return AppLayerResult::ok();
}
if self.tls_parsing {
/// probe for T.123 type identifier, as each message is encapsulated in T.123
fn probe_rdp(input: &[u8]) -> bool {
- input.len() > 0 && input[0] == TpktVersion::T123 as u8
+ !input.is_empty() && input[0] == TpktVersion::T123 as u8
}
/// probe for T.123 message, whether to client or to server
/// probe for TLS
fn probe_tls_handshake(input: &[u8]) -> bool {
- input.len() > 0 && input[0] == u8::from(TlsRecordType::Handshake)
+ !input.is_empty() && input[0] == u8::from(TlsRecordType::Handshake)
}
//
) -> u8 {
if let Some(ref r) = tx.tc_server_init {
let p = &r.name;
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
fn parse_request(&mut self, input: &[u8]) -> AppLayerResult {
// We're not interested in empty requests.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
let mut consumed = 0;
SCLogDebug!("request_state {}, input_len {}", self.state, input.len());
loop {
- if current.len() == 0 {
+ if current.is_empty() {
return AppLayerResult::ok();
}
match self.state {
fn parse_response(&mut self, input: &[u8]) -> AppLayerResult {
// We're not interested in empty responses.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
let mut consumed = 0;
SCLogDebug!("response_state {}, response_len {}", self.state, input.len());
loop {
- if current.len() == 0 {
+ if current.is_empty() {
return AppLayerResult::ok();
}
match self.state {
) -> u8 {
if let Some(ref r) = tx.request {
let m = &r.method;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
) -> u8 {
if let Some(ref r) = tx.request {
let p = &r.path;
- if p.len() > 0 {
+ if !p.is_empty() {
*buffer = p.as_ptr();
*buffer_len = p.len() as u32;
return 1;
Direction::ToServer => {
if let Some(ref r) = tx.request {
let v = &r.version;
- if v.len() > 0 {
+ if !v.is_empty() {
*buffer = v.as_ptr();
*buffer_len = v.len() as u32;
return 1;
Direction::ToClient => {
if let Some(ref r) = tx.response {
let v = &r.version;
- if v.len() > 0 {
+ if !v.is_empty() {
*buffer = v.as_ptr();
*buffer_len = v.len() as u32;
return 1;
) -> u8 {
if let Some(ref r) = tx.response {
let c = &r.code;
- if c.len() > 0 {
+ if !c.is_empty() {
*buffer = c.as_ptr();
*buffer_len = c.len() as u32;
return 1;
) -> u8 {
if let Some(ref r) = tx.response {
let re = &r.reason;
- if re.len() > 0 {
+ if !re.is_empty() {
*buffer = re.as_ptr();
*buffer_len = re.len() as u32;
return 1;
buffer_len: *mut u32,
) -> u8 {
if let Some(ref r) = tx.request_line {
- if r.len() > 0 {
+ if !r.is_empty() {
*buffer = r.as_ptr();
*buffer_len = r.len() as u32;
return 1;
buffer_len: *mut u32,
) -> u8 {
if let Some(ref r) = tx.response_line {
- if r.len() > 0 {
+ if !r.is_empty() {
*buffer = r.as_ptr();
*buffer_len = r.len() as u32;
return 1;
is_bind = true;
SCLogDebug!("SMB DCERPC {:?} BIND {:?}", dcer, bindr);
- if bindr.ifaces.len() > 0 {
+ if !bindr.ifaces.is_empty() {
let mut ifaces: Vec<DCERPCIface> = Vec::new();
for i in bindr.ifaces {
let x = if dcer.little_endian == true {
let mut malformed = false;
- if data.len() == 0 {
+ if data.is_empty() {
SCLogDebug!("weird: no DCERPC data"); // TODO
// TODO set event?
return false;
} else {
&x.stub_data_tc
};
- if vref.len() > 0 {
+ if !vref.is_empty() {
*buffer = vref.as_ptr();
*buffer_len = vref.len() as u32;
return 1;
Some(SMBTransactionTypeData::CREATE(ref x)) => {
let mut name_raw = x.filename.to_vec();
name_raw.retain(|&i|i != 0x00);
- if name_raw.len() > 0 {
+ if !name_raw.is_empty() {
let name = String::from_utf8_lossy(&name_raw);
if x.directory {
jsb.set_string("directory", &name)?;
Some(SMBTransactionTypeData::SETFILEPATHINFO(ref x)) => {
let mut name_raw = x.filename.to_vec();
name_raw.retain(|&i|i != 0x00);
- if name_raw.len() > 0 {
+ if !name_raw.is_empty() {
let name = String::from_utf8_lossy(&name_raw);
jsb.set_string("filename", &name)?;
} else {
}
cur_i = &cur_i[consumed as usize..];
}
- if cur_i.len() == 0 {
+ if cur_i.is_empty() {
return AppLayerResult::ok();
}
// gap
if self.ts_gap {
SCLogDebug!("TS trying to catch up after GAP (input {})", cur_i.len());
- while cur_i.len() > 0 { // min record size
+ while !cur_i.is_empty() { // min record size
match search_smb_record(cur_i) {
Ok((_, pg)) => {
SCLogDebug!("smb record found");
}
}
}
- while cur_i.len() > 0 { // min record size
+ while !cur_i.is_empty() { // min record size
match parse_nbss_record(cur_i) {
Ok((rem, ref nbss_hdr)) => {
SCLogDebug!("nbss frame offset {} len {}", stream_slice.offset_from(cur_i), cur_i.len() - rem.len());
}
} else if smb.version == 0xfe_u8 { // SMB2
let mut nbss_data = nbss_hdr.data;
- while nbss_data.len() > 0 {
+ while !nbss_data.is_empty() {
SCLogDebug!("SMBv2 record");
match parse_smb2_request_record(nbss_data) {
Ok((nbss_data_rem, ref smb_record)) => {
} else if smb.version == 0xfd_u8 { // SMB3 transform
let mut nbss_data = nbss_hdr.data;
- while nbss_data.len() > 0 {
+ while !nbss_data.is_empty() {
SCLogDebug!("SMBv3 transform record");
match parse_smb3_transform_record(nbss_data) {
Ok((nbss_data_rem, ref _smb3_record)) => {
}
cur_i = &cur_i[consumed as usize..];
}
- if cur_i.len() == 0 {
+ if cur_i.is_empty() {
return AppLayerResult::ok();
}
// gap
if self.tc_gap {
SCLogDebug!("TC trying to catch up after GAP (input {})", cur_i.len());
- while cur_i.len() > 0 { // min record size
+ while !cur_i.is_empty() { // min record size
match search_smb_record(cur_i) {
Ok((_, pg)) => {
SCLogDebug!("smb record found");
}
}
}
- while cur_i.len() > 0 { // min record size
+ while !cur_i.is_empty() { // min record size
match parse_nbss_record(cur_i) {
Ok((rem, ref nbss_hdr)) => {
SCLogDebug!("nbss record offset {} len {}", stream_slice.offset_from(cur_i), cur_i.len() - rem.len());
}
} else if smb.version == 0xfe_u8 { // SMB2
let mut nbss_data = nbss_hdr.data;
- while nbss_data.len() > 0 {
+ while !nbss_data.is_empty() {
SCLogDebug!("SMBv2 record");
match parse_smb2_response_record(nbss_data) {
Ok((nbss_data_rem, ref smb_record)) => {
}
} else if smb.version == 0xfd_u8 { // SMB3 transform
let mut nbss_data = nbss_hdr.data;
- while nbss_data.len() > 0 {
+ while !nbss_data.is_empty() {
SCLogDebug!("SMBv3 transform record");
match parse_smb3_transform_record(nbss_data) {
Ok((nbss_data_rem, ref _smb3_record)) => {
let mut bad_dialects = false;
let mut dialects : Vec<Vec<u8>> = Vec::new();
for d in &pr.dialects {
- if d.len() == 0 {
+ if d.is_empty() {
bad_dialects = true;
continue;
} else if d.len() == 1 {
/// configured to do so, or if this is a tx especially
/// for setting an event.
fn smb1_request_record_generic<'b>(state: &mut SMBState, r: &SmbRecord<'b>, events: Vec<SMBEvent>) {
- if smb1_create_new_tx(r.command) || events.len() > 0 {
+ if smb1_create_new_tx(r.command) || !events.is_empty() {
let tx_key = SMBCommonHdr::from1(r, SMBHDR_TYPE_GENERICTX);
let tx = state.new_generic_tx(1, r.command as u16, tx_key);
tx.set_events(events);
},
None => {},
}
- if events.len() > 0 {
+ if !events.is_empty() {
let tx = state.new_generic_tx(1, r.command as u16, tx_key);
tx.request_done = true;
tx.response_done = true;
Some(n) => (n.name.to_vec(), n.is_pipe),
_ => { (Vec::new(), false) },
};
- let mut is_dcerpc = if is_pipe || (share_name.len() == 0 && !is_pipe) {
+ let mut is_dcerpc = if is_pipe || (share_name.is_empty() && !is_pipe) {
state.get_service_for_guid(&file_guid).1
} else {
false
SCLogDebug!("SMBv2/READ: share_name {:?} is_pipe {} is_dcerpc {}",
share_name, is_pipe, is_dcerpc);
- if share_name.len() == 0 && !is_pipe {
+ if share_name.is_empty() && !is_pipe {
SCLogDebug!("SMBv2/READ: no tree connect seen, we don't know if we are a pipe");
if smb_dcerpc_probe(rd.data) == true {
Some(n) => { (n.name.to_vec(), n.is_pipe) },
_ => { (Vec::new(), false) },
};
- let mut is_dcerpc = if is_pipe || (share_name.len() == 0 && !is_pipe) {
+ let mut is_dcerpc = if is_pipe || (share_name.is_empty() && !is_pipe) {
state.get_service_for_guid(wr.guid).1
} else {
false
share_name, is_pipe, is_dcerpc);
// if we missed the TREE connect we can't be sure if 'is_dcerpc' is correct
- if share_name.len() == 0 && !is_pipe {
+ if share_name.is_empty() && !is_pipe {
SCLogDebug!("SMBv2/WRITE: no tree connect seen, we don't know if we are a pipe");
if smb_dcerpc_probe(wr.data) == true {
SCLogDebug!("get_unicode_string: blob {} {:?}", blob.len(), blob);
let mut name : Vec<u8> = Vec::new();
let mut c = blob;
- while c.len() >= 1 {
+ while !c.is_empty() {
if c.len() == 1 && c[0] == 0 {
let rem = &c[1..];
SCLogDebug!("get_unicode_string: name {:?}", name);
},
_ => ()
}
- if info.vars.len() > 0 {
+ if !info.vars.is_empty() {
jsb.open_array("vars")?;
for var in info.vars.iter() {
jsb.append_string(&var.to_string())?;
match direction.into() {
Direction::ToServer => {
let m = &tx.cli_hdr.protover;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
Direction::ToClient => {
let m = &tx.srv_hdr.protover;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
match direction.into() {
Direction::ToServer => {
let m = &tx.cli_hdr.swver;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
Direction::ToClient => {
let m = &tx.srv_hdr.swver;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
match direction.into() {
Direction::ToServer => {
let m = &tx.cli_hdr.hassh;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
Direction::ToClient => {
let m = &tx.srv_hdr.hassh;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
match direction.into() {
Direction::ToServer => {
let m = &tx.cli_hdr.hassh_string;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
}
Direction::ToClient => {
let m = &tx.srv_hdr.hassh_string;
- if m.len() > 0 {
+ if !m.is_empty() {
*buffer = m.as_ptr();
*buffer_len = m.len() as u32;
return 1;
use crate::jsonbuilder::{JsonBuilder, JsonError};
fn log_ssh(tx: &SSHTransaction, js: &mut JsonBuilder) -> Result<bool, JsonError> {
- if tx.cli_hdr.protover.len() == 0 && tx.srv_hdr.protover.len() == 0 {
+ if tx.cli_hdr.protover.is_empty() && tx.srv_hdr.protover.is_empty() {
return Ok(false);
}
- if tx.cli_hdr.protover.len() > 0 {
+ if !tx.cli_hdr.protover.is_empty() {
js.open_object("client")?;
js.set_string_from_bytes("proto_version", &tx.cli_hdr.protover)?;
- if tx.cli_hdr.swver.len() > 0 {
+ if !tx.cli_hdr.swver.is_empty() {
js.set_string_from_bytes("software_version", &tx.cli_hdr.swver)?;
}
- if tx.cli_hdr.hassh.len() > 0 || tx.cli_hdr.hassh_string.len() > 0 {
+ if !tx.cli_hdr.hassh.is_empty() || !tx.cli_hdr.hassh_string.is_empty() {
js.open_object("hassh")?;
- if tx.cli_hdr.hassh.len() > 0 {
+ if !tx.cli_hdr.hassh.is_empty() {
js.set_string_from_bytes("hash", &tx.cli_hdr.hassh)?;
}
- if tx.cli_hdr.hassh_string.len() > 0 {
+ if !tx.cli_hdr.hassh_string.is_empty() {
js.set_string_from_bytes("string", &tx.cli_hdr.hassh_string)?;
}
js.close()?;
}
js.close()?;
}
- if tx.srv_hdr.protover.len() > 0 {
+ if !tx.srv_hdr.protover.is_empty() {
js.open_object("server")?;
js.set_string_from_bytes("proto_version", &tx.srv_hdr.protover)?;
- if tx.srv_hdr.swver.len() > 0 {
+ if !tx.srv_hdr.swver.is_empty() {
js.set_string_from_bytes("software_version", &tx.srv_hdr.swver)?;
}
- if tx.srv_hdr.hassh.len() > 0 || tx.srv_hdr.hassh_string.len() > 0 {
+ if !tx.srv_hdr.hassh.is_empty() || !tx.srv_hdr.hassh_string.is_empty() {
js.open_object("hassh")?;
- if tx.srv_hdr.hassh.len() > 0 {
+ if !tx.srv_hdr.hassh.is_empty() {
js.set_string_from_bytes("hash", &tx.srv_hdr.hassh)?;
}
- if tx.srv_hdr.hassh_string.len() > 0 {
+ if !tx.srv_hdr.hassh_string.is_empty() {
js.set_string_from_bytes("string", &tx.srv_hdr.hassh_string)?;
}
js.close()?;
}
}
//parse records out of input
- while input.len() > 0 {
+ while !input.is_empty() {
match parser::ssh_parse_record(input) {
Ok((rem, head)) => {
SCLogDebug!("SSH valid record {}", head);
Ok((rem, line)) => {
if let Ok((_, banner)) = parser::ssh_parse_banner(line) {
hdr.protover.extend(banner.protover);
- if banner.swver.len() > 0 {
+ if !banner.swver.is_empty() {
hdr.swver.extend(banner.swver);
}
hdr.flags = SSHConnectionState::SshStateBannerDone;
);
if let Ok((_, banner)) = parser::ssh_parse_banner(input) {
hdr.protover.extend(banner.protover);
- if banner.swver.len() > 0 {
+ if !banner.swver.is_empty() {
hdr.swver.extend(banner.swver);
}
hdr.flags = SSHConnectionState::SshStateBannerWaitEol;
&mut self, flow: *const Flow, stream_slice: &StreamSlice, input: &[u8],
) -> AppLayerResult {
// We're not interested in empty requests.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
}
let mut start = input;
- while start.len() > 0 {
+ while !start.is_empty() {
if self.request_frame.is_none() {
self.request_frame = Frame::new(
flow,
fn parse_response(&mut self, flow: *const Flow, stream_slice: &StreamSlice, input: &[u8]) -> AppLayerResult {
// We're not interested in empty responses.
- if input.len() == 0 {
+ if input.is_empty() {
return AppLayerResult::ok();
}
self.response_gap = false;
}
let mut start = input;
- while start.len() > 0 {
+ while !start.is_empty() {
if self.response_frame.is_none() {
self.response_frame = Frame::new(flow, stream_slice, start, -1 as i64, TelnetFrameType::Pdu as u8);
}
projects / thirdparty / suricata.git / commitdiff
