diff --git a/src/cli/logging.rs b/src/cli/logging.rs index 38da6e0..72ac3b7 100644 --- a/src/cli/logging.rs +++ b/src/cli/logging.rs @@ -6,39 +6,36 @@ pub fn enable_logger(verbose: bool) { fern::Dispatch::new() .format(move |out, message, record| { out.finish(format_args!( - "{}: {}", - format!( - "{}{}", - // Level messages are padded to keep the output looking somewhat sane - match record.level() { - log::Level::Error => "ERROR" - .if_supports_color(Stdout, |text| text.red()) - .if_supports_color(Stdout, |text| text.bold()) - .to_string(), - log::Level::Warn => "WARN " - .if_supports_color(Stdout, |text| text.yellow()) - .if_supports_color(Stdout, |text| text.bold()) - .to_string(), - log::Level::Info => "INFO " - .if_supports_color(Stdout, |text| text.green()) - .if_supports_color(Stdout, |text| text.bold()) - .to_string(), - log::Level::Debug => "DEBUG" - .if_supports_color(Stdout, |text| text.bright_blue()) - .if_supports_color(Stdout, |text| text.bold()) - .to_string(), - log::Level::Trace => "TRACE" - .if_supports_color(Stdout, |text| text.bright_white()) - .if_supports_color(Stdout, |text| text.bold()) - .to_string(), - }, - // Only show the outer package name if verbose logging is enabled (otherwise nothing) - match verbose { - true => format!(" [{}]", record.target().split("::").nth(0).unwrap()), - false => String::new(), - } - .if_supports_color(Stdout, |text| text.bright_black()) - ), + "{}{}: {}", + // Level messages are padded to keep the output looking somewhat sane + match record.level() { + log::Level::Error => "ERROR" + .if_supports_color(Stdout, |text| text.red()) + .if_supports_color(Stdout, |text| text.bold()) + .to_string(), + log::Level::Warn => "WARN " + .if_supports_color(Stdout, |text| text.yellow()) + .if_supports_color(Stdout, |text| text.bold()) + .to_string(), + log::Level::Info => "INFO " + .if_supports_color(Stdout, |text| text.green()) + .if_supports_color(Stdout, |text| text.bold()) + .to_string(), + log::Level::Debug => "DEBUG" + .if_supports_color(Stdout, |text| text.bright_blue()) + .if_supports_color(Stdout, |text| text.bold()) + .to_string(), + log::Level::Trace => "TRACE" + .if_supports_color(Stdout, |text| text.bright_white()) + .if_supports_color(Stdout, |text| text.bold()) + .to_string(), + }, + // Only show the outer package name if verbose logging is enabled (otherwise nothing) + match verbose { + true => format!(" [{}]", record.target().split("::").next().unwrap()), + false => String::new(), + } + .if_supports_color(Stdout, |text| text.bright_black()), message )) }) diff --git a/src/lib.rs b/src/lib.rs index d5d7c1f..14f189f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,6 +2,11 @@ //! //! *Note: There is a fair chance you are looking for `src/cli/main.rs` instead of this file.* +#![deny(clippy::pedantic)] +#![allow(clippy::module_name_repetitions)] +#![allow(clippy::missing_errors_doc)] +#![allow(clippy::missing_panics_doc)] + +pub mod metrics; pub mod nat; mod packet; -pub mod metrics; \ No newline at end of file diff --git a/src/metrics/http.rs b/src/metrics/http.rs index c0eddc6..5f88e1c 100644 --- a/src/metrics/http.rs +++ b/src/metrics/http.rs @@ -7,6 +7,7 @@ use hyper::{ use prometheus::{Encoder, TextEncoder}; /// Handle an HTTP request +#[allow(clippy::unused_async)] async fn handle_request(request: Request) -> Result, Infallible> { // If the request is targeting the metrics endpoint if request.method() == Method::GET && request.uri().path() == "/metrics" { @@ -39,6 +40,6 @@ pub async fn serve_metrics(bind_addr: SocketAddr) { // Run the server if let Err(e) = server.await { - eprintln!("Metrics server error: {}", e); + eprintln!("Metrics server error: {e}"); } } diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs index af0e9e7..e79cd4c 100644 --- a/src/metrics/mod.rs +++ b/src/metrics/mod.rs @@ -1,5 +1,6 @@ mod http; +#[allow(clippy::module_inception)] mod metrics; +pub use http::serve_metrics; pub(crate) use metrics::*; -pub use http::serve_metrics; \ No newline at end of file diff --git a/src/nat/error.rs b/src/nat/error.rs index b924baa..d90751a 100644 --- a/src/nat/error.rs +++ b/src/nat/error.rs @@ -1,15 +1,15 @@ #[derive(Debug, thiserror::Error)] pub enum Nat64Error { #[error(transparent)] - TableError(#[from] super::table::TableError), + Table(#[from] super::table::TableError), #[error(transparent)] - TunError(#[from] protomask_tun::Error), + Tun(#[from] protomask_tun::Error), #[error(transparent)] - IoError(#[from] std::io::Error), + Io(#[from] std::io::Error), #[error(transparent)] - PacketHandlingError(#[from] crate::packet::error::PacketError), + PacketHandling(#[from] crate::packet::error::PacketError), #[error(transparent)] - PacketReceiveError(#[from] tokio::sync::broadcast::error::RecvError), + PacketReceive(#[from] tokio::sync::broadcast::error::RecvError), #[error(transparent)] - PacketSendError(#[from] tokio::sync::mpsc::error::SendError>), + PacketSend(#[from] tokio::sync::mpsc::error::SendError>), } diff --git a/src/nat/mod.rs b/src/nat/mod.rs index f79fb1b..930b363 100644 --- a/src/nat/mod.rs +++ b/src/nat/mod.rs @@ -44,7 +44,7 @@ impl Nat64 { interface.add_route(ipv6_nat_prefix.into()).await?; // Add the IPv4 pool prefixes as routes - for ipv4_prefix in ipv4_pool.iter() { + for ipv4_prefix in &ipv4_pool { interface.add_route((*ipv4_prefix).into()).await?; } @@ -149,7 +149,7 @@ impl Nat64 { // Spawn a task to process the packet tokio::spawn(async move { if let Some(output) = unwrap_log(translate_ipv6_to_ipv4( - packet, + &packet, new_source, new_destination, )) { @@ -169,7 +169,7 @@ impl Nat64 { log::warn!("Translator running behind! Dropping {} packets", count); Ok(()) } - error => Err(error), + error @ broadcast::error::RecvError::Closed => Err(error), }, }?; } diff --git a/src/nat/table.rs b/src/nat/table.rs index 561d4ba..e7e3693 100644 --- a/src/nat/table.rs +++ b/src/nat/table.rs @@ -5,7 +5,7 @@ use std::{ }; use bimap::BiHashMap; -use ipnet::{Ipv4Net, Ipv6Net}; +use ipnet::Ipv4Net; use crate::metrics::{IPV4_POOL_RESERVED, IPV4_POOL_SIZE}; @@ -136,61 +136,6 @@ impl Nat64Table { // Otherwise, there is no matching reservation Err(TableError::NoIpv6Mapping(ipv4)) } - - /// Check if an address is within the IPv4 pool - pub fn is_address_within_pool(&self, address: &Ipv4Addr) -> bool { - self.ipv4_pool.iter().any(|net| net.contains(address)) - } - - /// Calculate the translated version of any address - pub fn calculate_xlat_addr( - &mut self, - input: &IpAddr, - ipv6_nat64_prefix: &Ipv6Net, - ) -> Result { - // Handle the incoming address type - match input { - // Handle IPv4 - IpAddr::V4(ipv4_addr) => { - // If the address is in the IPv4 pool, it is a regular IPv4 address - if self.is_address_within_pool(ipv4_addr) { - // This means we need to pass through to `get_reverse` - return Ok(IpAddr::V6(self.get_reverse(*ipv4_addr)?)); - } - - // Otherwise, it shall be embedded inside the ipv6 prefix - let prefix_octets = ipv6_nat64_prefix.addr().octets(); - let address_octets = ipv4_addr.octets(); - return Ok(IpAddr::V6(Ipv6Addr::new( - u16::from_be_bytes([prefix_octets[0], prefix_octets[1]]), - u16::from_be_bytes([prefix_octets[2], prefix_octets[3]]), - u16::from_be_bytes([prefix_octets[4], prefix_octets[5]]), - u16::from_be_bytes([prefix_octets[6], prefix_octets[7]]), - u16::from_be_bytes([prefix_octets[8], prefix_octets[9]]), - u16::from_be_bytes([prefix_octets[10], prefix_octets[11]]), - u16::from_be_bytes([address_octets[0], address_octets[1]]), - u16::from_be_bytes([address_octets[2], address_octets[3]]), - ))); - } - - // Handle IPv6 - IpAddr::V6(ipv6_addr) => { - // If the address is in the IPv6 prefix, it is an embedded IPv4 address - if ipv6_nat64_prefix.contains(ipv6_addr) { - let address_bytes = ipv6_addr.octets(); - return Ok(IpAddr::V4(Ipv4Addr::new( - address_bytes[12], - address_bytes[13], - address_bytes[14], - address_bytes[15], - ))); - } - - // Otherwise, it is a regular IPv6 address and we can pass through to `get_or_assign_ipv4` - return Ok(IpAddr::V4(self.get_or_assign_ipv4(*ipv6_addr)?)); - } - } - } } impl Nat64Table { @@ -200,16 +145,12 @@ impl Nat64Table { // Prune from the reservation map self.reservations.retain(|v6, v4| { - if let Some(time) = self.reservation_times.get(&(*v6, *v4)) { - if let Some(time) = time { - let keep = now - *time < self.reservation_timeout; - if !keep { - log::info!("Pruned reservation: {} -> {}", v6, v4); - } - keep - } else { - true + if let Some(Some(time)) = self.reservation_times.get(&(*v6, *v4)) { + let keep = now - *time < self.reservation_timeout; + if !keep { + log::info!("Pruned reservation: {} -> {}", v6, v4); } + keep } else { true } @@ -235,10 +176,10 @@ impl Nat64Table { // Track the values IPV4_POOL_RESERVED .with_label_values(&["dynamic"]) - .set(total_dynamic_reservations as i64); + .set(i64::from(total_dynamic_reservations)); IPV4_POOL_RESERVED .with_label_values(&["static"]) - .set(total_static_reservations as i64); + .set(i64::from(total_static_reservations)); } } diff --git a/src/packet/protocols/icmp.rs b/src/packet/protocols/icmp.rs index 6553ff3..53e4a2a 100644 --- a/src/packet/protocols/icmp.rs +++ b/src/packet/protocols/icmp.rs @@ -13,7 +13,7 @@ pub struct IcmpPacket { } impl IcmpPacket { - /// Construct a new ICMPv6 packet + /// Construct a new `ICMP` packet pub fn new(icmp_type: IcmpType, icmp_code: IcmpCode, payload: T) -> Self { Self { icmp_type, @@ -32,7 +32,7 @@ where fn try_from(bytes: Vec) -> Result { // Parse the packet let packet = pnet_packet::icmp::IcmpPacket::new(&bytes) - .ok_or(PacketError::TooShort(bytes.len(), bytes.to_vec()))?; + .ok_or(PacketError::TooShort(bytes.len(), bytes.clone()))?; // Return the packet Ok(Self { @@ -43,13 +43,13 @@ where } } -impl Into> for IcmpPacket +impl From> for Vec where T: Into>, { - fn into(self) -> Vec { + fn from(packet: IcmpPacket) -> Self { // Convert the payload into raw bytes - let payload: Vec = self.payload.into(); + let payload: Vec = packet.payload.into(); // Allocate a mutable packet to write into let total_length = @@ -58,8 +58,8 @@ where pnet_packet::icmp::MutableIcmpPacket::owned(vec![0u8; total_length]).unwrap(); // Write the type and code - output.set_icmp_type(self.icmp_type); - output.set_icmp_code(self.icmp_code); + output.set_icmp_type(packet.icmp_type); + output.set_icmp_code(packet.icmp_code); // Write the payload output.set_payload(&payload); diff --git a/src/packet/protocols/icmpv6.rs b/src/packet/protocols/icmpv6.rs index 08d75e4..d320e93 100644 --- a/src/packet/protocols/icmpv6.rs +++ b/src/packet/protocols/icmpv6.rs @@ -19,7 +19,7 @@ pub struct Icmpv6Packet { } impl Icmpv6Packet { - /// Construct a new ICMPv6 packet + /// Construct a new `ICMPv6` packet pub fn new( source_address: Ipv6Addr, destination_address: Ipv6Addr, @@ -41,7 +41,7 @@ impl Icmpv6Packet where T: From>, { - /// Construct a new ICMPv6 packet from raw bytes + /// Construct a new `ICMPv6` packet from raw bytes #[allow(dead_code)] pub fn new_from_bytes( bytes: &[u8], @@ -64,7 +64,7 @@ where } impl Icmpv6Packet { - /// Construct a new ICMPv6 packet with a raw payload from raw bytes + /// Construct a new `ICMPv6` packet with a raw payload from raw bytes pub fn new_from_bytes_raw_payload( bytes: &[u8], source_address: Ipv6Addr, @@ -85,13 +85,13 @@ impl Icmpv6Packet { } } -impl Into> for Icmpv6Packet +impl From> for Vec where T: Into>, { - fn into(self) -> Vec { + fn from(packet: Icmpv6Packet) -> Self { // Convert the payload into raw bytes - let payload: Vec = self.payload.into(); + let payload: Vec = packet.payload.into(); // Allocate a mutable packet to write into let total_length = @@ -100,8 +100,8 @@ where pnet_packet::icmpv6::MutableIcmpv6Packet::owned(vec![0u8; total_length]).unwrap(); // Write the type and code - output.set_icmpv6_type(self.icmp_type); - output.set_icmpv6_code(self.icmp_code); + output.set_icmpv6_type(packet.icmp_type); + output.set_icmpv6_code(packet.icmp_code); // Write the payload output.set_payload(&payload); @@ -110,8 +110,8 @@ where output.set_checksum(0); output.set_checksum(pnet_packet::icmpv6::checksum( &output.to_immutable(), - &self.source_address, - &self.destination_address, + &packet.source_address, + &packet.destination_address, )); // Return the raw bytes diff --git a/src/packet/protocols/ipv4.rs b/src/packet/protocols/ipv4.rs index b83c65d..6b17f6b 100644 --- a/src/packet/protocols/ipv4.rs +++ b/src/packet/protocols/ipv4.rs @@ -25,6 +25,7 @@ pub struct Ipv4Packet { impl Ipv4Packet { /// Construct a new IPv4 packet + #[allow(clippy::too_many_arguments)] pub fn new( dscp: u8, ecn: u8, @@ -53,6 +54,7 @@ impl Ipv4Packet { } } + #[allow(clippy::cast_possible_truncation)] fn options_length_words(&self) -> u8 { self.options .iter() @@ -70,8 +72,8 @@ where fn try_from(bytes: Vec) -> Result { // Parse the packet - let packet = - pnet_packet::ipv4::Ipv4Packet::new(&bytes).ok_or(PacketError::TooShort(bytes.len(), bytes.to_vec()))?; + let packet = pnet_packet::ipv4::Ipv4Packet::new(&bytes) + .ok_or(PacketError::TooShort(bytes.len(), bytes.clone()))?; // Return the packet Ok(Self { @@ -90,42 +92,42 @@ where } } -impl Into> for Ipv4Packet +impl From> for Vec where T: Into> + Clone, { - fn into(self) -> Vec { + fn from(packet: Ipv4Packet) -> Self { // Convert the payload into raw bytes - let payload: Vec = self.payload.clone().into(); + let payload: Vec = packet.payload.clone().into(); // Build the packet - let total_length = 20 + (self.options_length_words() as usize * 4) + payload.len(); - let mut packet = + let total_length = 20 + (packet.options_length_words() as usize * 4) + payload.len(); + let mut output = pnet_packet::ipv4::MutableIpv4Packet::owned(vec![0u8; total_length]).unwrap(); // Set the fields - packet.set_version(4); - packet.set_header_length(5 + self.options_length_words()); - packet.set_dscp(self.dscp); - packet.set_ecn(self.ecn); - packet.set_total_length(total_length.try_into().unwrap()); - packet.set_identification(self.identification); - packet.set_flags(self.flags); - packet.set_fragment_offset(self.fragment_offset); - packet.set_ttl(self.ttl); - packet.set_next_level_protocol(self.protocol); - packet.set_source(self.source_address); - packet.set_destination(self.destination_address); - packet.set_options(&self.options); + output.set_version(4); + output.set_header_length(5 + packet.options_length_words()); + output.set_dscp(packet.dscp); + output.set_ecn(packet.ecn); + output.set_total_length(total_length.try_into().unwrap()); + output.set_identification(packet.identification); + output.set_flags(packet.flags); + output.set_fragment_offset(packet.fragment_offset); + output.set_ttl(packet.ttl); + output.set_next_level_protocol(packet.protocol); + output.set_source(packet.source_address); + output.set_destination(packet.destination_address); + output.set_options(&packet.options); // Set the payload - packet.set_payload(&payload); + output.set_payload(&payload); // Calculate the checksum - packet.set_checksum(0); - packet.set_checksum(pnet_packet::ipv4::checksum(&packet.to_immutable())); + output.set_checksum(0); + output.set_checksum(pnet_packet::ipv4::checksum(&output.to_immutable())); // Return the packet - packet.to_immutable().packet().to_vec() + output.to_immutable().packet().to_vec() } } diff --git a/src/packet/protocols/ipv6.rs b/src/packet/protocols/ipv6.rs index 253958b..bd89377 100644 --- a/src/packet/protocols/ipv6.rs +++ b/src/packet/protocols/ipv6.rs @@ -46,8 +46,8 @@ where fn try_from(bytes: Vec) -> Result { // Parse the packet - let packet = - pnet_packet::ipv6::Ipv6Packet::new(&bytes).ok_or(PacketError::TooShort(bytes.len(), bytes.to_vec()))?; + let packet = pnet_packet::ipv6::Ipv6Packet::new(&bytes) + .ok_or(PacketError::TooShort(bytes.len(), bytes.clone()))?; // Return the packet Ok(Self { @@ -62,13 +62,13 @@ where } } -impl Into> for Ipv6Packet +impl From> for Vec where T: Into>, { - fn into(self) -> Vec { + fn from(packet: Ipv6Packet) -> Self { // Convert the payload into raw bytes - let payload: Vec = self.payload.into(); + let payload: Vec = packet.payload.into(); // Allocate a mutable packet to write into let total_length = @@ -78,13 +78,13 @@ where // Write the header output.set_version(6); - output.set_traffic_class(self.traffic_class); - output.set_flow_label(self.flow_label); - output.set_payload_length(payload.len() as u16); - output.set_next_header(self.next_header); - output.set_hop_limit(self.hop_limit); - output.set_source(self.source_address); - output.set_destination(self.destination_address); + output.set_traffic_class(packet.traffic_class); + output.set_flow_label(packet.flow_label); + output.set_payload_length(u16::try_from(payload.len()).unwrap()); + output.set_next_header(packet.next_header); + output.set_hop_limit(packet.hop_limit); + output.set_source(packet.source_address); + output.set_destination(packet.destination_address); // Write the payload output.set_payload(&payload); diff --git a/src/packet/protocols/raw.rs b/src/packet/protocols/raw.rs index b3bbb3a..91e10e7 100644 --- a/src/packet/protocols/raw.rs +++ b/src/packet/protocols/raw.rs @@ -11,8 +11,8 @@ impl TryFrom> for RawBytes { } } -impl Into> for RawBytes { - fn into(self) -> Vec { - self.0 +impl From for Vec { + fn from(val: RawBytes) -> Self { + val.0 } } \ No newline at end of file diff --git a/src/packet/protocols/tcp.rs b/src/packet/protocols/tcp.rs index ca71159..d1623e5 100644 --- a/src/packet/protocols/tcp.rs +++ b/src/packet/protocols/tcp.rs @@ -24,6 +24,7 @@ pub struct TcpPacket { impl TcpPacket { /// Construct a new TCP packet + #[allow(clippy::too_many_arguments)] pub fn new( source: SocketAddr, destination: SocketAddr, @@ -102,11 +103,12 @@ impl TcpPacket { } /// Get the length of the options in words - fn options_length(&self) -> usize { + #[allow(clippy::cast_possible_truncation)] + fn options_length(&self) -> u8 { self.options .iter() - .map(|option| TcpOptionPacket::packet_size(option)) - .sum::() + .map(|option| TcpOptionPacket::packet_size(option) as u8) + .sum::() } } @@ -139,10 +141,10 @@ where destination: SocketAddr::new(destination_address, parsed.get_destination()), sequence: parsed.get_sequence(), ack_number: parsed.get_acknowledgement(), - flags: parsed.get_flags() as u8, + flags: parsed.get_flags(), window_size: parsed.get_window(), urgent_pointer: parsed.get_urgent_ptr(), - options: parsed.get_options().to_vec(), + options: parsed.get_options().clone(), payload: parsed.payload().to_vec().into(), }) } @@ -173,62 +175,62 @@ impl TcpPacket { destination: SocketAddr::new(destination_address, parsed.get_destination()), sequence: parsed.get_sequence(), ack_number: parsed.get_acknowledgement(), - flags: parsed.get_flags() as u8, + flags: parsed.get_flags(), window_size: parsed.get_window(), urgent_pointer: parsed.get_urgent_ptr(), - options: parsed.get_options().to_vec(), + options: parsed.get_options().clone(), payload: RawBytes(parsed.payload().to_vec()), }) } } -impl Into> for TcpPacket +impl From> for Vec where T: Into>, { - fn into(self) -> Vec { + fn from(packet: TcpPacket) -> Self { // Get the options length in words - let options_length = self.options_length(); + let options_length = packet.options_length(); // Convert the payload into raw bytes - let payload: Vec = self.payload.into(); + let payload: Vec = packet.payload.into(); // Allocate a mutable packet to write into let total_length = pnet_packet::tcp::MutableTcpPacket::minimum_packet_size() - + options_length + + options_length as usize + payload.len(); let mut output = pnet_packet::tcp::MutableTcpPacket::owned(vec![0u8; total_length]).unwrap(); // Write the source and dest ports - output.set_source(self.source.port()); - output.set_destination(self.destination.port()); + output.set_source(packet.source.port()); + output.set_destination(packet.destination.port()); // Write the sequence and ack numbers - output.set_sequence(self.sequence); - output.set_acknowledgement(self.ack_number); + output.set_sequence(packet.sequence); + output.set_acknowledgement(packet.ack_number); // Write the offset - output.set_data_offset(5 + (options_length / 4) as u8); + output.set_data_offset(5 + (options_length / 4)); // Write the options - output.set_options(&self.options); + output.set_options(&packet.options); // Write the flags - output.set_flags(self.flags.into()); + output.set_flags(packet.flags); // Write the window size - output.set_window(self.window_size); + output.set_window(packet.window_size); // Write the urgent pointer - output.set_urgent_ptr(self.urgent_pointer); + output.set_urgent_ptr(packet.urgent_pointer); // Write the payload output.set_payload(&payload); // Calculate the checksum output.set_checksum(0); - output.set_checksum(match (self.source.ip(), self.destination.ip()) { + output.set_checksum(match (packet.source.ip(), packet.destination.ip()) { (IpAddr::V4(source_ip), IpAddr::V4(destination_ip)) => { pnet_packet::tcp::ipv4_checksum(&output.to_immutable(), &source_ip, &destination_ip) } diff --git a/src/packet/protocols/udp.rs b/src/packet/protocols/udp.rs index 56200a7..98b73dd 100644 --- a/src/packet/protocols/udp.rs +++ b/src/packet/protocols/udp.rs @@ -141,13 +141,13 @@ impl UdpPacket { } } -impl Into> for UdpPacket +impl From> for Vec where T: Into>, { - fn into(self) -> Vec { + fn from(packet: UdpPacket) -> Self { // Convert the payload into raw bytes - let payload: Vec = self.payload.into(); + let payload: Vec = packet.payload.into(); // Allocate a mutable packet to write into let total_length = @@ -156,18 +156,18 @@ where pnet_packet::udp::MutableUdpPacket::owned(vec![0u8; total_length]).unwrap(); // Write the source and dest ports - output.set_source(self.source.port()); - output.set_destination(self.destination.port()); + output.set_source(packet.source.port()); + output.set_destination(packet.destination.port()); // Write the length - output.set_length(total_length as u16); + output.set_length(u16::try_from(total_length).unwrap()); // Write the payload output.set_payload(&payload); // Calculate the checksum output.set_checksum(0); - output.set_checksum(match (self.source.ip(), self.destination.ip()) { + output.set_checksum(match (packet.source.ip(), packet.destination.ip()) { (IpAddr::V4(source_ip), IpAddr::V4(destination_ip)) => { pnet_packet::udp::ipv4_checksum(&output.to_immutable(), &source_ip, &destination_ip) } diff --git a/src/packet/xlat/icmp/mod.rs b/src/packet/xlat/icmp/mod.rs index d40563f..f0479b0 100644 --- a/src/packet/xlat/icmp/mod.rs +++ b/src/packet/xlat/icmp/mod.rs @@ -1,3 +1,5 @@ +#![allow(clippy::doc_markdown)] + use std::net::{Ipv4Addr, Ipv6Addr}; use pnet_packet::{icmp::IcmpTypes, icmpv6::Icmpv6Types}; @@ -92,7 +94,7 @@ pub fn translate_icmpv6_to_icmp( // Translate let inner_payload = - translate_ipv6_to_ipv4(inner_payload.try_into()?, new_source, new_destination)?; + translate_ipv6_to_ipv4(&inner_payload.try_into()?, new_source, new_destination)?; let inner_payload: Vec = inner_payload.into(); // Build the new payload diff --git a/src/packet/xlat/icmp/type_code.rs b/src/packet/xlat/icmp/type_code.rs index e7cb6cd..8aead6c 100644 --- a/src/packet/xlat/icmp/type_code.rs +++ b/src/packet/xlat/icmp/type_code.rs @@ -1,5 +1,7 @@ //! Functions to map between ICMP and ICMPv6 types/codes +#![allow(clippy::doc_markdown)] + use pnet_packet::{ icmp::{destination_unreachable, IcmpCode, IcmpType, IcmpTypes}, icmpv6::{Icmpv6Code, Icmpv6Type, Icmpv6Types}, @@ -8,6 +10,7 @@ use pnet_packet::{ use crate::packet::error::PacketError; /// Best effort translation from an ICMP type and code to an ICMPv6 type and code +#[allow(clippy::deprecated_cfg_attr)] pub fn translate_type_and_code_4_to_6( icmp_type: IcmpType, icmp_code: IcmpCode, @@ -29,6 +32,7 @@ pub fn translate_type_and_code_4_to_6( (IcmpTypes::DestinationUnreachable, icmp_code) => Ok(( Icmpv6Types::DestinationUnreachable, #[cfg_attr(rustfmt, rustfmt_skip)] + #[allow(clippy::match_same_arms)] Icmpv6Code(match icmp_code { destination_unreachable::IcmpCodes::DestinationHostUnreachable => 3, destination_unreachable::IcmpCodes::DestinationProtocolUnreachable => 4, @@ -55,6 +59,7 @@ pub fn translate_type_and_code_4_to_6( } /// Best effort translation from an ICMPv6 type and code to an ICMP type and code +#[allow(clippy::deprecated_cfg_attr)] pub fn translate_type_and_code_6_to_4( icmp_type: Icmpv6Type, icmp_code: Icmpv6Code, @@ -76,6 +81,7 @@ pub fn translate_type_and_code_6_to_4( (Icmpv6Types::DestinationUnreachable, icmp_code) => Ok(( IcmpTypes::DestinationUnreachable, #[cfg_attr(rustfmt, rustfmt_skip)] + #[allow(clippy::match_same_arms)] match icmp_code.0 { 1 => destination_unreachable::IcmpCodes::CommunicationAdministrativelyProhibited, 2 => destination_unreachable::IcmpCodes::SourceHostIsolated, diff --git a/src/packet/xlat/ip.rs b/src/packet/xlat/ip.rs index 540638c..ae9804f 100644 --- a/src/packet/xlat/ip.rs +++ b/src/packet/xlat/ip.rs @@ -70,7 +70,7 @@ pub fn translate_ipv4_to_ipv6( /// Translates an IPv6 packet to an IPv4 packet pub fn translate_ipv6_to_ipv4( - input: Ipv6Packet>, + input: &Ipv6Packet>, new_source: Ipv4Addr, new_destination: Ipv4Addr, ) -> Result>, PacketError> { @@ -121,7 +121,7 @@ pub fn translate_ipv6_to_ipv4( new_source, new_destination, vec![], - new_payload.unwrap_or_else(Vec::new), + new_payload.unwrap_or_default(), ); // Return the output diff --git a/src/packet/xlat/tcp.rs b/src/packet/xlat/tcp.rs index 7dffe47..2b456c3 100644 --- a/src/packet/xlat/tcp.rs +++ b/src/packet/xlat/tcp.rs @@ -12,7 +12,7 @@ pub fn translate_tcp4_to_tcp6( new_destination_addr: Ipv6Addr, ) -> Result, PacketError> { // Build the packet - Ok(TcpPacket::new( + TcpPacket::new( SocketAddr::new(IpAddr::V6(new_source_addr), input.source().port()), SocketAddr::new(IpAddr::V6(new_destination_addr), input.destination().port()), input.sequence, @@ -22,7 +22,7 @@ pub fn translate_tcp4_to_tcp6( input.urgent_pointer, input.options, input.payload, - )?) + ) } /// Translates an IPv6 TCP packet to an IPv4 TCP packet @@ -32,7 +32,7 @@ pub fn translate_tcp6_to_tcp4( new_destination_addr: Ipv4Addr, ) -> Result, PacketError> { // Build the packet - Ok(TcpPacket::new( + TcpPacket::new( SocketAddr::new(IpAddr::V4(new_source_addr), input.source().port()), SocketAddr::new(IpAddr::V4(new_destination_addr), input.destination().port()), input.sequence, @@ -42,7 +42,7 @@ pub fn translate_tcp6_to_tcp4( input.urgent_pointer, input.options, input.payload, - )?) + ) } #[cfg(test)] diff --git a/src/packet/xlat/udp.rs b/src/packet/xlat/udp.rs index cd8a34b..df2a74b 100644 --- a/src/packet/xlat/udp.rs +++ b/src/packet/xlat/udp.rs @@ -12,11 +12,11 @@ pub fn translate_udp4_to_udp6( new_destination_addr: Ipv6Addr, ) -> Result, PacketError> { // Build the packet - Ok(UdpPacket::new( + UdpPacket::new( SocketAddr::new(IpAddr::V6(new_source_addr), input.source().port()), SocketAddr::new(IpAddr::V6(new_destination_addr), input.destination().port()), input.payload, - )?) + ) } /// Translates an IPv6 UDP packet to an IPv4 UDP packet @@ -26,11 +26,11 @@ pub fn translate_udp6_to_udp4( new_destination_addr: Ipv4Addr, ) -> Result, PacketError> { // Build the packet - Ok(UdpPacket::new( + UdpPacket::new( SocketAddr::new(IpAddr::V4(new_source_addr), input.source().port()), SocketAddr::new(IpAddr::V4(new_destination_addr), input.destination().port()), input.payload, - )?) + ) } #[cfg(test)]