rust/clippy: fix lint: needless_lifetimes

diff --git a/rust/src/dns/parser.rs b/rust/src/dns/parser.rs
index dbdca79c6ef5d6cc6adf5bc3a1e1d8432358f061..d208875078cf5d1aff8cd1436367b63e5ddef4d8 100644 (file)
--- a/rust/src/dns/parser.rs
+++ b/rust/src/dns/parser.rs
@@ -184,7 +184,7 @@ fn dns_parse_answer<'a>(
 }
 
 /// Parse a DNS response.
-pub fn dns_parse_response<'a>(slice: &'a [u8]) -> IResult<&[u8], DNSResponse> {
+pub fn dns_parse_response(slice: &[u8]) -> IResult<&[u8], DNSResponse> {
     let i = slice;
     let (i, header) = dns_parse_header(i)?;
     let (i, queries) = count(|b| dns_parse_query(b, slice), header.questions as usize)(i)?;
@@ -221,11 +221,11 @@ pub fn dns_parse_query<'a>(input: &'a [u8], message: &'a [u8]) -> IResult<&'a [u
     ))
 }
 
-fn dns_parse_rdata_a<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
+fn dns_parse_rdata_a(input: &[u8]) -> IResult<&[u8], DNSRData> {
     rest(input).map(|(input, data)| (input, DNSRData::A(data.to_vec())))
 }
 
-fn dns_parse_rdata_aaaa<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
+fn dns_parse_rdata_aaaa(input: &[u8]) -> IResult<&[u8], DNSRData> {
     rest(input).map(|(input, data)| (input, DNSRData::AAAA(data.to_vec())))
 }
 
@@ -289,16 +289,16 @@ fn dns_parse_rdata_srv<'a>(input: &'a [u8], message: &'a [u8]) -> IResult<&'a [u
     ))
 }
 
-fn dns_parse_rdata_txt<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
+fn dns_parse_rdata_txt(input: &[u8]) -> IResult<&[u8], DNSRData> {
     let (i, txt) = length_data(be_u8)(input)?;
     Ok((i, DNSRData::TXT(txt.to_vec())))
 }
 
-fn dns_parse_rdata_null<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
+fn dns_parse_rdata_null(input: &[u8]) -> IResult<&[u8], DNSRData> {
     rest(input).map(|(input, data)| (input, DNSRData::NULL(data.to_vec())))
 }
 
-fn dns_parse_rdata_sshfp<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
+fn dns_parse_rdata_sshfp(input: &[u8]) -> IResult<&[u8], DNSRData> {
     let i = input;
     let (i, algo) = be_u8(i)?;
     let (i, fp_type) = be_u8(i)?;
@@ -313,7 +313,7 @@ fn dns_parse_rdata_sshfp<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
     ))
 }
 
-fn dns_parse_rdata_unknown<'a>(input: &'a [u8]) -> IResult<&'a [u8], DNSRData> {
+fn dns_parse_rdata_unknown(input: &[u8]) -> IResult<&[u8], DNSRData> {
     rest(input).map(|(input, data)| (input, DNSRData::Unknown(data.to_vec())))
 }
 
@@ -337,7 +337,7 @@ pub fn dns_parse_rdata<'a>(
 }
 
 /// Parse a DNS request.
-pub fn dns_parse_request<'a>(input: &'a [u8]) -> IResult<&[u8], DNSRequest> {
+pub fn dns_parse_request(input: &[u8]) -> IResult<&[u8], DNSRequest> {
     let i = input;
     let (i, header) = dns_parse_header(i)?;
     let (i, queries) = count(|b| dns_parse_query(b, input), header.questions as usize)(i)?;

diff --git a/rust/src/http2/range.rs b/rust/src/http2/range.rs
index 8b07170bba8a6f5596fa3c630ea3ea2f3946f171..05f204dabaea00043c5b84778167fd059ad33eb0 100644 (file)
--- a/rust/src/http2/range.rs
+++ b/rust/src/http2/range.rs
@@ -38,7 +38,7 @@ pub struct HTTPContentRange {
     pub size: i64,
 }
 
-pub fn http2_parse_content_range_star<'a>(input: &'a [u8]) -> IResult<&'a [u8], HTTPContentRange> {
+pub fn http2_parse_content_range_star(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
     let (i2, _) = char('*')(input)?;
     let (i2, _) = char('/')(i2)?;
     let (i2, size) = map_res(map_res(digit1, std::str::from_utf8), i64::from_str)(i2)?;
@@ -52,7 +52,7 @@ pub fn http2_parse_content_range_star<'a>(input: &'a [u8]) -> IResult<&'a [u8],
     ));
 }
 
