rust/clippy: fix lint: needless_lifetimes

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)?;

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)));

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)]

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)
 }
 

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'),

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",

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;

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);

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)?;