feat: updated edition 2024, msrv 1.85

Author: zonyitoo

.github/workflows/build-msrv.yml

@@ -28,9 +28,9 @@ jobs:
       - name: Install Rust
         run: |
           rustup set profile minimal
-          rustup toolchain install 1.83
-          rustup default 1.83
-          rustup override set 1.83
+          rustup toolchain install 1.85
+          rustup default 1.85
+          rustup override set 1.85
       - name: Build with All Features Enabled (Unix)
         if: ${{ runner.os == 'Linux' || runner.os == 'macOS' }}
         run: cargo build --verbose --features "full-extra local-flow-stat utility-url-outline"
@@ -55,9 +55,9 @@ jobs:
       - name: Install Rust
         run: |
           rustup set profile minimal
-          rustup toolchain install 1.83
-          rustup default 1.83
-          rustup override set 1.83
+          rustup toolchain install 1.85
+          rustup default 1.85
+          rustup override set 1.85
       - name: Build with All Features Enabled
         run: cargo build --manifest-path crates/shadowsocks-service/Cargo.toml --verbose --features "full dns-over-tls dns-over-https dns-over-h3 local-dns local-flow-stat local-http-rustls local-tun local-fake-dns local-online-config stream-cipher aead-cipher-extra aead-cipher-2022 aead-cipher-2022-extra security-replay-attack-detect"
 
@@ -78,8 +78,8 @@ jobs:
       - name: Install Rust
         run: |
           rustup set profile minimal
-          rustup toolchain install 1.77
-          rustup default 1.77
-          rustup override set 1.77
+          rustup toolchain install 1.85
+          rustup default 1.85
+          rustup override set 1.85
       - name: Build with All Features Enabled
         run: cargo build --manifest-path crates/shadowsocks/Cargo.toml --verbose --features "stream-cipher aead-cipher-extra aead-cipher-2022 aead-cipher-2022-extra security-replay-attack-detect"

Cargo.toml

@@ -8,8 +8,8 @@ readme = "README.md"
 documentation = "https://docs.rs/shadowsocks-rust"
 keywords = ["shadowsocks", "proxy", "socks", "socks5", "firewall"]
 license = "MIT"
-edition = "2021"
-rust-version = "1.83"
+edition = "2024"
+rust-version = "1.85"
 
 [badges]
 maintenance = { status = "passively-maintained" }

crates/shadowsocks-service/Cargo.toml

@@ -8,8 +8,8 @@ readme = "README.md"
 documentation = "https://docs.rs/shadowsocks-service"
 keywords = ["shadowsocks", "proxy", "socks", "socks5", "firewall"]
 license = "MIT"
-edition = "2021"
-rust-version = "1.83"
+edition = "2024"
+rust-version = "1.85"
 
 [badges]
 maintenance = { status = "passively-maintained" }

crates/shadowsocks-service/src/config.rs