-pub fn http2_parse_content_range_def<'a>(input: &'a [u8]) -> IResult<&'a [u8], HTTPContentRange> {
+pub fn http2_parse_content_range_def(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
     let (i2, start) = map_res(map_res(digit1, std::str::from_utf8), i64::from_str)(input)?;
     let (i2, _) = char('-')(i2)?;
     let (i2, end) = map_res(map_res(digit1, std::str::from_utf8), i64::from_str)(i2)?;
@@ -64,7 +64,7 @@ pub fn http2_parse_content_range_def<'a>(input: &'a [u8]) -> IResult<&'a [u8], H
     return Ok((i2, HTTPContentRange { start, end, size }));
 }
 
-fn http2_parse_content_range<'a>(input: &'a [u8]) -> IResult<&'a [u8], HTTPContentRange> {
+fn http2_parse_content_range(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
     let (i2, _) = take_while(|c| c == b' ')(input)?;
     let (i2, _) = take_till(|c| c == b' ')(i2)?;
     let (i2, _) = take_while(|c| c == b' ')(i2)?;
@@ -74,7 +74,7 @@ fn http2_parse_content_range<'a>(input: &'a [u8]) -> IResult<&'a [u8], HTTPConte
     ))(i2);
 }
 
-pub fn http2_parse_check_content_range<'a>(input: &'a [u8]) -> IResult<&'a [u8], HTTPContentRange> {
+pub fn http2_parse_check_content_range(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
     let (rem, v) = http2_parse_content_range(input)?;
     if v.start > v.end || (v.end > 0 && v.size > 0 && v.end > v.size - 1) {
         return Err(Err::Error(make_error(rem, ErrorKind::Verify)));

diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 23aa0a792f4f4d9bccab95d10082165158e5fc9b..c7ccdf7e4c03d26f2c28c6ac640396d6ee467184 100644 (file)
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -39,7 +39,6 @@
 #![allow(clippy::match_like_matches_macro)]
 #![allow(clippy::match_ref_pats)]
 #![allow(clippy::module_inception)]
-#![allow(clippy::needless_lifetimes)]
 #![allow(clippy::needless_range_loop)]
 #![allow(clippy::never_loop)]
 #![allow(clippy::new_without_default)]

diff --git a/rust/src/nfs/nfs3_records.rs b/rust/src/nfs/nfs3_records.rs
index a4d90e4ae0ee6bc939c17f1319293ef9be29ef83..5529963d2f4633384be9efab7f3c610885372bd4 100644 (file)
--- a/rust/src/nfs/nfs3_records.rs
+++ b/rust/src/nfs/nfs3_records.rs
@@ -297,9 +297,9 @@ pub fn parse_nfs3_response_readdirplus(i: &[u8]) -> IResult<&[u8], Nfs3ResponseR
     Ok((i, resp))
 }
 
-pub(crate) fn many0_nfs3_response_readdirplus_entries<'a>(
-    input: &'a [u8],
-) -> IResult<&'a [u8], Vec<Nfs3ResponseReaddirplusEntry<'a>>> {
+pub(crate) fn many0_nfs3_response_readdirplus_entries(
+    input: &[u8],
+) -> IResult<&[u8], Vec<Nfs3ResponseReaddirplusEntry>> {
     many0(complete(parse_nfs3_response_readdirplus_entry_cond))(input)
 }
 

diff --git a/rust/src/rdp/log.rs b/rust/src/rdp/log.rs
index 6e14c8d91873003cca0d43327e92a910db6f5ea9..00cba685da9e15cde11235c373b524ada6287c3b 100644 (file)
--- a/rust/src/rdp/log.rs
+++ b/rust/src/rdp/log.rs
@@ -375,7 +375,7 @@ fn mcs_req_to_json(mcs: &McsConnectRequest, js: &mut JsonBuilder) -> Result<(),
 }
 
 /// converts RdpClientVersion to a string, using the provided prefix
