Migrate to 2024 edition

Cargo.toml

@@ -31,14 +31,14 @@ authors = [
 version = "0.13.0-dev"
 publish = false
 repository = "https://github.com/mitmproxy/mitmproxy-rs"
-edition = "2021"
+edition = "2024"
 rust-version = "1.88"  # MSRV
 
 [workspace.dependencies]
 aya = { version = "0.13.0", default-features = false }
 aya-ebpf = { version = "0.1.1", default-features = false }
 aya-log = { version = "0.2.1", default-features = false }
-aya-log-ebpf = { version = "0.1.1", default-features = false }
+aya-log-ebpf = { version = "0.1.0", default-features = false }
 tun = { version = "0.8.5" }
 
 [workspace.lints.clippy]
@@ -97,8 +97,7 @@ security-framework = "3.2.0"
 nix = { version = "0.30.1", default-features = false, features = ["fs"] }
 core-graphics = "0.25"
 core-foundation = "0.10"
-cocoa = "0.26"
-objc = "0.2"
+objc2-app-kit = { version = "0.3.2", features = ["NSRunningApplication", "NSImage", "libc"] }
 sysinfo = "0.36.1"
 
 [target.'cfg(target_os = "linux")'.dependencies]
@@ -123,6 +122,3 @@ opt-level = 3
 
 [features]
 tracing = ["console-subscriber"]
-# This feature solely exists to silence warnings caused by objc 0.2.7,
-# see https://github.com/SSheldon/rust-objc/issues/125
-cargo-clippy = []

benches/process.rs

@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 #[cfg(any(windows, target_os = "macos"))]
 use mitmproxy::processes;
 

mitmproxy-contentviews/benches/contentviews.rs

@@ -1,5 +1,5 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-use mitmproxy_contentviews::{test::TestMetadata, MsgPack, Prettify, Protobuf, Reencode};
+use criterion::{Criterion, criterion_group, criterion_main};
+use mitmproxy_contentviews::{MsgPack, Prettify, Protobuf, Reencode, test::TestMetadata};
 use std::hint::black_box;
 
 fn criterion_benchmark(c: &mut Criterion) {

mitmproxy-contentviews/src/hex_dump.rs

@@ -25,11 +25,7 @@ impl Prettify for HexDump {
     }
 
     fn render_priority(&self, data: &[u8], _metadata: &dyn Metadata) -> f32 {
-        if is_binary(data) {
-            0.5
-        } else {
-            0.0
-        }
+        if is_binary(data) { 0.5 } else { 0.0 }
     }
 }
 

mitmproxy-contentviews/src/hex_stream.rs

@@ -27,11 +27,7 @@ impl Prettify for HexStream {
     }
 
     fn render_priority(&self, data: &[u8], _metadata: &dyn Metadata) -> f32 {
-        if is_binary(data) {
-            0.4
-        } else {
-            0.0
-        }
+        if is_binary(data) { 0.4 } else { 0.0 }
     }
 }
 

mitmproxy-contentviews/src/lib.rs

@@ -7,8 +7,8 @@ mod test_inspect_metadata;
 pub use hex_dump::HexDump;
 pub use hex_stream::HexStream;
 pub use msgpack::MsgPack;
-pub use protobuf::Protobuf;
 pub use protobuf::GRPC;
+pub use protobuf::Protobuf;
 pub use test_inspect_metadata::TestInspectMetadata;
 
 use anyhow::Result;

mitmproxy-contentviews/src/protobuf/existing_proto_definitions.rs

@@ -1,5 +1,5 @@
-use crate::protobuf::raw_to_proto::new_empty_descriptor;
 use crate::Metadata;
+use crate::protobuf::raw_to_proto::new_empty_descriptor;
 use anyhow::Context;
 use protobuf::reflect::{FileDescriptor, MessageDescriptor};
 use protobuf_parse::Parser;
@@ -89,19 +89,19 @@ fn find_best_message(
     }
 
     let file = fds.first()?;