@@ -2781,11 +2781,11 @@ impl fmt::Display for Config {
                 let local = &local_instance.config;
                 if let Some(ref a) = local.addr {
                     jconf.local_address = Some(match a {
-                        ServerAddr::SocketAddr(ref sa) => sa.ip().to_string(),
-                        ServerAddr::DomainName(ref dm, ..) => dm.to_string(),
+                        ServerAddr::SocketAddr(sa) => sa.ip().to_string(),
+                        ServerAddr::DomainName(dm, ..) => dm.to_string(),
                     });
                     jconf.local_port = Some(match a {
-                        ServerAddr::SocketAddr(ref sa) => sa.port(),
+                        ServerAddr::SocketAddr(sa) => sa.port(),
                         ServerAddr::DomainName(.., port) => *port,
                     });
                 }
@@ -2811,11 +2811,11 @@ impl fmt::Display for Config {
 
                     let jlocal = SSLocalExtConfig {
                         local_address: local.addr.as_ref().map(|a| match a {
-                            ServerAddr::SocketAddr(ref sa) => sa.ip().to_string(),
-                            ServerAddr::DomainName(ref dm, ..) => dm.to_string(),
+                            ServerAddr::SocketAddr(sa) => sa.ip().to_string(),
+                            ServerAddr::DomainName(dm, ..) => dm.to_string(),
                         }),
                         local_port: local.addr.as_ref().map(|a| match a {
-                            ServerAddr::SocketAddr(ref sa) => sa.port(),
+                            ServerAddr::SocketAddr(sa) => sa.port(),
                             ServerAddr::DomainName(.., port) => *port,
                         }),
                         disabled: None,
@@ -2853,25 +2853,25 @@ impl fmt::Display for Config {
                         forward_address: match local.forward_addr {
                             None => None,
                             Some(ref forward_addr) => match forward_addr {
-                                Address::SocketAddress(ref sa) => Some(sa.ip().to_string()),
-                                Address::DomainNameAddress(ref dm, ..) => Some(dm.to_string()),
+                                Address::SocketAddress(sa) => Some(sa.ip().to_string()),
+                                Address::DomainNameAddress(dm, ..) => Some(dm.to_string()),
                             },
                         },
                         #[cfg(feature = "local-tunnel")]
                         forward_port: match local.forward_addr {
                             None => None,
                             Some(ref forward_addr) => match forward_addr {
-                                Address::SocketAddress(ref sa) => Some(sa.port()),
+                                Address::SocketAddress(sa) => Some(sa.port()),
                                 Address::DomainNameAddress(.., port) => Some(*port),
                             },
                         },
                         #[cfg(feature = "local-dns")]
                         local_dns_address: match local.local_dns_addr {
                             None => None,
                             Some(ref local_dns_addr) => match local_dns_addr {
-                                NameServerAddr::SocketAddr(ref sa) => Some(sa.ip().to_string()),
+                                NameServerAddr::SocketAddr(sa) => Some(sa.ip().to_string()),
                                 #[cfg(unix)]
-                                NameServerAddr::UnixSocketAddr(ref path) => {
+                                NameServerAddr::UnixSocketAddr(path) => {
                                     Some(path.to_str().expect("path is not utf-8").to_owned())
                                 }
                             },
@@ -2880,7 +2880,7 @@ impl fmt::Display for Config {
                         local_dns_port: match local.local_dns_addr {
                             None => None,
                             Some(ref local_dns_addr) => match local_dns_addr {
-                                NameServerAddr::SocketAddr(ref sa) => Some(sa.port()),
+                                NameServerAddr::SocketAddr(sa) => Some(sa.port()),
                                 #[cfg(unix)]
                                 NameServerAddr::UnixSocketAddr(..) => None,
                             },
@@ -2889,15 +2889,15 @@ impl fmt::Display for Config {
                         remote_dns_address: match local.remote_dns_addr {
                             None => None,
                             Some(ref remote_dns_addr) => match remote_dns_addr {
-                                Address::SocketAddress(ref sa) => Some(sa.ip().to_string()),
-                                Address::DomainNameAddress(ref dm, ..) => Some(dm.to_string()),
+                                Address::SocketAddress(sa) => Some(sa.ip().to_string()),
+                                Address::DomainNameAddress(dm, ..) => Some(dm.to_string()),
                             },
                         },
                         #[cfg(feature = "local-dns")]
                         remote_dns_port: match local.remote_dns_addr {
                             None => None,
                             Some(ref remote_dns_addr) => match remote_dns_addr {
-                                Address::SocketAddress(ref sa) => Some(sa.port()),
+                                Address::SocketAddress(sa) => Some(sa.port()),
                                 Address::DomainNameAddress(.., port) => Some(*port),
                             },
                         },

crates/shadowsocks-service/src/local/context.rs

@@ -137,7 +137,7 @@ impl ServiceContext {
             Some(ref acl) => {
                 #[cfg(feature = "local-dns")]
                 {
-                    if let Address::SocketAddress(ref saddr) = addr {
+                    if let Address::SocketAddress(saddr) = addr {
                         // do the reverse lookup in our local cache
                         let mut reverse_lookup_cache = self.reverse_lookup_cache.lock().await;
                         // if a qname is found

crates/shadowsocks-service/src/local/dns/server.rs

@@ -211,15 +211,17 @@ impl DnsTcpServerBuilder {
     async fn build(self) -> io::Result<DnsTcpServer> {
         cfg_if::cfg_if! {
             if #[cfg(target_os = "macos")] {
-                let listener = if let Some(launchd_socket_name) = self.launchd_socket_name {
-                    use tokio::net::TcpListener as TokioTcpListener;
-                    use crate::net::launch_activate_socket::get_launch_activate_tcp_listener;
-
-                    let std_listener = get_launch_activate_tcp_listener(&launchd_socket_name, true)?;
-                    let tokio_listener = TokioTcpListener::from_std(std_listener)?;
-                    TcpListener::from_listener(tokio_listener, self.context.accept_opts())?
-                } else {
-                    create_standard_tcp_listener(&self.context, &self.bind_addr).await?
+                let listener = match self.launchd_socket_name {
+                    Some(launchd_socket_name) => {
+                        use tokio::net::TcpListener as TokioTcpListener;
+                        use crate::net::launch_activate_socket::get_launch_activate_tcp_listener;
+
+                        let std_listener = get_launch_activate_tcp_listener(&launchd_socket_name, true)?;
+                        let tokio_listener = TokioTcpListener::from_std(std_listener)?;
+                        TcpListener::from_listener(tokio_listener, self.context.accept_opts())?
+                    } _ => {
+                        create_standard_tcp_listener(&self.context, &self.bind_addr).await?
+                    }
                 };
             } else {
                 let listener = create_standard_tcp_listener(&self.context, &self.bind_addr).await?;
@@ -384,15 +386,15 @@ impl DnsUdpServerBuilder {
     async fn build(self) -> io::Result<DnsUdpServer> {
         cfg_if::cfg_if! {
             if #[cfg(target_os = "macos")] {
-                let socket = if let Some(launchd_socket_name) = self.launchd_socket_name {
+                let socket = match self.launchd_socket_name { Some(launchd_socket_name) => {
                     use tokio::net::UdpSocket as TokioUdpSocket;
                     use crate::net::launch_activate_socket::get_launch_activate_udp_socket;
 
                     let std_socket = get_launch_activate_udp_socket(&launchd_socket_name, true)?;
                     TokioUdpSocket::from_std(std_socket)?
-                } else {
+                } _ => {
                     create_standard_udp_listener(&self.context, &self.bind_addr).await?.into()
-                };
+                }};
             } else {
                 let socket = create_standard_udp_listener(&self.context, &self.bind_addr).await?.into();
             }
@@ -589,7 +591,7 @@ fn should_forward_by_query(context: &ServiceContext, balancer: &PingBalancer, qu
     // https://github.com/shadowsocks/shadowsocks-android/issues/2722
     for server in balancer.servers() {
         let svr_cfg = server.server_config();
-        if let ServerAddr::DomainName(ref dn, ..) = svr_cfg.addr() {
+        if let ServerAddr::DomainName(dn, ..) = svr_cfg.addr() {
             // Convert domain name to `Name`
             // Ignore it if error occurs
             if let Ok(name) = Name::from_str(dn) {
@@ -629,11 +631,11 @@ fn should_forward_by_response(
     query: &Query,
 ) -> bool {
     if let Some(acl) = acl {
-        if let Ok(ref local_response) = local_response {
+        if let Ok(local_response) = local_response {
             let mut names = HashSet::new();
             names.insert(query.name());
             macro_rules! examine_name {
-                ($name:expr, $is_answer:expr) => {{
+                ($name:expr_2021, $is_answer:expr_2021) => {{
                     names.insert($name);
                     if $is_answer {
                         if let Some(value) = check_name_in_proxy_list(acl, $name) {
@@ -647,7 +649,7 @@ fn should_forward_by_response(
                 }};
             }
             macro_rules! examine_record {
-                ($rec:ident, $is_answer:expr) => {
+                ($rec:ident, $is_answer:expr_2021) => {
                     if let RData::CNAME(name) = $rec.data() {
                         if $is_answer {
                             if let Some(value) = check_name_in_proxy_list(acl, name) {

crates/shadowsocks-service/src/local/http/http_client.rs

@@ -383,10 +383,13 @@ where
                     && (req.uri().scheme().is_some() || req.uri().authority().is_some())
                 {
                     let mut builder = Uri::builder();
-                    if let Some(path_and_query) = req.uri().path_and_query() {
-                        builder = builder.path_and_query(path_and_query.as_str());
-                    } else {
-                        builder = builder.path_and_query("/");
+                    match req.uri().path_and_query() {
+                        Some(path_and_query) => {
+                            builder = builder.path_and_query(path_and_query.as_str());
+                        }
+                        _ => {
+                            builder = builder.path_and_query("/");
+                        }
                     }
                     *(req.uri_mut()) = builder.build()?;
                 }

crates/shadowsocks-service/src/local/http/server.rs

@@ -58,15 +58,17 @@ impl HttpBuilder {
     pub async fn build(self) -> io::Result<Http> {
         cfg_if::cfg_if! {
             if #[cfg(target_os = "macos")] {
-                let listener = if let Some(launchd_socket_name) = self.launchd_tcp_socket_name {
-                    use tokio::net::TcpListener as TokioTcpListener;
-                    use crate::net::launch_activate_socket::get_launch_activate_tcp_listener;
-
-                    let std_listener = get_launch_activate_tcp_listener(&launchd_socket_name, true)?;
-                    let tokio_listener = TokioTcpListener::from_std(std_listener)?;
-                    TcpListener::from_listener(tokio_listener, self.context.accept_opts())?
-                } else {
-                    create_standard_tcp_listener(&self.context, &self.client_config).await?
+                let listener = match self.launchd_tcp_socket_name {
+                    Some(launchd_socket_name) => {
+                        use tokio::net::TcpListener as TokioTcpListener;
+                        use crate::net::launch_activate_socket::get_launch_activate_tcp_listener;
+
+                        let std_listener = get_launch_activate_tcp_listener(&launchd_socket_name, true)?;
+                        let tokio_listener = TokioTcpListener::from_std(std_listener)?;
+                        TcpListener::from_listener(tokio_listener, self.context.accept_opts())?
+                    } _ => {
+                        create_standard_tcp_listener(&self.context, &self.client_config).await?
+                    }
                 };
             } else {
                 let listener = create_standard_tcp_listener(&self.context, &self.client_config).await?;

crates/shadowsocks-service/src/local/net/udp/association.rs

@@ -447,14 +447,19 @@ where
                     err
                 );
             }
-        } else if let Err(err) = self.dispatch_received_proxied_packet(target_addr, data).await {
-            error!(
-                "udp relay {} -> {} (proxied) with {} bytes, error: {}",
-                self.peer_addr,
-                target_addr,
-                data.len(),
-                err
-            );
+        } else {
+            match self.dispatch_received_proxied_packet(target_addr, data).await {
+                Err(err) => {
+                    error!(
+                        "udp relay {} -> {} (proxied) with {} bytes, error: {}",
+                        self.peer_addr,
+                        target_addr,
+                        data.len(),
+                        err
+                    );
+                }
+                _ => {}
+            }
         }
     }
 
@@ -615,23 +620,26 @@ where
         self.keepalive_flag = true;
 
         // Send back to client
-        if let Err(err) = self.respond_writer.send_to(self.peer_addr, addr, data).await {
-            warn!(
-                "udp failed to send back {} bytes to client {}, from target {} ({}), error: {}",
-                data.len(),
-                self.peer_addr,
-                addr,
-                if bypassed { "bypassed" } else { "proxied" },
-                err
-            );
-        } else {
-            trace!(
-                "udp relay {} <- {} ({}) with {} bytes",
-                self.peer_addr,
-                addr,
-                if bypassed { "bypassed" } else { "proxied" },
-                data.len()
-            );
+        match self.respond_writer.send_to(self.peer_addr, addr, data).await {
+            Err(err) => {
+                warn!(
+                    "udp failed to send back {} bytes to client {}, from target {} ({}), error: {}",
+                    data.len(),
+                    self.peer_addr,
+                    addr,
+                    if bypassed { "bypassed" } else { "proxied" },
+                    err
+                );
+            }
+            Ok(..) => {
+                trace!(
+                    "udp relay {} <- {} ({}) with {} bytes",
+                    self.peer_addr,
+                    addr,
+                    if bypassed { "bypassed" } else { "proxied" },
+                    data.len()
+                );
+            }
         }
     }
 }