-fn version_to_string<'a>(ver: &RdpClientVersion, prefix: &'a str) -> String {
+fn version_to_string(ver: &RdpClientVersion, prefix: &str) -> String {
     let mut result = String::from(prefix);
     match ver {
         RdpClientVersion::V4 => result.push('4'),

diff --git a/rust/src/rdp/windows.rs b/rust/src/rdp/windows.rs
index c7acd9ad22ad2462b457c77a427cb3fc0b376d44..29ee4b229befa17d6692d73ca288f4fb15c2f177 100644 (file)
--- a/rust/src/rdp/windows.rs
+++ b/rust/src/rdp/windows.rs
@@ -19,7 +19,7 @@
 
 /// converts a locale identifier into a locale name
 /// <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/70feba9f-294e-491e-b6eb-56532684c37f>
-pub fn lcid_to_string<'a>(lcid: u32, default: &'a str) -> String {
+pub fn lcid_to_string(lcid: u32, default: &str) -> String {
     let s = match lcid {
         0x0001 => "ar",
         0x0002 => "bg",
@@ -550,7 +550,7 @@ pub fn build_number_to_os(number: u32) -> OperatingSystem {
 }
 
 /// convert an OperatingSystem into a string description
-pub fn os_to_string<'a>(os: &OperatingSystem, default: &'a str) -> String {
+pub fn os_to_string(os: &OperatingSystem, default: &str) -> String {
     let s = match os.build {
         Build::Win31 => "Windows NT 3.1",
         Build::Win35 => "Windows NT 3.5",

diff --git a/rust/src/smb/dcerpc.rs b/rust/src/smb/dcerpc.rs
index 794479b3738ad6d878d9c68ee2ceb4924bb6fb8d..fccdac1b19e6a5a196b1e55f3ab0c729521188eb 100644 (file)
--- a/rust/src/smb/dcerpc.rs
+++ b/rust/src/smb/dcerpc.rs
@@ -178,10 +178,10 @@ impl SMBState {
 /// Handle DCERPC request data from a WRITE, IOCTL or TRANS record.
 /// return bool indicating whether an tx has been created/updated.
 ///
-pub fn smb_write_dcerpc_record<'b>(state: &mut SMBState,
+pub fn smb_write_dcerpc_record(state: &mut SMBState,
         vercmd: SMBVerCmdStat,
         hdr: SMBCommonHdr,
-        data: &'b [u8]) -> bool
+        data: &[u8]) -> bool
 {
     let mut bind_ifaces : Option<Vec<DCERPCIface>> = None;
     let mut is_bind = false;

diff --git a/rust/src/smb/smb2_records.rs b/rust/src/smb/smb2_records.rs
index ef2d9f731589d528442559f77291d27cacc0b6af..3db46aab92598210e8735fe2ee466b972bf2e5f8 100644 (file)
--- a/rust/src/smb/smb2_records.rs
+++ b/rust/src/smb/smb2_records.rs
@@ -489,8 +489,8 @@ pub struct Smb2ReadResponseRecord<'a> {
 // parse read/write data. If all is available, 'take' it.
 // otherwise just return what we have. So this may return
 // partial data.
-fn parse_smb2_data<'a>(i: &'a[u8], len: u32)
-    -> IResult<&'a[u8], &'a[u8]>
+fn parse_smb2_data(i: &[u8], len: u32)
+    -> IResult<&[u8], &[u8]>
 {
     if len as usize > i.len() {
         rest(i)
@@ -611,7 +611,7 @@ fn smb_basic_search(d: &[u8]) -> usize {
     return 0;
 }
 
-pub fn search_smb_record<'a>(i: &'a [u8]) -> IResult<&'a [u8], &'a [u8]> {
+pub fn search_smb_record(i: &[u8]) -> IResult<&[u8], &[u8]> {
     let mut d = i;
     while d.len() >= 4 {
         let index = smb_basic_search(d);

diff --git a/rust/src/tftp/tftp.rs b/rust/src/tftp/tftp.rs
index a75a3cae0931f09b51d49ba5019866b70c45185a..1b093fed256d52eae0a7f0f9a55fba9f12f74c89 100644 (file)
--- a/rust/src/tftp/tftp.rs
+++ b/rust/src/tftp/tftp.rs
@@ -125,7 +125,7 @@ fn getstr(i: &[u8]) -> IResult<&[u8], &str> {
     )(i)
 }
 
-fn tftp_request<'a>(slice: &'a [u8]) -> IResult<&[u8], TFTPTransaction> {
+fn tftp_request(slice: &[u8]) -> IResult<&[u8], TFTPTransaction> {
     let (i, _) = tag([0])(slice)?;
     let (i, opcode) = be_u8(i)?;
     let (i, filename) = getstr(i)?;