-    if let Some(service) = file.services().next() {
-        if let Some(method) = service.methods().next() {
-            log::info!(
-                "Falling back to first defined service in {}: {}",
-                file.name(),
-                service.proto().name()
-            );
-            return Some(if is_request {
-                method.input_type()
-            } else {
-                method.output_type()
-            });
-        }
+    if let Some(service) = file.services().next()
+        && let Some(method) = service.methods().next()
+    {
+        log::info!(
+            "Falling back to first defined service in {}: {}",
+            file.name(),
+            service.proto().name()
+        );
+        return Some(if is_request {
+            method.input_type()
+        } else {
+            method.output_type()
+        });
     }
     if let Some(method) = file.messages().next() {
         log::info!(

mitmproxy-contentviews/src/protobuf/proto_to_yaml.rs

@@ -1,11 +1,11 @@
 use crate::protobuf::view_protobuf::tags;
+use protobuf::MessageDyn;
 /// Parsed protobuf message => YAML value
 use protobuf::descriptor::field_descriptor_proto::Type;
 use protobuf::descriptor::field_descriptor_proto::Type::{
     TYPE_BYTES, TYPE_FIXED32, TYPE_FIXED64, TYPE_UINT64,
 };
 use protobuf::reflect::{ReflectFieldRef, ReflectValueRef};
-use protobuf::MessageDyn;
 use serde_yaml::value::TaggedValue;
 use serde_yaml::{Mapping, Number, Value};
 use std::ops::Deref;

mitmproxy-contentviews/src/protobuf/raw_to_proto.rs

@@ -182,14 +182,13 @@ fn guess_field_type(
         parent.file_descriptor_proto().package.clone(),
         &format!("{}.UnknownField{}", parent.name_to_package(), field_index),
     );
-    if let Ok(descriptor) = create_descriptor_proto(values[0], &existing) {
-        if values
+    if let Ok(descriptor) = create_descriptor_proto(values[0], &existing)
+        && values
             .iter()
             .skip(1)
             .all(|data| descriptor.descriptor_dyn().parse_from_bytes(data).is_ok())
-        {
-            return GuessedFieldType::Message(Box::new(descriptor));
-        }
+    {
+        return GuessedFieldType::Message(Box::new(descriptor));
     }
 
     GuessedFieldType::Unknown

mitmproxy-contentviews/src/protobuf/reencode.rs

@@ -1,5 +1,5 @@
 use crate::protobuf::view_protobuf::tags;
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use protobuf::descriptor::field_descriptor_proto::Type;
 use protobuf::descriptor::field_descriptor_proto::Type::{TYPE_FIXED32, TYPE_FIXED64};
 use protobuf::reflect::{FieldDescriptor, MessageDescriptor, RuntimeFieldType, RuntimeType};
@@ -138,29 +138,29 @@ fn add_field(message: &mut dyn MessageDyn, field_num: u32, value: Value) -> anyh
 }
 
 fn int_value(n: Number, field: Option<&FieldDescriptor>) -> UnknownValue {
-    if let Some(field) = field {
-        if let Some(typ) = field.proto().type_.and_then(|t| t.enum_value().ok()) {
-            match typ {
-                TYPE_FIXED64 | Type::TYPE_SFIXED64 | Type::TYPE_DOUBLE => {
-                    return if let Some(n) = n.as_u64() {
-                        UnknownValue::Fixed64(n)
-                    } else if let Some(n) = n.as_i64() {
-                        UnknownValue::sfixed64(n)
-                    } else {
-                        UnknownValue::double(n.as_f64().expect("as_f64 never fails"))
-                    }
-                }
-                TYPE_FIXED32 | Type::TYPE_SFIXED32 | Type::TYPE_FLOAT => {
-                    return if let Some(n) = n.as_u64() {
-                        UnknownValue::Fixed32(n as u32)
-                    } else if let Some(n) = n.as_i64() {
-                        UnknownValue::sfixed32(n as i32)
-                    } else {
-                        UnknownValue::float(n.as_f64().expect("as_f64 never fails") as f32)
-                    }
-                }
-                _ => (),
+    if let Some(field) = field
+        && let Some(typ) = field.proto().type_.and_then(|t| t.enum_value().ok())
+    {
+        match typ {
+            TYPE_FIXED64 | Type::TYPE_SFIXED64 | Type::TYPE_DOUBLE => {
+                return if let Some(n) = n.as_u64() {
+                    UnknownValue::Fixed64(n)
+                } else if let Some(n) = n.as_i64() {
+                    UnknownValue::sfixed64(n)
+                } else {
+                    UnknownValue::double(n.as_f64().expect("as_f64 never fails"))
+                };
+            }
+            TYPE_FIXED32 | Type::TYPE_SFIXED32 | Type::TYPE_FLOAT => {
+                return if let Some(n) = n.as_u64() {
+                    UnknownValue::Fixed32(n as u32)
+                } else if let Some(n) = n.as_i64() {
+                    UnknownValue::sfixed32(n as i32)
+                } else {
+                    UnknownValue::float(n.as_f64().expect("as_f64 never fails") as f32)
+                };
             }
+            _ => (),
         }
     }
     if let Some(n) = n.as_u64() {

mitmproxy-contentviews/src/protobuf/view_grpc.rs

@@ -1,7 +1,7 @@
 use super::{existing_proto_definitions, reencode};
 use crate::protobuf::existing_proto_definitions::DescriptorWithDeps;
 use crate::{Metadata, Prettify, Protobuf, Reencode};
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use flate2::read::{DeflateDecoder, GzDecoder};
 use log::info;
 use mitmproxy_highlight::Language;
@@ -23,10 +23,10 @@ impl Prettify for GRPC {
     fn prettify(&self, data: &[u8], metadata: &dyn Metadata) -> Result<String> {
         let encoding = metadata.get_header("grpc-encoding").unwrap_or_default();
         let proto_def = existing_proto_definitions::find_best_match(metadata)?;
-        if let Some(descriptor) = &proto_def {
-            if let Ok(ret) = self.prettify_with_descriptor(data, &encoding, descriptor) {
-                return Ok(ret);
-            }
+        if let Some(descriptor) = &proto_def
+            && let Ok(ret) = self.prettify_with_descriptor(data, &encoding, descriptor)
+        {
+            return Ok(ret);
         }
         let ret = self.prettify_with_descriptor(data, &encoding, &DescriptorWithDeps::default())?;
         if proto_def.is_some() {

mitmproxy-contentviews/src/protobuf/view_protobuf.rs

@@ -40,10 +40,10 @@ impl Prettify for Protobuf {
 
     fn prettify(&self, data: &[u8], metadata: &dyn Metadata) -> Result<String> {
         let proto_def = existing_proto_definitions::find_best_match(metadata)?;
-        if let Some(descriptor) = &proto_def {
-            if let Ok(ret) = self.prettify_with_descriptor(data, descriptor) {
-                return Ok(ret);
-            }
+        if let Some(descriptor) = &proto_def
+            && let Ok(ret) = self.prettify_with_descriptor(data, descriptor)
+        {
+            return Ok(ret);
         }
         let ret = self.prettify_with_descriptor(data, &DescriptorWithDeps::default())?;
         if proto_def.is_some() {
@@ -202,7 +202,10 @@ mod tests {
         let result = Protobuf.prettify(
             b"\n\x13gRPC testing server\x12\x07\n\x05Index\x12\x07\n\x05Empty\x12\x0c\n\nDummyUnary\x12\x0f\n\rSpecificError\x12\r\n\x0bRandomError\x12\x0e\n\x0cHeadersUnary\x12\x11\n\x0fNoResponseUnary",
             &TestMetadata::default()).unwrap();
-        assert_eq!(result,  "1: gRPC testing server\n2:\n- 1: Index\n- 1: Empty\n- 1: DummyUnary\n- 1: SpecificError\n- 1: RandomError\n- 1: HeadersUnary\n- 1: NoResponseUnary\n");
+        assert_eq!(
+            result,
+            "1: gRPC testing server\n2:\n- 1: Index\n- 1: Empty\n- 1: DummyUnary\n- 1: SpecificError\n- 1: RandomError\n- 1: HeadersUnary\n- 1: NoResponseUnary\n"
+        );
     }
 
     #[test]

mitmproxy-highlight/benches/syntax_highlight.rs

@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use mitmproxy_highlight::Language;
 use std::hint::black_box;
 

mitmproxy-highlight/src/css.rs

@@ -1,4 +1,4 @@
-use super::{common, Chunk, Tag};
+use super::{Chunk, Tag, common};
 use anyhow::Result;
 use std::sync::LazyLock;
 use tree_sitter_css::HIGHLIGHTS_QUERY;

mitmproxy-highlight/src/javascript.rs

@@ -1,4 +1,4 @@
-use super::{common, Chunk, Tag};
+use super::{Chunk, Tag, common};
 use anyhow::Result;
 use std::sync::LazyLock;
 use tree_sitter_highlight::HighlightConfiguration;

mitmproxy-linux-ebpf/src/main.rs

@@ -1,14 +1,14 @@
 #![no_std]
 #![no_main]
 
+use aya_ebpf::EbpfContext;
 use aya_ebpf::macros::{cgroup_sock, map};
 use aya_ebpf::maps::Array;
 use aya_ebpf::programs::SockContext;
-use aya_ebpf::EbpfContext;
 use aya_log_ebpf::debug;
 use mitmproxy_linux_ebpf_common::{Action, INTERCEPT_CONF_LEN};
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 static INTERFACE_ID: u32 = 0;
 
 #[map]

mitmproxy-linux/build.rs

@@ -1,5 +1,5 @@
 #[cfg(target_os = "linux")]
-use anyhow::{anyhow, Context as _};
+use anyhow::{Context as _, anyhow};
 
 #[cfg(target_os = "linux")]
 use aya_build::Toolchain;

mitmproxy-rs/pytests/logger.rs

@@ -1,7 +1,7 @@
 use log::{LevelFilter, Log, Metadata, Record};
 use std::sync::LazyLock;
 use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
-use tokio::sync::{mpsc, Mutex, MutexGuard};
+use tokio::sync::{Mutex, MutexGuard, mpsc};
 
 /// A logger for tests to ensure that log statements are made.
 pub struct TestLogger {

mitmproxy-rs/pytests/test_task.rs

@@ -47,11 +47,13 @@ mod tests {
         )
         .await?;
         logger.wait_for("shutting down").await;
-        assert!(!logger
-            .logs()
-            .await
-            .into_iter()
-            .any(|l| l.contains("exception")));
+        assert!(
+            !logger
+                .logs()
+                .await
+                .into_iter()
+                .any(|l| l.contains("exception"))
+        );
         Ok(())
     }
 

mitmproxy-rs/src/dns_resolver.rs

@@ -1,4 +1,4 @@
-use mitmproxy::dns::{ResolveError, DNS_SERVERS};
+use mitmproxy::dns::{DNS_SERVERS, ResolveError};
 use pyo3::exceptions::socket::gaierror;
 use pyo3::prelude::*;
 use pyo3::types::PyAny;

mitmproxy-rs/src/lib.rs

@@ -47,39 +47,39 @@ mod mitmproxy_rs {
     #[pymodule]
     mod dns {
         #[pymodule_export]
-        use crate::dns_resolver::{get_system_dns_servers, DnsResolver};
+        use crate::dns_resolver::{DnsResolver, get_system_dns_servers};
     }
 
     #[pymodule]
     mod local {
         #[pymodule_export]
-        use crate::server::{start_local_redirector, LocalRedirector};
+        use crate::server::{LocalRedirector, start_local_redirector};
     }
 
     #[pymodule]
     mod process_info {
         #[pymodule_export]
-        use crate::process_info::{active_executables, executable_icon, Process};
+        use crate::process_info::{Process, active_executables, executable_icon};
     }
 
     #[pymodule]
     mod tun {
         #[pymodule_export]
-        use crate::server::{create_tun_interface, TunInterface};
+        use crate::server::{TunInterface, create_tun_interface};
     }
 
     #[pymodule]
     mod udp {
         #[pymodule_export]
-        use crate::server::{start_udp_server, UdpServer};
+        use crate::server::{UdpServer, start_udp_server};
         #[pymodule_export]
         use crate::udp_client::open_udp_connection;
     }
 
     #[pymodule]
     mod wireguard {
         #[pymodule_export]
-        use crate::server::{start_wireguard_server, WireGuardServer};
+        use crate::server::{WireGuardServer, start_wireguard_server};
         #[pymodule_export]
         use crate::util::{genkey, pubkey};
     }
@@ -92,7 +92,7 @@ mod mitmproxy_rs {
         #[pymodule_export]
         use crate::contentviews::InteractiveContentview;
         use mitmproxy_contentviews::{
-            HexDump, HexStream, MsgPack, Protobuf, TestInspectMetadata, GRPC,
+            GRPC, HexDump, HexStream, MsgPack, Protobuf, TestInspectMetadata,
         };
 
         #[pymodule_init]