evan/protomask
1
Fork 0
Code

Fix all existing clippy warnings

Browse Source
This commit is contained in:
Evan Pratten 2023-07-21 09:59:11 -04:00
parent 9f4dc5a42f
commit a9c4d499a7
16 changed files with 130 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/cli/logging.rs
View File

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

4
src/lib.rs
View File

@ -2,8 +2,6 @@
//!
//! *Note: There is a fair chance you are looking for `src/cli/main.rs` instead of this file.*
#[warn(clippy::deprecated_cfg_attr)]
pub mod metrics;
pub mod nat;
mod packet;
pub mod metrics;

3
src/metrics/mod.rs
View File

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

12
src/nat/error.rs
View File

@ -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<Vec<u8>>),
PacketSend(#[from] tokio::sync::mpsc::error::SendError<Vec<u8>>),
}

71
src/nat/table.rs
View File

@ -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<IpAddr, TableError> {
// 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
}

10
src/packet/protocols/icmp.rs
View File

@ -43,13 +43,13 @@ where
}
}
impl<T> Into<Vec<u8>> for IcmpPacket<T>
impl<T> From<IcmpPacket<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: IcmpPacket<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = 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);

14
src/packet/protocols/icmpv6.rs
View File

@ -85,13 +85,13 @@ impl Icmpv6Packet<RawBytes> {
}
}
impl<T> Into<Vec<u8>> for Icmpv6Packet<T>
impl<T> From<Icmpv6Packet<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: Icmpv6Packet<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = 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

49
src/packet/protocols/ipv4.rs
View File

@ -25,6 +25,7 @@ pub struct Ipv4Packet<T> {
impl<T> Ipv4Packet<T> {
/// Construct a new IPv4 packet
#[allow(clippy::too_many_arguments)]
pub fn new(
dscp: u8,
ecn: u8,
@ -70,8 +71,8 @@ where
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
// 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.to_vec()))?;
// Return the packet
Ok(Self {
@ -90,42 +91,42 @@ where
}
}
impl<T> Into<Vec<u8>> for Ipv4Packet<T>
impl<T> From<Ipv4Packet<T>> for Vec<u8>
where
T: Into<Vec<u8>> + Clone,
{
fn into(self) -> Vec<u8> {
fn from(packet: Ipv4Packet<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.clone().into();
let payload: Vec<u8> = 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()
}
}

22
src/packet/protocols/ipv6.rs
View File

@ -46,8 +46,8 @@ where
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
// 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.to_vec()))?;
// Return the packet
Ok(Self {
@ -62,13 +62,13 @@ where
}
}
impl<T> Into<Vec<u8>> for Ipv6Packet<T>
impl<T> From<Ipv6Packet<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: Ipv6Packet<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = 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_traffic_class(packet.traffic_class);
output.set_flow_label(packet.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_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);

6
src/packet/protocols/raw.rs
View File

@ -11,8 +11,8 @@ impl TryFrom<Vec<u8>> for RawBytes {
}
}
impl Into<Vec<u8>> for RawBytes {
fn into(self) -> Vec<u8> {
self.0
impl From<RawBytes> for Vec<u8> {
fn from(val: RawBytes) -> Self {
val.0
}
}

33
src/packet/protocols/tcp.rs
View File

@ -24,6 +24,7 @@ pub struct TcpPacket<T> {
impl<T> TcpPacket<T> {
/// Construct a new TCP packet
#[allow(clippy::too_many_arguments)]
pub fn new(
source: SocketAddr,
destination: SocketAddr,
@ -105,7 +106,7 @@ impl<T> TcpPacket<T> {
fn options_length(&self) -> usize {
self.options
.iter()
.map(|option| TcpOptionPacket::packet_size(option))
.map(TcpOptionPacket::packet_size)
.sum::<usize>()
}
}
@ -139,7 +140,7 @@ 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(),
@ -173,7 +174,7 @@ impl TcpPacket<RawBytes> {
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(),
@ -182,16 +183,16 @@ impl TcpPacket<RawBytes> {
}
}
impl<T> Into<Vec<u8>> for TcpPacket<T>
impl<T> From<TcpPacket<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: TcpPacket<T>) -> 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<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length = pnet_packet::tcp::MutableTcpPacket::minimum_packet_size()
@ -201,34 +202,34 @@ where
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);
// 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)
}

12
src/packet/protocols/udp.rs
View File

@ -141,13 +141,13 @@ impl UdpPacket<RawBytes> {
}
}
impl<T> Into<Vec<u8>> for UdpPacket<T>
impl<T> From<UdpPacket<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: UdpPacket<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length =
@ -156,8 +156,8 @@ 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);
@ -167,7 +167,7 @@ where
// 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)
}

2
src/packet/xlat/icmp/type_code.rs
View File

@ -8,6 +8,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,
@ -55,6 +56,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,

2
src/packet/xlat/ip.rs
View File

@ -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

8
src/packet/xlat/tcp.rs
View File

@ -12,7 +12,7 @@ pub fn translate_tcp4_to_tcp6(
new_destination_addr: Ipv6Addr,
) -> Result<TcpPacket<RawBytes>, 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<TcpPacket<RawBytes>, 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)]

8
src/packet/xlat/udp.rs
View File

@ -12,11 +12,11 @@ pub fn translate_udp4_to_udp6(
new_destination_addr: Ipv6Addr,
) -> Result<UdpPacket<RawBytes>, 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<UdpPacket<RawBytes>, 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)]