diff --git a/Cargo.lock b/Cargo.lock
index 15c13382..30decfa3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -698,6 +698,12 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.14"
@@ -1323,9 +1329,9 @@ dependencies = [
 
 [[package]]
 name = "h3"
-version = "0.0.6"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e7675a0963b47a6d12fe44c279918b4ffb19baee838ac37f48d2722ad5bc6ab"
+checksum = "7dfb059a4f28a66f186ed16ad912d142f490676acba59353831d7cb45a96b0d3"
 dependencies = [
  "bytes",
  "fastrand",
@@ -1337,9 +1343,9 @@ dependencies = [
 
 [[package]]
 name = "h3-quinn"
-version = "0.0.7"
+version = "0.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17c799f413fceeea505236c4d8132f084ff4b55a652288d91439ee93dc24d855"
+checksum = "6d482318ae94198fc8e3cbb0b7ba3099c865d744e6ec7c62039ca7b6b6c66fbf"
 dependencies = [
  "bytes",
  "futures",
@@ -1388,14 +1394,15 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hickory-proto"
-version = "0.25.0-alpha.5"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d00147af6310f4392a31680db52a3ed45a2e0f68eb18e8c3fe5537ecc96d9e2"
+checksum = "6d844af74f7b799e41c78221be863bade11c430d46042c3b49ca8ae0c6d27287"
 dependencies = [
  "async-recursion",
  "async-trait",
  "bytes",
  "cfg-if",
+ "critical-section",
  "data-encoding",
  "enum-as-inner",
  "futures-channel",
@@ -1411,6 +1418,7 @@ dependencies = [
  "pin-project-lite",
  "quinn",
  "rand 0.9.0",
+ "ring",
  "rustls",
  "serde",
  "thiserror 2.0.12",
@@ -1424,9 +1432,9 @@ dependencies = [
 
 [[package]]
 name = "hickory-resolver"
-version = "0.25.0-alpha.5"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5762f69ebdbd4ddb2e975cd24690bf21fe6b2604039189c26acddbc427f12887"
+checksum = "a128410b38d6f931fcc6ca5c107a3b02cabd6c05967841269a4ad65d23c44331"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -2320,6 +2328,10 @@ name = "once_cell"
 version = "1.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d75b0bedcc4fe52caa0e03d9f1151a323e4aa5e2d78ba3580400cd3c9e2bc4bc"
+dependencies = [
+ "critical-section",
+ "portable-atomic",
+]
 
 [[package]]
 name = "opaque-debug"
@@ -2663,11 +2675,12 @@ checksum = "d68782463e408eb1e668cf6152704bd856c78c5b6417adaee3203d8f4c1fc9ec"
 
 [[package]]
 name = "quinn"
-version = "0.11.6"
+version = "0.11.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62e96808277ec6f97351a2380e6c25114bc9e67037775464979f3037c92d05ef"
+checksum = "c3bd15a6f2967aef83887dcb9fec0014580467e33720d073560cf015a5683012"
 dependencies = [
  "bytes",
+ "cfg_aliases",
  "futures-io",
  "pin-project-lite",
  "quinn-proto",
@@ -2678,17 +2691,18 @@ dependencies = [
  "thiserror 2.0.12",
  "tokio",
  "tracing",
+ "web-time",
 ]
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.9"
+version = "0.11.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2fe5ef3495d7d2e377ff17b1a8ce2ee2ec2a18cde8b6ad6619d65d0701c135d"
+checksum = "b820744eb4dc9b57a3398183639c511b5a26d2ed702cedd3febaa1393caa22cc"
 dependencies = [
  "bytes",
- "getrandom 0.2.15",
- "rand 0.8.5",
+ "getrandom 0.3.1",
+ "rand 0.9.0",
  "ring",
  "rustc-hash 2.1.1",
  "rustls",
diff --git a/bin/ssurl.rs b/bin/ssurl.rs
index bdba3708..39c61879 100644
--- a/bin/ssurl.rs
+++ b/bin/ssurl.rs
@@ -6,7 +6,7 @@
 use std::process::ExitCode;
 
 use clap::{Arg, ArgAction, Command, ValueHint};
-use qrcode::{types::Color, QrCode};
+use qrcode::{QrCode, types::Color};
 
 use shadowsocks_service::{
     config::{Config, ConfigType, ServerInstanceConfig},
diff --git a/crates/shadowsocks-service/Cargo.toml b/crates/shadowsocks-service/Cargo.toml
index fa6d44e4..8cb207d1 100644
--- a/crates/shadowsocks-service/Cargo.toml
+++ b/crates/shadowsocks-service/Cargo.toml
@@ -42,15 +42,15 @@ hickory-dns = ["hickory-resolver", "shadowsocks/trust-dns"]
 trust-dns = ["hickory-dns"]
 dns-over-tls = [
     "hickory-dns",
-    "hickory-resolver/dns-over-rustls",
+    "hickory-resolver/tls-ring",
     "hickory-resolver/webpki-roots",
 ]
 dns-over-https = [
     "hickory-dns",
-    "hickory-resolver/dns-over-https-rustls",
+    "hickory-resolver/https-ring",
     "hickory-resolver/webpki-roots",
 ]
-dns-over-h3 = ["hickory-dns", "hickory-resolver/dns-over-h3"]
+dns-over-h3 = ["hickory-dns", "hickory-resolver/h3-ring"]
 
 # Enable DNS-relay
 local-dns = ["local", "hickory-dns"]
@@ -166,7 +166,7 @@ http-body-util = { version = "0.1", optional = true }
 http = { version = "1.1", optional = true }
 httparse = { version = "1.9", optional = true }
 
-hickory-resolver = { version = "=0.25.0-alpha.5", optional = true, features = [
+hickory-resolver = { version = "0.25", optional = true, features = [
     "serde",
 ] }
 
diff --git a/crates/shadowsocks-service/src/config.rs b/crates/shadowsocks-service/src/config.rs
index 1aae4278..1b3067e2 100644
--- a/crates/shadowsocks-service/src/config.rs
+++ b/crates/shadowsocks-service/src/config.rs
@@ -1893,7 +1893,9 @@ impl Config {
                         return Err(err);
                     }
                     None => {
-                        warn!("OnlineConfig \"version\" is missing in the configuration, assuming it is a compatible version for this project");
+                        warn!(
+                            "OnlineConfig \"version\" is missing in the configuration, assuming it is a compatible version for this project"
+                        );
                     }
                 }
             }
diff --git a/crates/shadowsocks-service/src/dns/mod.rs b/crates/shadowsocks-service/src/dns/mod.rs
index 32da44d2..048915f1 100644
--- a/crates/shadowsocks-service/src/dns/mod.rs
+++ b/crates/shadowsocks-service/src/dns/mod.rs
@@ -41,9 +41,9 @@ pub async fn build_dns_resolver(
                         Ok(r) => Some(r),
                         Err(err) => {
                             warn!(
-                            "initialize hickory-dns DNS system resolver failed, fallback to default system resolver, error: {}",
-                            err
-                        );
+                                "initialize hickory-dns DNS system resolver failed, fallback to default system resolver, error: {}",
+                                err
+                            );
                             None
                         }
                     };
diff --git a/crates/shadowsocks-service/src/local/dns/client_cache.rs b/crates/shadowsocks-service/src/local/dns/client_cache.rs
index 7d82fd55..481e9c72 100644
--- a/crates/shadowsocks-service/src/local/dns/client_cache.rs
+++ b/crates/shadowsocks-service/src/local/dns/client_cache.rs
@@ -3,14 +3,14 @@
 #[cfg(unix)]
 use std::path::Path;
 use std::{
-    collections::{hash_map::Entry, HashMap, VecDeque},
+    collections::{HashMap, VecDeque, hash_map::Entry},
     future::Future,
     io,
     net::SocketAddr,
     time::Duration,
 };
 
-use hickory_resolver::proto::{op::Message, ProtoError};
+use hickory_resolver::proto::{ProtoError, op::Message};
 use log::{debug, trace};
 use tokio::sync::Mutex;
 
diff --git a/crates/shadowsocks-service/src/local/dns/server.rs b/crates/shadowsocks-service/src/local/dns/server.rs
index 1b20a1a3..8b622a5e 100644
--- a/crates/shadowsocks-service/src/local/dns/server.rs
+++ b/crates/shadowsocks-service/src/local/dns/server.rs
@@ -15,11 +15,11 @@ use std::{
 use byteorder::{BigEndian, ByteOrder};
 use bytes::{BufMut, BytesMut};
 use futures::{
-    future::{self, Either},
     FutureExt,
+    future::{self, Either},
 };
 use hickory_resolver::proto::{
-    op::{header::MessageType, response_code::ResponseCode, Message, OpCode, Query},
+    op::{Message, OpCode, Query, header::MessageType, response_code::ResponseCode},
     rr::{DNSClass, Name, RData, RecordType},
 };
 use log::{debug, error, info, trace, warn};
@@ -30,10 +30,10 @@ use tokio::{
 };
 
 use shadowsocks::{
+    ServerAddr,
     config::Mode,
     net::TcpListener,
-    relay::{udprelay::MAXIMUM_UDP_PAYLOAD_SIZE, Address},
-    ServerAddr,
+    relay::{Address, udprelay::MAXIMUM_UDP_PAYLOAD_SIZE},
 };
 
 use crate::{
diff --git a/crates/shadowsocks-service/src/local/dns/upstream.rs b/crates/shadowsocks-service/src/local/dns/upstream.rs
index fa7a6c04..e069ab9e 100644
--- a/crates/shadowsocks-service/src/local/dns/upstream.rs
+++ b/crates/shadowsocks-service/src/local/dns/upstream.rs
@@ -12,7 +12,7 @@ use std::{
 
 use byteorder::{BigEndian, ByteOrder};
 use bytes::{BufMut, BytesMut};
-use hickory_resolver::proto::{op::Message, ProtoError, ProtoErrorKind};
+use hickory_resolver::proto::{ProtoError, ProtoErrorKind, op::Message};
 use log::{error, trace};
 use lru_time_cache::{Entry, LruCache};
 use shadowsocks::{
@@ -20,9 +20,9 @@ use shadowsocks::{
     context::SharedContext,
     net::{ConnectOpts, TcpStream as ShadowTcpStream, UdpSocket as ShadowUdpSocket},
     relay::{
-        tcprelay::ProxyClientStream,
-        udprelay::{options::UdpSocketControlData, ProxySocket},
         Address,
+        tcprelay::ProxyClientStream,
+        udprelay::{ProxySocket, options::UdpSocketControlData},
     },
 };
 #[cfg(unix)]
@@ -34,9 +34,9 @@ use tokio::{
 };
 
 use crate::{
-    local::net::udp::generate_client_session_id,
-    net::{packet_window::PacketWindowFilter, FlowStat, MonProxySocket, MonProxyStream},
     DEFAULT_UDP_EXPIRY_DURATION,
+    local::net::udp::generate_client_session_id,
+    net::{FlowStat, MonProxySocket, MonProxyStream, packet_window::PacketWindowFilter},
 };
 
 /// Collection of various DNS connections
@@ -231,8 +231,8 @@ impl DnsClient {
         #[cfg(windows)]
         fn check_peekable<F: std::os::windows::io::AsRawSocket>(s: &mut F) -> bool {
             use windows_sys::{
+                Win32::Networking::WinSock::{MSG_PEEK, SOCKET, recv},
                 core::PSTR,
-                Win32::Networking::WinSock::{recv, MSG_PEEK, SOCKET},
             };
 
             let sock = s.as_raw_socket() as SOCKET;
diff --git a/crates/shadowsocks-service/src/local/fake_dns/manager.rs b/crates/shadowsocks-service/src/local/fake_dns/manager.rs
index 7bad1367..9edd6560 100644
--- a/crates/shadowsocks-service/src/local/fake_dns/manager.rs
+++ b/crates/shadowsocks-service/src/local/fake_dns/manager.rs
@@ -75,9 +75,7 @@ macro_rules! map_domain_ip {
                                 db.put(&name2ip_key, nv)?;
                                 trace!(
                                     "fakedns mapping {} -> {}, expires {}",
-                                    $domain,
-                                    i,
-                                    domain_name_mapping.expire_time
+                                    $domain, i, domain_name_mapping.expire_time
                                 );
                                 return Ok((i, $self.expire_duration));
                             } else {
@@ -94,9 +92,7 @@ macro_rules! map_domain_ip {
                                         db.put(&ip2name_key, nv)?;
                                         trace!(
                                             "fakedns mapping {} -> {}, expires {}",
-                                            $domain,
-                                            i,
-                                            domain_name_mapping.expire_time
+                                            $domain, i, domain_name_mapping.expire_time
                                         );
                                         return Ok((i, $self.expire_duration));
                                     }
@@ -141,9 +137,7 @@ macro_rules! map_domain_ip {
                 db.put(&name2ip_key, nv)?;
                 trace!(
                     "fakedns mapping {} -> {}, expires {} created",
-                    $domain,
-                    ip,
-                    domain_name_mapping.expire_time
+                    $domain, ip, domain_name_mapping.expire_time
                 );
 
                 return Ok((ip, $self.expire_duration));
diff --git a/crates/shadowsocks-service/src/local/fake_dns/processor.rs b/crates/shadowsocks-service/src/local/fake_dns/processor.rs
index 5bcde7a9..cdc7d7d2 100644
--- a/crates/shadowsocks-service/src/local/fake_dns/processor.rs
+++ b/crates/shadowsocks-service/src/local/fake_dns/processor.rs
@@ -3,10 +3,10 @@
 use std::io;
 
 use hickory_resolver::proto::{
-    op::{header::MessageType, response_code::ResponseCode, Header, Message, OpCode},
+    op::{Header, Message, OpCode, header::MessageType, response_code::ResponseCode},
     rr::{
-        rdata::{A, AAAA},
         DNSClass, RData, Record, RecordType,
+        rdata::{A, AAAA},
     },
 };
 use log::{debug, trace, warn};
diff --git a/crates/shadowsocks-service/src/local/fake_dns/server.rs b/crates/shadowsocks-service/src/local/fake_dns/server.rs
index 0c739310..8086a3dc 100644
--- a/crates/shadowsocks-service/src/local/fake_dns/server.rs
+++ b/crates/shadowsocks-service/src/local/fake_dns/server.rs
@@ -8,7 +8,7 @@ use std::{
     time::Duration,
 };
 
-use futures::{future, FutureExt};
+use futures::{FutureExt, future};
 use ipnet::{Ipv4Net, Ipv6Net};
 use shadowsocks::config::{Mode, ServerAddr};
 
diff --git a/crates/shadowsocks-service/src/local/fake_dns/tcp_server.rs b/crates/shadowsocks-service/src/local/fake_dns/tcp_server.rs
index 6d440ae5..943f855f 100644
--- a/crates/shadowsocks-service/src/local/fake_dns/tcp_server.rs
+++ b/crates/shadowsocks-service/src/local/fake_dns/tcp_server.rs
@@ -10,11 +10,11 @@ use std::{
 use byteorder::{BigEndian, ByteOrder};
 use bytes::{BufMut, BytesMut};
 use hickory_resolver::proto::{
-    op::{response_code::ResponseCode, Message},
+    op::{Message, response_code::ResponseCode},
     serialize::binary::{BinEncodable, BinEncoder, EncodeMode},
 };
 use log::{error, trace};
-use shadowsocks::{lookup_then, net::TcpListener as ShadowTcpListener, ServerAddr};
+use shadowsocks::{ServerAddr, lookup_then, net::TcpListener as ShadowTcpListener};
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
     net::TcpStream,
diff --git a/crates/shadowsocks-service/src/local/fake_dns/udp_server.rs b/crates/shadowsocks-service/src/local/fake_dns/udp_server.rs
index 142a5548..d6ace3f3 100644
--- a/crates/shadowsocks-service/src/local/fake_dns/udp_server.rs
+++ b/crates/shadowsocks-service/src/local/fake_dns/udp_server.rs
@@ -2,9 +2,9 @@
 
 use std::{io, net::SocketAddr, sync::Arc, time::Duration};
 
-use hickory_resolver::proto::op::{response_code::ResponseCode, Message};
+use hickory_resolver::proto::op::{Message, response_code::ResponseCode};
 use log::error;
-use shadowsocks::{lookup_then, net::UdpSocket as ShadowUdpSocket, ServerAddr};
+use shadowsocks::{ServerAddr, lookup_then, net::UdpSocket as ShadowUdpSocket};
 use tokio::time;
 
 use crate::local::context::ServiceContext;
diff --git a/crates/shadowsocks-service/src/local/http/http_client.rs b/crates/shadowsocks-service/src/local/http/http_client.rs
index dc5945ac..70a6ac28 100644
--- a/crates/shadowsocks-service/src/local/http/http_client.rs
+++ b/crates/shadowsocks-service/src/local/http/http_client.rs
@@ -12,13 +12,13 @@ use std::{
     time::{Duration, Instant},
 };
 
-use http::{header::InvalidHeaderValue, HeaderValue, Method as HttpMethod, Uri, Version as HttpVersion};
+use http::{HeaderValue, Method as HttpMethod, Uri, Version as HttpVersion, header::InvalidHeaderValue};
 use hyper::{
+    Request, Response,
     body::{self, Body},
     client::conn::{http1, http2},
     http::uri::Scheme,
     rt::{Sleep, Timer},
-    Request, Response,
 };
 use log::{error, trace};
 use lru_time_cache::LruCache;
@@ -229,8 +229,7 @@ where
         if check_keep_alive(response.version(), response.headers(), false) {
             trace!(
                 "HTTP connection keep-alive for host: {}, response: {:?}",
-                host,
-                response
+                host, response
             );
             self.cache_conn
                 .lock()
@@ -284,8 +283,7 @@ where
     ) -> io::Result<HttpConnection<B>> {
         trace!(
             "HTTP making new HTTP/1.1 connection to host: {}, scheme: {}",
-            host,
-            scheme
+            host, scheme
         );
 
         let stream = ProxyHttpStream::connect_http(stream);
diff --git a/crates/shadowsocks-service/src/local/http/http_service.rs b/crates/shadowsocks-service/src/local/http/http_service.rs
index cba174fd..a048108f 100644
--- a/crates/shadowsocks-service/src/local/http/http_service.rs
+++ b/crates/shadowsocks-service/src/local/http/http_service.rs
@@ -3,12 +3,11 @@
 use std::{net::SocketAddr, str::FromStr, sync::Arc};
 
 use bytes::Bytes;
-use http_body_util::{combinators::BoxBody, BodyExt};
+use http_body_util::{BodyExt, combinators::BoxBody};
 use hyper::{
-    body,
+    HeaderMap, Method, Request, Response, StatusCode, Uri, Version, body,
     header::{self, HeaderValue},
     http::uri::{Authority, Scheme},
-    HeaderMap, Method, Request, Response, StatusCode, Uri, Version,
 };
 use log::{debug, error, trace};
 use shadowsocks::relay::Address;
diff --git a/crates/shadowsocks-service/src/local/http/http_stream.rs b/crates/shadowsocks-service/src/local/http/http_stream.rs
index c8875030..fa418bac 100644
--- a/crates/shadowsocks-service/src/local/http/http_stream.rs
+++ b/crates/shadowsocks-service/src/local/http/http_stream.rs
@@ -65,8 +65,8 @@ impl ProxyHttpStream {
         use rustls_native_certs::CertificateResult;
         use std::sync::Arc;
         use tokio_rustls::{
-            rustls::{pki_types::ServerName, ClientConfig, RootCertStore},
             TlsConnector,
+            rustls::{ClientConfig, RootCertStore, pki_types::ServerName},
         };
 
         static TLS_CONFIG: Lazy<Arc<ClientConfig>> = Lazy::new(|| {
diff --git a/crates/shadowsocks-service/src/local/http/utils.rs b/crates/shadowsocks-service/src/local/http/utils.rs
index 4abbd163..c7881eed 100644
--- a/crates/shadowsocks-service/src/local/http/utils.rs
+++ b/crates/shadowsocks-service/src/local/http/utils.rs
@@ -7,9 +7,9 @@ use std::{
 };
 
 use hyper::{
+    HeaderMap, Uri, Version,
     header::{self, HeaderValue},
     http::uri::Authority,
-    HeaderMap, Uri, Version,
 };
 use log::error;
 use shadowsocks::relay::socks5::Address;
diff --git a/crates/shadowsocks-service/src/local/loadbalancing/ping_balancer.rs b/crates/shadowsocks-service/src/local/loadbalancing/ping_balancer.rs
index 01c86c62..1d51e369 100644
--- a/crates/shadowsocks-service/src/local/loadbalancing/ping_balancer.rs
+++ b/crates/shadowsocks-service/src/local/loadbalancing/ping_balancer.rs
@@ -7,8 +7,8 @@ use std::{
     iter::Iterator,
     net::{Ipv4Addr, SocketAddr},
     sync::{
-        atomic::{AtomicUsize, Ordering},
         Arc,
+        atomic::{AtomicUsize, Ordering},
     },
     time::{Duration, Instant},
 };
@@ -18,14 +18,14 @@ use byte_string::ByteStr;
 use futures::future;
 use log::{debug, error, info, trace, warn};
 use shadowsocks::{
+    ServerConfig,
     config::{Mode, ServerSource},
     plugin::{Plugin, PluginMode},
     relay::{
         socks5::Address,
         tcprelay::proxy_stream::ProxyClientStream,
-        udprelay::{options::UdpSocketControlData, proxy_socket::ProxySocket, MAXIMUM_UDP_PAYLOAD_SIZE},
+        udprelay::{MAXIMUM_UDP_PAYLOAD_SIZE, options::UdpSocketControlData, proxy_socket::ProxySocket},
     },
-    ServerConfig,
 };
 use spin::Mutex as SpinMutex;
 use tokio::{
@@ -39,7 +39,7 @@ use crate::{config::ServerInstanceConfig, local::context::ServiceContext};
 
 use super::{
     server_data::ServerIdent,
-    server_stat::{Score, DEFAULT_CHECK_INTERVAL_SEC, DEFAULT_CHECK_TIMEOUT_SEC},
+    server_stat::{DEFAULT_CHECK_INTERVAL_SEC, DEFAULT_CHECK_TIMEOUT_SEC, Score},
 };
 
 const EXPECTED_CHECK_POINTS_IN_CHECK_WINDOW: u32 = 67;
diff --git a/crates/shadowsocks-service/src/local/loadbalancing/server_data.rs b/crates/shadowsocks-service/src/local/loadbalancing/server_data.rs
index bce11ce0..f9fa0362 100644
--- a/crates/shadowsocks-service/src/local/loadbalancing/server_data.rs
+++ b/crates/shadowsocks-service/src/local/loadbalancing/server_data.rs
@@ -4,13 +4,13 @@ use std::{
     fmt::{self, Debug},
     net::SocketAddr,
     sync::{
-        atomic::{AtomicU32, Ordering},
         Arc,
+        atomic::{AtomicU32, Ordering},
     },
     time::Duration,
 };
 
-use shadowsocks::{net::ConnectOpts, ServerConfig};
+use shadowsocks::{ServerConfig, net::ConnectOpts};
 use tokio::sync::Mutex;
 
 use crate::{config::ServerInstanceConfig, local::context::ServiceContext};
diff --git a/crates/shadowsocks-service/src/local/mod.rs b/crates/shadowsocks-service/src/local/mod.rs
index f891116e..ee6d4ea9 100644
--- a/crates/shadowsocks-service/src/local/mod.rs
+++ b/crates/shadowsocks-service/src/local/mod.rs
@@ -106,8 +106,12 @@ impl Server {
             let server = &inst.config;
 
             if server.method().is_stream() {
-                log::warn!("stream cipher {} for server {} have inherent weaknesses (see discussion in https://github.com/shadowsocks/shadowsocks-org/issues/36). \
-                    DO NOT USE. It will be removed in the future.", server.method(), server.addr());
+                log::warn!(
+                    "stream cipher {} for server {} have inherent weaknesses (see discussion in https://github.com/shadowsocks/shadowsocks-org/issues/36). \
+                    DO NOT USE. It will be removed in the future.",
+                    server.method(),
+                    server.addr()
+                );
             }
         }
 
diff --git a/crates/shadowsocks-service/src/local/net/udp/association.rs b/crates/shadowsocks-service/src/local/net/udp/association.rs
index 9229ba2d..ed0dd5d6 100644
--- a/crates/shadowsocks-service/src/local/net/udp/association.rs
+++ b/crates/shadowsocks-service/src/local/net/udp/association.rs
@@ -13,23 +13,23 @@ use bytes::Bytes;
 use futures::future;
 use log::{debug, error, trace, warn};
 use lru_time_cache::LruCache;
-use rand::{rngs::SmallRng, Rng, SeedableRng};
+use rand::{Rng, SeedableRng, rngs::SmallRng};
 use tokio::{sync::mpsc, task::JoinHandle, time};
 
 use shadowsocks::{
     lookup_then,
     net::{AddrFamily, UdpSocket as ShadowUdpSocket},
     relay::{
-        udprelay::{options::UdpSocketControlData, ProxySocket, MAXIMUM_UDP_PAYLOAD_SIZE},
         Address,
+        udprelay::{MAXIMUM_UDP_PAYLOAD_SIZE, ProxySocket, options::UdpSocketControlData},
     },
 };
 
 use crate::{
     local::{context::ServiceContext, loadbalancing::PingBalancer},
     net::{
-        packet_window::PacketWindowFilter, MonProxySocket, UDP_ASSOCIATION_KEEP_ALIVE_CHANNEL_SIZE,
-        UDP_ASSOCIATION_SEND_CHANNEL_SIZE,
+        MonProxySocket, UDP_ASSOCIATION_KEEP_ALIVE_CHANNEL_SIZE, UDP_ASSOCIATION_SEND_CHANNEL_SIZE,
+        packet_window::PacketWindowFilter,
     },
 };
 
diff --git a/crates/shadowsocks-service/src/local/net/udp/mod.rs b/crates/shadowsocks-service/src/local/net/udp/mod.rs
index ab64ecf6..41e387be 100644
--- a/crates/shadowsocks-service/src/local/net/udp/mod.rs
+++ b/crates/shadowsocks-service/src/local/net/udp/mod.rs
@@ -1,5 +1,5 @@
 #[allow(unused_imports)]
-pub use self::association::{generate_client_session_id, UdpAssociationManager, UdpInboundWrite};
+pub use self::association::{UdpAssociationManager, UdpInboundWrite, generate_client_session_id};
 
 pub mod association;
 pub mod listener;
diff --git a/crates/shadowsocks-service/src/local/online_config/mod.rs b/crates/shadowsocks-service/src/local/online_config/mod.rs
index 2ada278e..407e8f9e 100644
--- a/crates/shadowsocks-service/src/local/online_config/mod.rs
+++ b/crates/shadowsocks-service/src/local/online_config/mod.rs
@@ -19,7 +19,7 @@ use mime::Mime;
 use shadowsocks::config::ServerSource;
 use tokio::time;
 
-use self::content_encoding::{read_body, ContentEncoding};
+use self::content_encoding::{ContentEncoding, read_body};
 
 mod content_encoding;
 
@@ -214,7 +214,8 @@ impl OnlineConfigService {
 
         let finish_time = Instant::now();
 
-        debug!("server-loader task finished loading {} servers from url: {}, fetch time: {:?}, read time: {:?}, load time: {:?}, total time: {:?}",
+        debug!(
+            "server-loader task finished loading {} servers from url: {}, fetch time: {:?}, read time: {:?}, load time: {:?}, total time: {:?}",
             server_len,
             self.config_url,
             fetch_time - start_time,
diff --git a/crates/shadowsocks-service/src/local/redir/server.rs b/crates/shadowsocks-service/src/local/redir/server.rs
index b152a3de..bdac16e6 100644
--- a/crates/shadowsocks-service/src/local/redir/server.rs
+++ b/crates/shadowsocks-service/src/local/redir/server.rs
@@ -2,8 +2,8 @@
 
 use std::{io, sync::Arc, time::Duration};
 
-use futures::{future, FutureExt};
-use shadowsocks::{config::Mode, ServerAddr};
+use futures::{FutureExt, future};
+use shadowsocks::{ServerAddr, config::Mode};
 
 use crate::{
     config::RedirType,
diff --git a/crates/shadowsocks-service/src/local/redir/sys/unix/bsd_pf.rs b/crates/shadowsocks-service/src/local/redir/sys/unix/bsd_pf.rs
index b08ad3ac..49b7bc64 100644
--- a/crates/shadowsocks-service/src/local/redir/sys/unix/bsd_pf.rs
+++ b/crates/shadowsocks-service/src/local/redir/sys/unix/bsd_pf.rs
@@ -13,7 +13,7 @@ use nix::ioctl_readwrite;
 use once_cell::sync::Lazy;
 use socket2::{Protocol, SockAddr};
 
-use super::pfvar::{in6_addr, in_addr, pfioc_natlook, sockaddr_in, sockaddr_in6, PF_OUT};
+use super::pfvar::{PF_OUT, in_addr, in6_addr, pfioc_natlook, sockaddr_in, sockaddr_in6};
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 use super::pfvar::{pf_addr, pfioc_states, pfsync_state};
 
diff --git a/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_freebsd.rs b/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_freebsd.rs
index 8373868e..9e086516 100644
--- a/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_freebsd.rs
+++ b/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_freebsd.rs
@@ -3524,7 +3524,7 @@ unsafe extern "C" {
 }
 unsafe extern "C" {
     pub fn cpuset_getid(arg1: cpulevel_t, arg2: cpuwhich_t, arg3: id_t, arg4: *mut cpusetid_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn cpuset_getaffinity(
@@ -6739,7 +6739,7 @@ unsafe extern "C" {
 }
 unsafe extern "C" {
     pub fn clock_getcpuclockid2(arg1: id_t, arg2: ::std::os::raw::c_int, arg3: *mut clockid_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn futimes(arg1: ::std::os::raw::c_int, arg2: *const timeval) -> ::std::os::raw::c_int;
@@ -7562,11 +7562,11 @@ unsafe extern "C" {
 }
 unsafe extern "C" {
     pub fn getpeername(arg1: ::std::os::raw::c_int, arg2: *mut sockaddr, arg3: *mut socklen_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn getsockname(arg1: ::std::os::raw::c_int, arg2: *mut sockaddr, arg3: *mut socklen_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn getsockopt(
@@ -7644,7 +7644,7 @@ unsafe extern "C" {
 }
 unsafe extern "C" {
     pub fn sendmmsg(arg1: ::std::os::raw::c_int, arg2: *mut mmsghdr, arg3: usize, arg4: ::std::os::raw::c_int)
-        -> isize;
+    -> isize;
 }
 unsafe extern "C" {
     pub fn setfib(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
diff --git a/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_macos.rs b/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_macos.rs
index 60f8dedd..79c79a26 100644
--- a/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_macos.rs
+++ b/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_macos.rs
@@ -10859,12 +10859,12 @@ unsafe extern "C" {
 unsafe extern "C" {
     #[link_name = "\u{1}_getpeername$UNIX2003"]
     pub fn getpeername(arg1: ::std::os::raw::c_int, arg2: *mut sockaddr, arg3: *mut socklen_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     #[link_name = "\u{1}_getsockname$UNIX2003"]
     pub fn getsockname(arg1: ::std::os::raw::c_int, arg2: *mut sockaddr, arg3: *mut socklen_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn getsockopt(
diff --git a/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_openbsd.rs b/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_openbsd.rs
index 60b84fe7..087d5a41 100644
--- a/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_openbsd.rs
+++ b/crates/shadowsocks-service/src/local/redir/sys/unix/pfvar_bindgen_openbsd.rs
@@ -1134,7 +1134,7 @@ pub const uio_seg_UIO_SYSSPACE: uio_seg = 1;
 pub type uio_seg = ::std::os::raw::c_uint;
 unsafe extern "C" {
     pub fn preadv(arg1: ::std::os::raw::c_int, arg2: *const iovec, arg3: ::std::os::raw::c_int, arg4: __off_t)
-        -> isize;
+    -> isize;
 }
 unsafe extern "C" {
     pub fn pwritev(
@@ -1599,11 +1599,11 @@ unsafe extern "C" {
 }
 unsafe extern "C" {
     pub fn getpeername(arg1: ::std::os::raw::c_int, arg2: *mut sockaddr, arg3: *mut socklen_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn getsockname(arg1: ::std::os::raw::c_int, arg2: *mut sockaddr, arg3: *mut socklen_t)
-        -> ::std::os::raw::c_int;
+    -> ::std::os::raw::c_int;
 }
 unsafe extern "C" {
     pub fn getsockopt(
diff --git a/crates/shadowsocks-service/src/local/redir/tcprelay/mod.rs b/crates/shadowsocks-service/src/local/redir/tcprelay/mod.rs
index 066ffe71..b42c919d 100644
--- a/crates/shadowsocks-service/src/local/redir/tcprelay/mod.rs
+++ b/crates/shadowsocks-service/src/local/redir/tcprelay/mod.rs
@@ -8,7 +8,7 @@ use std::{
 };
 
 use log::{debug, error, info, trace};
-use shadowsocks::{lookup_then, net::TcpListener as ShadowTcpListener, relay::socks5::Address, ServerAddr};
+use shadowsocks::{ServerAddr, lookup_then, net::TcpListener as ShadowTcpListener, relay::socks5::Address};
 use tokio::{
     net::{TcpListener, TcpStream},
     time,
diff --git a/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/bsd.rs b/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/bsd.rs
index ec4cdd06..3eb731cc 100644
--- a/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/bsd.rs
+++ b/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/bsd.rs
@@ -4,7 +4,7 @@ use std::{
 };
 
 use log::warn;
-use shadowsocks::net::{is_dual_stack_addr, set_tcp_fastopen, AcceptOpts};
+use shadowsocks::net::{AcceptOpts, is_dual_stack_addr, set_tcp_fastopen};
 use socket2::Protocol;
 use tokio::net::{TcpListener, TcpSocket, TcpStream};
 
diff --git a/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/linux.rs b/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/linux.rs
index dc12a339..3fa008d7 100644
--- a/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/linux.rs
+++ b/crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/linux.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use log::warn;
-use shadowsocks::net::{is_dual_stack_addr, set_tcp_fastopen, AcceptOpts};
+use shadowsocks::net::{AcceptOpts, is_dual_stack_addr, set_tcp_fastopen};
 use socket2::SockAddr;
 use tokio::net::{TcpListener, TcpSocket, TcpStream};
 
diff --git a/crates/shadowsocks-service/src/local/redir/udprelay/mod.rs b/crates/shadowsocks-service/src/local/redir/udprelay/mod.rs
index 5d6b12b7..7a62658b 100644
--- a/crates/shadowsocks-service/src/local/redir/udprelay/mod.rs
+++ b/crates/shadowsocks-service/src/local/redir/udprelay/mod.rs
@@ -10,10 +10,9 @@ use std::{
 use log::{debug, error, info, trace, warn};
 use lru_time_cache::LruCache;
 use shadowsocks::{
-    lookup_then,
-    net::{get_ip_stack_capabilities, ConnectOpts},
+    ServerAddr, lookup_then,
+    net::{ConnectOpts, get_ip_stack_capabilities},
     relay::{socks5::Address, udprelay::MAXIMUM_UDP_PAYLOAD_SIZE},
-    ServerAddr,
 };
 use tokio::{sync::Mutex, task::JoinHandle, time};
 
@@ -186,10 +185,7 @@ impl UdpInboundWrite for UdpRedirInboundWriter {
 
                 trace!(
                     "udp redir send back data {} bytes, remote: {}, peer: {}, socket_opts: {:?}",
-                    n,
-                    remote_addr,
-                    peer_addr,
-                    self.socket_opts
+                    n, remote_addr, peer_addr, self.socket_opts
                 );
 
                 Ok(())
diff --git a/crates/shadowsocks-service/src/local/socks/server/mod.rs b/crates/shadowsocks-service/src/local/socks/server/mod.rs
index fa666344..0e060a3b 100644
--- a/crates/shadowsocks-service/src/local/socks/server/mod.rs
+++ b/crates/shadowsocks-service/src/local/socks/server/mod.rs
@@ -2,8 +2,8 @@
 
 use std::{io, sync::Arc, time::Duration};
 
-use futures::{future, FutureExt};
-use shadowsocks::{config::Mode, ServerAddr};
+use futures::{FutureExt, future};
+use shadowsocks::{ServerAddr, config::Mode};
 
 use crate::local::{context::ServiceContext, loadbalancing::PingBalancer};
 
diff --git a/crates/shadowsocks-service/src/local/socks/server/server.rs b/crates/shadowsocks-service/src/local/socks/server/server.rs
index 36db2901..7ee47dbf 100644
--- a/crates/shadowsocks-service/src/local/socks/server/server.rs
+++ b/crates/shadowsocks-service/src/local/socks/server/server.rs
@@ -1,7 +1,7 @@
 use std::{io, net::SocketAddr, sync::Arc, time::Duration};
 
 use log::{error, info};
-use shadowsocks::{config::Mode, net::TcpListener as ShadowTcpListener, ServerAddr};
+use shadowsocks::{ServerAddr, config::Mode, net::TcpListener as ShadowTcpListener};
 use tokio::{net::TcpStream, time};
 
 #[cfg(feature = "local-http")]
diff --git a/crates/shadowsocks-service/src/local/socks/server/socks5/tcprelay.rs b/crates/shadowsocks-service/src/local/socks/server/socks5/tcprelay.rs
index 01220802..f4c61c8c 100644
--- a/crates/shadowsocks-service/src/local/socks/server/socks5/tcprelay.rs
+++ b/crates/shadowsocks-service/src/local/socks/server/socks5/tcprelay.rs
@@ -9,12 +9,12 @@ use std::{
 
 use log::{debug, error, trace, warn};
 use shadowsocks::{
+    ServerAddr,
     config::Mode,
     relay::socks5::{
         self, Address, Command, Error as Socks5Error, HandshakeRequest, HandshakeResponse, PasswdAuthRequest,
         PasswdAuthResponse, Reply, TcpRequestHeader, TcpResponseHeader,
     },
-    ServerAddr,
 };
 use tokio::net::TcpStream;
 
@@ -145,8 +145,7 @@ impl Socks5TcpHandler {
         if self.auth.passwd.check_user(user_name, password) {
             trace!(
                 "socks5 authenticated with Username/Password method, user: {}, password: {}",
-                user_name,
-                password
+                user_name, password
             );
 
             let rsp = PasswdAuthResponse::new(0);
diff --git a/crates/shadowsocks-service/src/local/socks/server/socks5/udprelay.rs b/crates/shadowsocks-service/src/local/socks/server/socks5/udprelay.rs
index 5f9578cd..54e52346 100644
--- a/crates/shadowsocks-service/src/local/socks/server/socks5/udprelay.rs
+++ b/crates/shadowsocks-service/src/local/socks/server/socks5/udprelay.rs
@@ -11,11 +11,11 @@ use byte_string::ByteStr;
 use bytes::{BufMut, BytesMut};
 use log::{debug, error, info, trace};
 use shadowsocks::{
+    ServerAddr,
     relay::{
         socks5::{Address, UdpAssociateHeader},
         udprelay::MAXIMUM_UDP_PAYLOAD_SIZE,
     },
-    ServerAddr,
 };
 use tokio::{net::UdpSocket, time};
 
@@ -23,7 +23,7 @@ use crate::{
     local::{
         context::ServiceContext,
         loadbalancing::PingBalancer,
-        net::{udp::listener::create_standard_udp_listener, UdpAssociationManager, UdpInboundWrite},
+        net::{UdpAssociationManager, UdpInboundWrite, udp::listener::create_standard_udp_listener},
     },
     net::utils::to_ipv4_mapped,
 };
diff --git a/crates/shadowsocks-service/src/local/tun/mod.rs b/crates/shadowsocks-service/src/local/tun/mod.rs
index 03536e78..e10ea913 100644
--- a/crates/shadowsocks-service/src/local/tun/mod.rs
+++ b/crates/shadowsocks-service/src/local/tun/mod.rs
@@ -186,9 +186,7 @@ impl Tun {
 
         trace!(
             "[TUN] tun device network: {} (address: {}, netmask: {})",
-            address_net,
-            address,
-            netmask
+            address_net, address, netmask
         );
 
         let address_broadcast = address_net.broadcast();
@@ -283,10 +281,7 @@ impl Tun {
         if src_non_unicast || dst_non_unicast {
             trace!(
                 "[TUN] IP packet {} (unicast? {}) -> {} (unicast? {}) throwing away",
-                src_ip_addr,
-                !src_non_unicast,
-                dst_ip_addr,
-                !dst_non_unicast
+                src_ip_addr, !src_non_unicast, dst_ip_addr, !dst_non_unicast
             );
             return Ok(());
         }
@@ -320,11 +315,7 @@ impl Tun {
 
                 trace!(
                     "[TUN] TCP packet {} (unicast? {}) -> {} (unicast? {}) {}",
-                    src_addr,
-                    !src_non_unicast,
-                    dst_addr,
-                    !dst_non_unicast,
-                    tcp_packet
+                    src_addr, !src_non_unicast, dst_addr, !dst_non_unicast, tcp_packet
                 );
 
                 // TCP first handshake packet.
@@ -366,11 +357,7 @@ impl Tun {
                 let payload = udp_packet.payload();
                 trace!(
                     "[TUN] UDP packet {} (unicast? {}) -> {} (unicast? {}) {}",
-                    src_addr,
-                    !src_non_unicast,
-                    dst_addr,
-                    !dst_non_unicast,
-                    udp_packet
+                    src_addr, !src_non_unicast, dst_addr, !dst_non_unicast, udp_packet
                 );
 
                 if let Err(err) = self.udp.handle_packet(src_addr, dst_addr, payload).await {
diff --git a/crates/shadowsocks-service/src/local/tun/tcp.rs b/crates/shadowsocks-service/src/local/tun/tcp.rs
index 988ce654..d5d0f0f5 100644
--- a/crates/shadowsocks-service/src/local/tun/tcp.rs
+++ b/crates/shadowsocks-service/src/local/tun/tcp.rs
@@ -6,8 +6,8 @@ use std::{
     net::{IpAddr, SocketAddr},
     pin::Pin,
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
     task::{Context, Poll, Waker},
     thread::{self, JoinHandle, Thread},
diff --git a/crates/shadowsocks-service/src/local/tun/virt_device.rs b/crates/shadowsocks-service/src/local/tun/virt_device.rs
index 5bcb46d6..6fdc797d 100644
--- a/crates/shadowsocks-service/src/local/tun/virt_device.rs
+++ b/crates/shadowsocks-service/src/local/tun/virt_device.rs
@@ -3,8 +3,8 @@
 use std::{
     marker::PhantomData,
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
 };
 
diff --git a/crates/shadowsocks-service/src/local/tunnel/server.rs b/crates/shadowsocks-service/src/local/tunnel/server.rs
index a20487b8..4b853ef9 100644
--- a/crates/shadowsocks-service/src/local/tunnel/server.rs
+++ b/crates/shadowsocks-service/src/local/tunnel/server.rs
@@ -2,8 +2,8 @@
 
 use std::{io, sync::Arc, time::Duration};
 
-use futures::{future, FutureExt};
-use shadowsocks::{config::Mode, relay::socks5::Address, ServerAddr};
+use futures::{FutureExt, future};
+use shadowsocks::{ServerAddr, config::Mode, relay::socks5::Address};
 
 use crate::local::{context::ServiceContext, loadbalancing::PingBalancer};
 
diff --git a/crates/shadowsocks-service/src/local/tunnel/tcprelay.rs b/crates/shadowsocks-service/src/local/tunnel/tcprelay.rs
index a25f4727..59f5d435 100644
--- a/crates/shadowsocks-service/src/local/tunnel/tcprelay.rs
+++ b/crates/shadowsocks-service/src/local/tunnel/tcprelay.rs
@@ -3,13 +3,13 @@
 use std::{io, net::SocketAddr, sync::Arc, time::Duration};
 
 use log::{error, info, trace};
-use shadowsocks::{net::TcpListener as ShadowTcpListener, relay::socks5::Address, ServerAddr};
+use shadowsocks::{ServerAddr, net::TcpListener as ShadowTcpListener, relay::socks5::Address};
 use tokio::{net::TcpStream, time};
 
 use crate::local::{
     context::ServiceContext,
     loadbalancing::PingBalancer,
-    net::{tcp::listener::create_standard_tcp_listener, AutoProxyClientStream},
+    net::{AutoProxyClientStream, tcp::listener::create_standard_tcp_listener},
     utils::{establish_tcp_tunnel, establish_tcp_tunnel_bypassed},
 };
 
diff --git a/crates/shadowsocks-service/src/local/tunnel/udprelay.rs b/crates/shadowsocks-service/src/local/tunnel/udprelay.rs
index 5062a46f..e9ced6dd 100644
--- a/crates/shadowsocks-service/src/local/tunnel/udprelay.rs
+++ b/crates/shadowsocks-service/src/local/tunnel/udprelay.rs
@@ -4,15 +4,15 @@ use std::{io, net::SocketAddr, sync::Arc, time::Duration};
 
 use log::{debug, error, info};
 use shadowsocks::{
-    relay::{socks5::Address, udprelay::MAXIMUM_UDP_PAYLOAD_SIZE},
     ServerAddr,
+    relay::{socks5::Address, udprelay::MAXIMUM_UDP_PAYLOAD_SIZE},
 };
 use tokio::{net::UdpSocket, time};
 
 use crate::local::{
     context::ServiceContext,
     loadbalancing::PingBalancer,
-    net::{udp::listener::create_standard_udp_listener, UdpAssociationManager, UdpInboundWrite},
+    net::{UdpAssociationManager, UdpInboundWrite, udp::listener::create_standard_udp_listener},
 };
 
 pub struct TunnelUdpServerBuilder {
diff --git a/crates/shadowsocks-service/src/local/utils.rs b/crates/shadowsocks-service/src/local/utils.rs
index 9d6532f5..10f5ad81 100644
--- a/crates/shadowsocks-service/src/local/utils.rs
+++ b/crates/shadowsocks-service/src/local/utils.rs
@@ -8,7 +8,7 @@ use shadowsocks::{
     relay::{socks5::Address, tcprelay::utils::copy_encrypted_bidirectional},
 };
 use tokio::{
-    io::{copy_bidirectional, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
+    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, copy_bidirectional},
     time,
 };
 
@@ -60,8 +60,7 @@ where
 
                 trace!(
                     "tcp tunnel {} -> {} (proxied) sent handshake without data",
-                    peer_addr,
-                    target_addr
+                    peer_addr, target_addr
                 );
             }
         }
@@ -71,18 +70,13 @@ where
         Ok((wn, rn)) => {
             trace!(
                 "tcp tunnel {} <-> {} (proxied) closed, L2R {} bytes, R2L {} bytes",
-                peer_addr,
-                target_addr,
-                rn,
-                wn
+                peer_addr, target_addr, rn, wn
             );
         }
         Err(err) => {
             trace!(
                 "tcp tunnel {} <-> {} (proxied) closed with error: {}",
-                peer_addr,
-                target_addr,
-                err
+                peer_addr, target_addr, err
             );
         }
     }
@@ -106,18 +100,13 @@ where
         Ok((rn, wn)) => {
             trace!(
                 "tcp tunnel {} <-> {} (bypassed) closed, L2R {} bytes, R2L {} bytes",
-                peer_addr,
-                target_addr,
-                rn,
-                wn
+                peer_addr, target_addr, rn, wn
             );
         }
         Err(err) => {
             trace!(
                 "tcp tunnel {} <-> {} (bypassed) closed with error: {}",
-                peer_addr,
-                target_addr,
-                err
+                peer_addr, target_addr, err
             );
         }
     }
diff --git a/crates/shadowsocks-service/src/manager/server.rs b/crates/shadowsocks-service/src/manager/server.rs
index 06557f5a..48d3966f 100644
--- a/crates/shadowsocks-service/src/manager/server.rs
+++ b/crates/shadowsocks-service/src/manager/server.rs
@@ -6,6 +6,7 @@ use std::{collections::HashMap, io, net::SocketAddr, sync::Arc, time::Duration};
 
 use log::{error, info, trace};
 use shadowsocks::{
+    ManagerListener, ServerAddr,
     config::{Mode, ServerConfig, ServerType, ServerUser, ServerUserManager},
     context::{Context, SharedContext},
     crypto::CipherKind,
@@ -19,7 +20,6 @@ use shadowsocks::{
     },
     net::{AcceptOpts, ConnectOpts},
     plugin::PluginConfig,
-    ManagerListener, ServerAddr,
 };
 use tokio::{sync::Mutex, task::JoinHandle};
 
diff --git a/crates/shadowsocks-service/src/net/mon_socket.rs b/crates/shadowsocks-service/src/net/mon_socket.rs
index 3ba055a4..28553a78 100644
--- a/crates/shadowsocks-service/src/net/mon_socket.rs
+++ b/crates/shadowsocks-service/src/net/mon_socket.rs
@@ -3,11 +3,11 @@
 use std::{io, net::SocketAddr, sync::Arc};
 
 use shadowsocks::{
+    ProxySocket,
     relay::{
         socks5::Address,
-        udprelay::{options::UdpSocketControlData, DatagramReceive, DatagramSend},
+        udprelay::{DatagramReceive, DatagramSend, options::UdpSocketControlData},
     },
-    ProxySocket,
 };
 
 use super::flow::FlowStat;
diff --git a/crates/shadowsocks-service/src/server/mod.rs b/crates/shadowsocks-service/src/server/mod.rs
index 06c54aea..ec31af42 100644
--- a/crates/shadowsocks-service/src/server/mod.rs
+++ b/crates/shadowsocks-service/src/server/mod.rs
@@ -42,8 +42,12 @@ pub async fn run(config: Config) -> io::Result<()> {
         let server = &inst.config;
 
         if server.method().is_stream() {
-            log::warn!("stream cipher {} for server {} have inherent weaknesses (see discussion in https://github.com/shadowsocks/shadowsocks-org/issues/36). \
-                    DO NOT USE. It will be removed in the future.", server.method(), server.addr());
+            log::warn!(
+                "stream cipher {} for server {} have inherent weaknesses (see discussion in https://github.com/shadowsocks/shadowsocks-org/issues/36). \
+                    DO NOT USE. It will be removed in the future.",
+                server.method(),
+                server.addr()
+            );
         }
     }
 
diff --git a/crates/shadowsocks-service/src/server/server.rs b/crates/shadowsocks-service/src/server/server.rs
index e57db1dd..5d93127e 100644
--- a/crates/shadowsocks-service/src/server/server.rs
+++ b/crates/shadowsocks-service/src/server/server.rs
@@ -10,11 +10,11 @@ use std::{
 use futures::future;
 use log::{error, trace};
 use shadowsocks::{
+    ManagerClient,
     config::{ManagerAddr, ServerConfig},
     dns_resolver::DnsResolver,
     net::{AcceptOpts, ConnectOpts},
     plugin::{Plugin, PluginMode},
-    ManagerClient,
 };
 use tokio::time;
 
diff --git a/crates/shadowsocks-service/src/server/tcprelay.rs b/crates/shadowsocks-service/src/server/tcprelay.rs
index 544ba94a..8f01a678 100644
--- a/crates/shadowsocks-service/src/server/tcprelay.rs
+++ b/crates/shadowsocks-service/src/server/tcprelay.rs
@@ -10,10 +10,10 @@ use std::{
 
 use log::{debug, error, info, trace, warn};
 use shadowsocks::{
+    ProxyListener, ServerConfig,
     crypto::CipherKind,
     net::{AcceptOpts, TcpStream as OutboundTcpStream},
-    relay::tcprelay::{utils::copy_encrypted_bidirectional, ProxyServerStream},
-    ProxyListener, ServerConfig,
+    relay::tcprelay::{ProxyServerStream, utils::copy_encrypted_bidirectional},
 };
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
@@ -21,7 +21,7 @@ use tokio::{
     time,
 };
 
-use crate::net::{utils::ignore_until_end, MonProxyStream};
+use crate::net::{MonProxyStream, utils::ignore_until_end};
 
 use super::context::ServiceContext;
 
@@ -179,8 +179,7 @@ impl TcpServerClient {
 
                 trace!(
                     "tcp silent-drop peer: {} is now closing with result {:?}",
-                    self.peer_addr,
-                    res
+                    self.peer_addr, res
                 );
 
                 return Ok(());
@@ -189,8 +188,7 @@ impl TcpServerClient {
 
         trace!(
             "accepted tcp client connection {}, establishing tunnel to {}",
-            self.peer_addr,
-            target_addr
+            self.peer_addr, target_addr
         );
 
         if self.context.check_outbound_blocked(&target_addr).await {
@@ -244,8 +242,7 @@ impl TcpServerClient {
 
                     trace!(
                         "tcp tunnel {} -> {} sent TFO connect without data",
-                        self.peer_addr,
-                        target_addr
+                        self.peer_addr, target_addr
                     );
                 }
             }
@@ -262,18 +259,13 @@ impl TcpServerClient {
             Ok((rn, wn)) => {
                 trace!(
                     "tcp tunnel {} <-> {} closed, L2R {} bytes, R2L {} bytes",
-                    self.peer_addr,
-                    target_addr,
-                    rn,
-                    wn
+                    self.peer_addr, target_addr, rn, wn
                 );
             }
             Err(err) => {
                 trace!(
                     "tcp tunnel {} <-> {} closed with error: {}",
-                    self.peer_addr,
-                    target_addr,
-                    err
+                    self.peer_addr, target_addr, err
                 );
             }
         }
diff --git a/crates/shadowsocks-service/src/server/udprelay.rs b/crates/shadowsocks-service/src/server/udprelay.rs
index 2a6e0178..d673b2f9 100644
--- a/crates/shadowsocks-service/src/server/udprelay.rs
+++ b/crates/shadowsocks-service/src/server/udprelay.rs
@@ -12,26 +12,26 @@ use bytes::Bytes;
 use futures::future;
 use log::{debug, error, info, trace, warn};
 use lru_time_cache::LruCache;
-use rand::{rngs::SmallRng, Rng, SeedableRng};
+use rand::{Rng, SeedableRng, rngs::SmallRng};
 use shadowsocks::{
+    ServerConfig,
     config::ServerUser,
     crypto::CipherCategory,
     lookup_then,
     net::{
-        get_ip_stack_capabilities, AcceptOpts, AddrFamily, UdpSocket as OutboundUdpSocket,
-        UdpSocket as InboundUdpSocket,
+        AcceptOpts, AddrFamily, UdpSocket as OutboundUdpSocket, UdpSocket as InboundUdpSocket,
+        get_ip_stack_capabilities,
     },
     relay::{
         socks5::Address,
-        udprelay::{options::UdpSocketControlData, ProxySocket, MAXIMUM_UDP_PAYLOAD_SIZE},
+        udprelay::{MAXIMUM_UDP_PAYLOAD_SIZE, ProxySocket, options::UdpSocketControlData},
     },
-    ServerConfig,
 };
 use tokio::{runtime::Handle, sync::mpsc, task::JoinHandle, time};
 
 use crate::net::{
-    packet_window::PacketWindowFilter, utils::to_ipv4_mapped, MonProxySocket, UDP_ASSOCIATION_KEEP_ALIVE_CHANNEL_SIZE,
-    UDP_ASSOCIATION_SEND_CHANNEL_SIZE,
+    MonProxySocket, UDP_ASSOCIATION_KEEP_ALIVE_CHANNEL_SIZE, UDP_ASSOCIATION_SEND_CHANNEL_SIZE,
+    packet_window::PacketWindowFilter, utils::to_ipv4_mapped,
 };
 
 use super::context::ServiceContext;
diff --git a/crates/shadowsocks/Cargo.toml b/crates/shadowsocks/Cargo.toml
index dcc237ea..e6ed8466 100644
--- a/crates/shadowsocks/Cargo.toml
+++ b/crates/shadowsocks/Cargo.toml
@@ -86,7 +86,7 @@ tokio = { version = "1.9.0", features = [
     "time",
 ] }
 
-hickory-resolver = { version = "=0.25.0-alpha.5", optional = true }
+hickory-resolver = { version = "0.25", optional = true }
 arc-swap = { version = "1.7", optional = true }
 notify = { version = "8.0", optional = true }
 
diff --git a/crates/shadowsocks/src/config.rs b/crates/shadowsocks/src/config.rs
index 5cf53089..8f21c2ee 100644
--- a/crates/shadowsocks/src/config.rs
+++ b/crates/shadowsocks/src/config.rs
@@ -500,7 +500,10 @@ where
             debug_assert_eq!(method.key_len(), 0);
 
             if !password.is_empty() {
-                warn!("method \"none\" doesn't need a password, which should be set as an empty String, but password.len() = {}", password.len());
+                warn!(
+                    "method \"none\" doesn't need a password, which should be set as an empty String, but password.len() = {}",
+                    password.len()
+                );
             }
 
             return Ok((password, Vec::new().into_boxed_slice(), Vec::new()));
diff --git a/crates/shadowsocks/src/dns_resolver/hickory_dns_resolver.rs b/crates/shadowsocks/src/dns_resolver/hickory_dns_resolver.rs
index d7062574..6755cbd2 100644
--- a/crates/shadowsocks/src/dns_resolver/hickory_dns_resolver.rs
+++ b/crates/shadowsocks/src/dns_resolver/hickory_dns_resolver.rs
@@ -13,18 +13,18 @@ use std::{
 use cfg_if::cfg_if;
 use futures::ready;
 use hickory_resolver::{
+    ResolveError, Resolver,
     config::{LookupIpStrategy, ResolverConfig, ResolverOpts},
     name_server::GenericConnector,
     proto::{
-        runtime::{iocompat::AsyncIoTokioAsStd, RuntimeProvider, TokioHandle, TokioTime},
+        runtime::{RuntimeProvider, TokioHandle, TokioTime, iocompat::AsyncIoTokioAsStd},
         udp::DnsUdpSocket,
     },
-    ResolveError, Resolver,
 };
-use log::trace;
+use log::{error, trace};
 use tokio::{io::ReadBuf, net::UdpSocket};
 
-use crate::net::{tcp::TcpStream as ShadowTcpStream, udp::UdpSocket as ShadowUdpSocket, ConnectOpts};
+use crate::net::{ConnectOpts, tcp::TcpStream as ShadowTcpStream, udp::UdpSocket as ShadowUdpSocket};
 
 /// Shadowsocks hickory-dns Runtime Provider
 #[derive(Clone)]
@@ -130,7 +130,17 @@ pub async fn create_resolver(
     // Customized dns resolution
     match dns {
         Some(conf) => {
-            let mut resolver_opts = opts.unwrap_or_default();
+            trace!("initializing DNS resolver with config {:?}", conf,);
+
+            let mut builder = DnsResolver::builder_with_config(
+                conf,
+                ShadowDnsConnectionProvider::new(ShadowDnsRuntimeProvider::new(connect_opts)),
+            );
+            if let Some(opts) = opts {
+                *builder.options_mut() = opts;
+            }
+            let resolver_opts = builder.options_mut();
+
             // Use Ipv4AndIpv6 strategy. Because Ipv4ThenIpv6 or Ipv6ThenIpv4 will return if the first query returned.
             // Since we want to use Happy Eyeballs to connect to both IPv4 and IPv6 addresses, we need both A and AAAA records.
             resolver_opts.ip_strategy = LookupIpStrategy::Ipv4AndIpv6;
@@ -138,39 +148,19 @@ pub async fn create_resolver(
             // Enable EDNS0 for large records
             resolver_opts.edns0 = true;
 
-            trace!(
-                "initializing DNS resolver with config {:?} opts {:?}",
-                conf,
-                resolver_opts
-            );
-            Ok(DnsResolver::new(
-                conf,
-                resolver_opts,
-                ShadowDnsConnectionProvider::new(ShadowDnsRuntimeProvider::new(connect_opts)),
-            ))
+            trace!("initializing DNS resolver with opts {:?}", resolver_opts);
+
+            Ok(builder.build())
         }
 
         // To make this independent, if targeting macOS, BSD, Linux, or Windows, we can use the system's configuration
         // Android doesn't have /etc/resolv.conf.
         None => {
-            cfg_if! {
-                if #[cfg(any(all(unix, not(target_os = "android")), windows))] {
-                    use hickory_resolver::system_conf::read_system_conf;
-
-                    // use the system resolver configuration
-                    let (config, mut opts) = match read_system_conf() {
-                        Ok(o) => o,
-                        Err(err) => {
-                            use log::error;
-
-                            error!("failed to initialize DNS resolver with system-config, error: {}", err);
-
-                            // From::from is required because on error type is different on Windows
-                            #[allow(clippy::useless_conversion)]
-                            return Err(From::from(err));
-                        }
-                    };
-
+            match DnsResolver::builder(ShadowDnsConnectionProvider::new(ShadowDnsRuntimeProvider::new(
+                connect_opts,
+            ))) {
+                Ok(mut builder) => {
+                    let opts = builder.options_mut();
                     // NOTE: timeout will be set by config (for example, /etc/resolv.conf on UNIX-like system)
                     //
                     // Only ip_strategy should be changed. Why Ipv4AndIpv6? See comments above.
@@ -179,15 +169,15 @@ pub async fn create_resolver(
                     // Enable EDNS0 for large records
                     opts.edns0 = true;
 
-                    trace!(
-                        "initializing DNS resolver with system-config {:?} opts {:?}",
-                        config,
-                        opts
-                    );
+                    trace!("initializing DNS resolver with system-config opts {:?}", opts);
 
-                    Ok(DnsResolver::new(config, opts, ShadowDnsConnectionProvider::new(ShadowDnsRuntimeProvider::new(connect_opts))))
-                } else {
-                    Err(ResolveError::from("current platform doesn't support hickory-dns resolver with system configured".to_owned()))
+                    Ok(builder.build())
+                }
+                Err(err) => {
+                    error!("initialize DNS resolver with system-config failed, error: {}", err);
+                    Err(ResolveError::from(
+                        "current platform doesn't support hickory-dns resolver with system configured".to_owned(),
+                    ))
                 }
             }
         }
diff --git a/crates/shadowsocks/src/dns_resolver/resolver.rs b/crates/shadowsocks/src/dns_resolver/resolver.rs
index 4c09cf6a..e319a4fa 100644
--- a/crates/shadowsocks/src/dns_resolver/resolver.rs
+++ b/crates/shadowsocks/src/dns_resolver/resolver.rs
@@ -18,7 +18,7 @@ use hickory_resolver::config::ResolverConfig;
 use hickory_resolver::config::ResolverOpts;
 #[cfg(all(feature = "hickory-dns", unix, not(target_os = "android")))]
 use log::error;
-use log::{log_enabled, trace, Level};
+use log::{Level, log_enabled, trace};
 use tokio::net::lookup_host;
 #[cfg(all(feature = "hickory-dns", unix, not(target_os = "android")))]
 use tokio::task::JoinHandle;
@@ -290,7 +290,11 @@ impl DnsResolver {
     }
 
     /// Resolve address into `SocketAddr`s
-    pub async fn resolve<'a>(&self, addr: &'a str, port: u16) -> io::Result<impl Iterator<Item = SocketAddr> + 'a + use<'a>> {
+    pub async fn resolve<'a>(
+        &self,
+        addr: &'a str,
+        port: u16,
+    ) -> io::Result<impl Iterator<Item = SocketAddr> + 'a + use<'a>> {
         struct ResolverLogger<'x, 'y> {
             resolver: &'x DnsResolver,
             addr: &'y str,
diff --git a/crates/shadowsocks/src/manager/datagram.rs b/crates/shadowsocks/src/manager/datagram.rs
index 06106f1a..f50186c6 100644
--- a/crates/shadowsocks/src/manager/datagram.rs
+++ b/crates/shadowsocks/src/manager/datagram.rs
@@ -6,7 +6,7 @@ use std::{fmt, io, net::SocketAddr};
 
 use tokio::net::UdpSocket;
 #[cfg(unix)]
-use tokio::net::{unix::SocketAddr as UnixSocketAddr, UnixDatagram};
+use tokio::net::{UnixDatagram, unix::SocketAddr as UnixSocketAddr};
 
 use crate::{
     config::ManagerAddr,
diff --git a/crates/shadowsocks/src/net/mod.rs b/crates/shadowsocks/src/net/mod.rs
index 11731d2c..6b69fbcd 100644
--- a/crates/shadowsocks/src/net/mod.rs
+++ b/crates/shadowsocks/src/net/mod.rs
@@ -6,7 +6,7 @@ use std::net::SocketAddr;
 pub use self::sys::uds::{UnixListener, UnixStream};
 pub use self::{
     option::{AcceptOpts, ConnectOpts, TcpSocketOpts, UdpSocketOpts},
-    sys::{get_ip_stack_capabilities, set_tcp_fastopen, socket_bind_dual_stack, IpStackCapabilities},
+    sys::{IpStackCapabilities, get_ip_stack_capabilities, set_tcp_fastopen, socket_bind_dual_stack},
     tcp::{TcpListener, TcpStream},
     udp::UdpSocket,
 };
diff --git a/crates/shadowsocks/src/net/sys/unix/bsd/freebsd.rs b/crates/shadowsocks/src/net/sys/unix/bsd/freebsd.rs
index 85983a86..f2095b3c 100644
--- a/crates/shadowsocks/src/net/sys/unix/bsd/freebsd.rs
+++ b/crates/shadowsocks/src/net/sys/unix/bsd/freebsd.rs
@@ -18,9 +18,9 @@ use tokio::{
 use tokio_tfo::TfoStream;
 
 use crate::net::{
+    AcceptOpts, AddrFamily, ConnectOpts,
     sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, socket_bind_dual_stack},
     udp::{BatchRecvMessage, BatchSendMessage},
-    AcceptOpts, AddrFamily, ConnectOpts,
 };
 
 /// A `TcpStream` that supports TFO (TCP Fast Open)
diff --git a/crates/shadowsocks/src/net/sys/unix/bsd/macos.rs b/crates/shadowsocks/src/net/sys/unix/bsd/macos.rs
index 3e77374e..5c67933a 100644
--- a/crates/shadowsocks/src/net/sys/unix/bsd/macos.rs
+++ b/crates/shadowsocks/src/net/sys/unix/bsd/macos.rs
@@ -22,9 +22,9 @@ use tokio::{
 use tokio_tfo::TfoStream;
 
 use crate::net::{
+    AcceptOpts, AddrFamily, ConnectOpts,
     sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, socket_bind_dual_stack},
     udp::{BatchRecvMessage, BatchSendMessage},
-    AcceptOpts, AddrFamily, ConnectOpts,
 };
 
 /// A `TcpStream` that supports TFO (TCP Fast Open)
diff --git a/crates/shadowsocks/src/net/sys/unix/linux/mod.rs b/crates/shadowsocks/src/net/sys/unix/linux/mod.rs
index faebaec6..356c5a33 100644
--- a/crates/shadowsocks/src/net/sys/unix/linux/mod.rs
+++ b/crates/shadowsocks/src/net/sys/unix/linux/mod.rs
@@ -19,9 +19,9 @@ use tokio::{
 use tokio_tfo::TfoStream;
 
 use crate::net::{
+    AcceptOpts, AddrFamily, ConnectOpts,
     sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, socket_bind_dual_stack},
     udp::{BatchRecvMessage, BatchSendMessage},
-    AcceptOpts, AddrFamily, ConnectOpts,
 };
 
 /// A `TcpStream` that supports TFO (TCP Fast Open)
diff --git a/crates/shadowsocks/src/net/sys/unix/mod.rs b/crates/shadowsocks/src/net/sys/unix/mod.rs
index 6020c083..03642b0d 100644
--- a/crates/shadowsocks/src/net/sys/unix/mod.rs
+++ b/crates/shadowsocks/src/net/sys/unix/mod.rs
@@ -9,7 +9,7 @@ use log::warn;
 use socket2::{Domain, Protocol, Socket, TcpKeepalive, Type};
 use tokio::net::UdpSocket;
 
-use crate::net::{is_dual_stack_addr, sys::socket_bind_dual_stack, AcceptOpts, AddrFamily, ConnectOpts, TcpSocketOpts};
+use crate::net::{AcceptOpts, AddrFamily, ConnectOpts, TcpSocketOpts, is_dual_stack_addr, sys::socket_bind_dual_stack};
 
 cfg_if! {
     if #[cfg(any(target_os = "linux", target_os = "android"))] {
diff --git a/crates/shadowsocks/src/net/sys/unix/others.rs b/crates/shadowsocks/src/net/sys/unix/others.rs
index cb047e4e..15cac8f0 100644
--- a/crates/shadowsocks/src/net/sys/unix/others.rs
+++ b/crates/shadowsocks/src/net/sys/unix/others.rs
@@ -14,8 +14,8 @@ use tokio::{
 };
 
 use crate::net::{
-    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, ErrorKind},
     AcceptOpts, AddrFamily, ConnectOpts,
+    sys::{ErrorKind, set_common_sockopt_after_connect, set_common_sockopt_for_connect},
 };
 
 /// A wrapper of `TcpStream`
diff --git a/crates/shadowsocks/src/net/sys/unix/uds.rs b/crates/shadowsocks/src/net/sys/unix/uds.rs
index 31f597df..e8eba2bc 100644
--- a/crates/shadowsocks/src/net/sys/unix/uds.rs
+++ b/crates/shadowsocks/src/net/sys/unix/uds.rs
@@ -13,7 +13,7 @@ use pin_project::pin_project;
 use sendfd::{RecvWithFd, SendWithFd};
 use tokio::{
     io::{AsyncRead, AsyncWrite, Interest, ReadBuf},
-    net::{unix::SocketAddr, UnixListener as TokioUnixListener, UnixStream as TokioUnixStream},
+    net::{UnixListener as TokioUnixListener, UnixStream as TokioUnixStream, unix::SocketAddr},
 };
 
 /// A UnixStream supports transferring FDs between processes
diff --git a/crates/shadowsocks/src/net/sys/windows/mod.rs b/crates/shadowsocks/src/net/sys/windows/mod.rs
index 45751070..05d8008f 100644
--- a/crates/shadowsocks/src/net/sys/windows/mod.rs
+++ b/crates/shadowsocks/src/net/sys/windows/mod.rs
@@ -1,7 +1,7 @@
 use std::{
     cell::RefCell,
     collections::HashMap,
-    ffi::{c_void, CStr, CString, OsString},
+    ffi::{CStr, CString, OsString, c_void},
     io::{self, ErrorKind},
     mem,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
@@ -25,28 +25,27 @@ use tokio::{
 };
 use tokio_tfo::TfoStream;
 use windows_sys::{
-    core::PCSTR,
     Win32::{
         Foundation::{BOOL, ERROR_BUFFER_OVERFLOW, ERROR_NO_DATA, ERROR_SUCCESS},
         NetworkManagement::IpHelper::{
-            if_nametoindex, GetAdaptersAddresses, GAA_FLAG_SKIP_ANYCAST, GAA_FLAG_SKIP_DNS_SERVER,
-            GAA_FLAG_SKIP_MULTICAST, GAA_FLAG_SKIP_UNICAST, IP_ADAPTER_ADDRESSES_LH,
+            GAA_FLAG_SKIP_ANYCAST, GAA_FLAG_SKIP_DNS_SERVER, GAA_FLAG_SKIP_MULTICAST, GAA_FLAG_SKIP_UNICAST,
+            GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH, if_nametoindex,
         },
         Networking::WinSock::{
-            htonl, setsockopt, WSAGetLastError, WSAIoctl, AF_UNSPEC, IPPROTO_IP, IPPROTO_IPV6, IPPROTO_TCP,
-            IPV6_MTU_DISCOVER, IPV6_UNICAST_IF, IP_MTU_DISCOVER, IP_PMTUDISC_DO, IP_UNICAST_IF, SIO_UDP_CONNRESET,
-            SOCKET, SOCKET_ERROR, TCP_FASTOPEN,
+            AF_UNSPEC, IP_MTU_DISCOVER, IP_PMTUDISC_DO, IP_UNICAST_IF, IPPROTO_IP, IPPROTO_IPV6, IPPROTO_TCP,
+            IPV6_MTU_DISCOVER, IPV6_UNICAST_IF, SIO_UDP_CONNRESET, SOCKET, SOCKET_ERROR, TCP_FASTOPEN, WSAGetLastError,
+            WSAIoctl, htonl, setsockopt,
         },
     },
+    core::PCSTR,
 };
 
 // BOOL values
 const FALSE: BOOL = 0;
 
 use crate::net::{
-    is_dual_stack_addr,
+    AcceptOpts, AddrFamily, ConnectOpts, is_dual_stack_addr,
     sys::{set_common_sockopt_for_connect, socket_bind_dual_stack},
-    AcceptOpts, AddrFamily, ConnectOpts,
 };
 
 /// A `TcpStream` that supports TFO (TCP Fast Open)
diff --git a/crates/shadowsocks/src/net/tcp.rs b/crates/shadowsocks/src/net/tcp.rs
index 66b797a6..d0f7ebc3 100644
--- a/crates/shadowsocks/src/net/tcp.rs
+++ b/crates/shadowsocks/src/net/tcp.rs
@@ -19,15 +19,14 @@ use tokio::{
     net::{TcpListener as TokioTcpListener, TcpStream as TokioTcpStream},
 };
 
-use crate::{context::Context, relay::socks5::Address, ServerAddr};
+use crate::{ServerAddr, context::Context, relay::socks5::Address};
 
 use super::{
-    is_dual_stack_addr,
+    AcceptOpts, ConnectOpts, is_dual_stack_addr,
     sys::{
-        create_inbound_tcp_socket, set_common_sockopt_after_accept, set_tcp_fastopen, socket_bind_dual_stack,
-        TcpStream as SysTcpStream,
+        TcpStream as SysTcpStream, create_inbound_tcp_socket, set_common_sockopt_after_accept, set_tcp_fastopen,
+        socket_bind_dual_stack,
     },
-    AcceptOpts, ConnectOpts,
 };
 
 /// TcpStream for outbound connections
diff --git a/crates/shadowsocks/src/net/udp.rs b/crates/shadowsocks/src/net/udp.rs
index a84e75a4..2cb82474 100644
--- a/crates/shadowsocks/src/net/udp.rs
+++ b/crates/shadowsocks/src/net/udp.rs
@@ -35,11 +35,11 @@ use futures::ready;
 use tokio::io::Interest;
 use tokio::{io::ReadBuf, net::ToSocketAddrs};
 
-use crate::{context::Context, relay::socks5::Address, ServerAddr};
+use crate::{ServerAddr, context::Context, relay::socks5::Address};
 
 use super::{
-    sys::{bind_outbound_udp_socket, create_inbound_udp_socket, create_outbound_udp_socket},
     AcceptOpts, AddrFamily, ConnectOpts,
+    sys::{bind_outbound_udp_socket, create_inbound_udp_socket, create_outbound_udp_socket},
 };
 
 /// Message struct for `batch_send`
diff --git a/crates/shadowsocks/src/plugin/ss_plugin.rs b/crates/shadowsocks/src/plugin/ss_plugin.rs
index c6a2f21c..9487d91b 100644
--- a/crates/shadowsocks/src/plugin/ss_plugin.rs
+++ b/crates/shadowsocks/src/plugin/ss_plugin.rs
@@ -7,11 +7,7 @@ use tokio::process::Command;
 pub fn plugin_cmd(plugin: &PluginConfig, remote: &ServerAddr, local: &SocketAddr, _mode: PluginMode) -> Command {
     trace!(
         "Starting plugin \"{}\", opt: {:?}, arg: {:?}, remote: {}, local: {}",
-        plugin.plugin,
-        plugin.plugin_opts,
-        plugin.plugin_args,
-        remote,
-        local
+        plugin.plugin, plugin.plugin_opts, plugin.plugin_args, remote, local
     );
 
     let mut cmd = Command::new(&plugin.plugin);
diff --git a/crates/shadowsocks/src/relay/mod.rs b/crates/shadowsocks/src/relay/mod.rs
index 6f467664..0fe4a26f 100644
--- a/crates/shadowsocks/src/relay/mod.rs
+++ b/crates/shadowsocks/src/relay/mod.rs
@@ -15,7 +15,7 @@ const AEAD2022_MAX_PADDING_SIZE: usize = 900;
 fn get_aead_2022_padding_size(payload: &[u8]) -> usize {
     use std::cell::RefCell;
 
-    use rand::{rngs::SmallRng, Rng, SeedableRng};
+    use rand::{Rng, SeedableRng, rngs::SmallRng};
 
     thread_local! {
         static PADDING_RNG: RefCell<SmallRng> = RefCell::new(SmallRng::from_os_rng());
diff --git a/crates/shadowsocks/src/relay/tcprelay/aead.rs b/crates/shadowsocks/src/relay/tcprelay/aead.rs
index 9fd19c73..d8c757ff 100644
--- a/crates/shadowsocks/src/relay/tcprelay/aead.rs
+++ b/crates/shadowsocks/src/relay/tcprelay/aead.rs
@@ -47,7 +47,7 @@ use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 use crate::{
     context::Context,
-    crypto::{v1::Cipher, CipherKind},
+    crypto::{CipherKind, v1::Cipher},
 };
 
 /// AEAD packet payload must be smaller than 0x3FFF
@@ -64,7 +64,9 @@ pub enum ProtocolError {
     DecryptDataError,
     #[error("decrypt length failed")]
     DecryptLengthError,
-    #[error("buffer size too large ({0:#x}), AEAD encryption protocol requires buffer to be smaller than 0x3FFF, the higher two bits must be set to zero")]
+    #[error(
+        "buffer size too large ({0:#x}), AEAD encryption protocol requires buffer to be smaller than 0x3FFF, the higher two bits must be set to zero"
+    )]
     DataTooLong(usize),
 }
 
diff --git a/crates/shadowsocks/src/relay/tcprelay/aead_2022.rs b/crates/shadowsocks/src/relay/tcprelay/aead_2022.rs
index bbc54836..f66f6de3 100644
--- a/crates/shadowsocks/src/relay/tcprelay/aead_2022.rs
+++ b/crates/shadowsocks/src/relay/tcprelay/aead_2022.rs
@@ -54,8 +54,8 @@ use std::{
 };
 
 use aes::{
-    cipher::{BlockDecrypt, BlockEncrypt, KeyInit},
     Aes128, Aes256, Block,
+    cipher::{BlockDecrypt, BlockEncrypt, KeyInit},
 };
 use byte_string::ByteStr;
 use bytes::{Buf, BufMut, Bytes, BytesMut};
@@ -65,9 +65,9 @@ use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 use super::{crypto_io::StreamType, proxy_stream::protocol::v2::SERVER_STREAM_TIMESTAMP_MAX_DIFF};
 use crate::{
-    config::{method_support_eih, ServerUserManager},
+    config::{ServerUserManager, method_support_eih},
     context::Context,
-    crypto::{v2::tcp::TcpCipher, CipherKind},
+    crypto::{CipherKind, v2::tcp::TcpCipher},
 };
 
 #[inline]
diff --git a/crates/shadowsocks/src/relay/tcprelay/proxy_stream/client.rs b/crates/shadowsocks/src/relay/tcprelay/proxy_stream/client.rs
index cc567a5d..5b01512c 100644
--- a/crates/shadowsocks/src/relay/tcprelay/proxy_stream/client.rs
+++ b/crates/shadowsocks/src/relay/tcprelay/proxy_stream/client.rs
@@ -128,7 +128,7 @@ where
                         return Err(io::Error::new(
                             ErrorKind::TimedOut,
                             format!("connect {} timeout", svr_cfg.addr()),
-                        ))
+                        ));
                     }
                 }
             }
diff --git a/crates/shadowsocks/src/relay/tcprelay/stream.rs b/crates/shadowsocks/src/relay/tcprelay/stream.rs
index 5918f56b..e7e72d39 100644
--- a/crates/shadowsocks/src/relay/tcprelay/stream.rs
+++ b/crates/shadowsocks/src/relay/tcprelay/stream.rs
@@ -15,7 +15,7 @@ use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 use crate::{
     context::Context,
-    crypto::{v1::Cipher, CipherKind},
+    crypto::{CipherKind, v1::Cipher},
 };
 
 /// Stream protocol error
diff --git a/crates/shadowsocks/src/relay/tcprelay/utils.rs b/crates/shadowsocks/src/relay/tcprelay/utils.rs
index e37d8c66..ce964dbf 100644
--- a/crates/shadowsocks/src/relay/tcprelay/utils.rs
+++ b/crates/shadowsocks/src/relay/tcprelay/utils.rs
@@ -255,8 +255,7 @@ where
                     Ok(..) => {
                         trace!(
                             "copy bidirection ends, a_to_b: {:?}, b_to_a: {:?}",
-                            self.a_to_b,
-                            self.b_to_a
+                            self.a_to_b, self.b_to_a
                         );
                     }
                     Err(ref err) => {
diff --git a/crates/shadowsocks/src/relay/udprelay/aead.rs b/crates/shadowsocks/src/relay/udprelay/aead.rs
index 4455b447..618b9d0b 100644
--- a/crates/shadowsocks/src/relay/udprelay/aead.rs
+++ b/crates/shadowsocks/src/relay/udprelay/aead.rs
@@ -19,7 +19,7 @@ use log::trace;
 
 use crate::{
     context::Context,
-    crypto::{v1::Cipher, CipherKind},
+    crypto::{CipherKind, v1::Cipher},
     relay::socks5::{Address, Error as Socks5Error},
 };
 
diff --git a/crates/shadowsocks/src/relay/udprelay/aead_2022.rs b/crates/shadowsocks/src/relay/udprelay/aead_2022.rs
index bf27ded4..2e07346a 100644
--- a/crates/shadowsocks/src/relay/udprelay/aead_2022.rs
+++ b/crates/shadowsocks/src/relay/udprelay/aead_2022.rs
@@ -57,8 +57,8 @@ use std::{
 };
 
 use aes::{
-    cipher::{BlockDecrypt, BlockEncrypt, KeyInit},
     Aes128, Aes256, Block,
+    cipher::{BlockDecrypt, BlockEncrypt, KeyInit},
 };
 use byte_string::ByteStr;
 use bytes::{Buf, BufMut, Bytes, BytesMut};
@@ -68,11 +68,11 @@ use lru_time_cache::LruCache;
 #[cfg(feature = "aead-cipher-2022-extra")]
 use crate::crypto::v2::udp::ChaCha8Poly1305Cipher;
 use crate::{
-    config::{method_support_eih, ServerUser, ServerUserManager},
+    config::{ServerUser, ServerUserManager, method_support_eih},
     context::Context,
     crypto::{
-        v2::udp::{ChaCha20Poly1305Cipher, UdpCipher},
         CipherKind,
+        v2::udp::{ChaCha20Poly1305Cipher, UdpCipher},
     },
     relay::{
         get_aead_2022_padding_size,
diff --git a/crates/shadowsocks/src/relay/udprelay/proxy_socket.rs b/crates/shadowsocks/src/relay/udprelay/proxy_socket.rs
index 8be8f63c..6ad3290b 100644
--- a/crates/shadowsocks/src/relay/udprelay/proxy_socket.rs
+++ b/crates/shadowsocks/src/relay/udprelay/proxy_socket.rs
@@ -8,7 +8,7 @@ use std::{
     io::{self, ErrorKind},
     net::SocketAddr,
     sync::Arc,
-    task::{ready, Context, Poll},
+    task::{Context, Poll, ready},
     time::Duration,
 };
 
@@ -29,8 +29,8 @@ use crate::{
 use super::{
     compat::{DatagramReceive, DatagramReceiveExt, DatagramSend, DatagramSendExt, DatagramSocket},
     crypto_io::{
-        decrypt_client_payload, decrypt_server_payload, encrypt_client_payload, encrypt_server_payload, ProtocolError,
-        ProtocolResult,
+        ProtocolError, ProtocolResult, decrypt_client_payload, decrypt_server_payload, encrypt_client_payload,
+        encrypt_server_payload,
     },
 };
 
@@ -385,7 +385,8 @@ where
 
     /// Send a UDP packet to target through proxy `target`
     pub async fn send_to(&self, target: SocketAddr, addr: &Address, payload: &[u8]) -> ProxySocketResult<usize> {
-        self.send_to_with_ctrl(target, addr, &DEFAULT_SOCKET_CONTROL, payload).await
+        self.send_to_with_ctrl(target, addr, &DEFAULT_SOCKET_CONTROL, payload)
+            .await
     }
 
     /// Send a UDP packet to target through proxy `target`
@@ -479,10 +480,7 @@ where
 
         trace!(
             "UDP server client receive from {}, control: {:?}, packet length {} bytes, payload length {} bytes",
-            addr,
-            control,
-            recv_n,
-            n
+            addr, control, recv_n, n
         );
 
         Ok((n, addr, recv_n, control))
@@ -527,11 +525,7 @@ where
 
         trace!(
             "UDP server client receive from {}, addr {}, control: {:?}, packet length {} bytes, payload length {} bytes",
-            target_addr,
-            addr,
-            control,
-            recv_n,
-            n,
+            target_addr, addr, control, recv_n, n,
         );
 
         Ok((n, target_addr, addr, recv_n, control))
diff --git a/crates/shadowsocks/src/relay/udprelay/stream.rs b/crates/shadowsocks/src/relay/udprelay/stream.rs
index d6706c79..f2133315 100644
--- a/crates/shadowsocks/src/relay/udprelay/stream.rs
+++ b/crates/shadowsocks/src/relay/udprelay/stream.rs
@@ -17,7 +17,7 @@ use log::trace;
 
 use crate::{
     context::Context,
-    crypto::{v1::Cipher, CipherKind},
+    crypto::{CipherKind, v1::Cipher},
     relay::socks5::{Address, Error as Socks5Error},
 };
 
diff --git a/crates/shadowsocks/tests/tcp.rs b/crates/shadowsocks/tests/tcp.rs
index 0135daca..d2e46912 100644
--- a/crates/shadowsocks/tests/tcp.rs
+++ b/crates/shadowsocks/tests/tcp.rs
@@ -14,6 +14,7 @@ use tokio::{
 };
 
 use shadowsocks::{
+    ProxyClientStream, ProxyListener,
     config::{ServerConfig, ServerType},
     context::Context,
     crypto::CipherKind,
@@ -24,7 +25,6 @@ use shadowsocks::{
             utils::{copy_from_encrypted, copy_to_encrypted},
         },
     },
-    ProxyClientStream, ProxyListener,
 };
 
 async fn handle_tcp_tunnel_server_client(
diff --git a/crates/shadowsocks/tests/tcp_tfo.rs b/crates/shadowsocks/tests/tcp_tfo.rs
index 6058ebd1..ae1aea5f 100644
--- a/crates/shadowsocks/tests/tcp_tfo.rs
+++ b/crates/shadowsocks/tests/tcp_tfo.rs
@@ -13,6 +13,7 @@ use byte_string::ByteStr;
 use futures::future;
 use log::debug;
 use shadowsocks::{
+    ProxyClientStream, ProxyListener, ServerConfig,
     config::ServerType,
     context::Context,
     crypto::CipherKind,
@@ -21,7 +22,6 @@ use shadowsocks::{
         socks5::Address,
         tcprelay::utils::{copy_from_encrypted, copy_to_encrypted},
     },
-    ProxyClientStream, ProxyListener, ServerConfig,
 };
 use tokio::{
     io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
diff --git a/src/logging/tracing.rs b/src/logging/tracing.rs
index ae85e43c..b045946d 100644
--- a/src/logging/tracing.rs
+++ b/src/logging/tracing.rs
@@ -4,7 +4,7 @@ use std::io::IsTerminal;
 
 use time::UtcOffset;
 use tracing::level_filters::LevelFilter;
-use tracing_subscriber::{fmt::time::OffsetTime, EnvFilter, FmtSubscriber};
+use tracing_subscriber::{EnvFilter, FmtSubscriber, fmt::time::OffsetTime};
 
 use crate::config::LogConfig;
 
diff --git a/src/monitor/unix.rs b/src/monitor/unix.rs
index 59ede04d..d7a36f07 100644
--- a/src/monitor/unix.rs
+++ b/src/monitor/unix.rs
@@ -1,7 +1,7 @@
 use futures::future::{self, Either, FutureExt};
 use log::info;
 use std::io;
-use tokio::signal::unix::{signal, SignalKind};
+use tokio::signal::unix::{SignalKind, signal};
 
 /// Create a monitor future for signals
 ///
diff --git a/src/service/genkey.rs b/src/service/genkey.rs
index fa49a0e3..3a361ea4 100644
--- a/src/service/genkey.rs
+++ b/src/service/genkey.rs
@@ -3,9 +3,9 @@
 use std::process::ExitCode;
 
 use base64::Engine as _;
-use clap::{builder::PossibleValuesParser, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::PossibleValuesParser};
 
-use shadowsocks_service::shadowsocks::crypto::{available_ciphers, CipherKind};
+use shadowsocks_service::shadowsocks::crypto::{CipherKind, available_ciphers};
 
 /// Defines command line options
 pub fn define_command_line_options(mut app: Command) -> Command {
diff --git a/src/service/local.rs b/src/service/local.rs
index 3b8653cd..4a1f61d1 100644
--- a/src/service/local.rs
+++ b/src/service/local.rs
@@ -10,7 +10,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use clap::{builder::PossibleValuesParser, Arg, ArgAction, ArgGroup, ArgMatches, Command, ValueHint};
+use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command, ValueHint, builder::PossibleValuesParser};
 use futures::future::{self, FutureExt};
 use log::{error, info, trace};
 use tokio::{
@@ -25,13 +25,13 @@ use shadowsocks_service::shadowsocks::relay::socks5::Address;
 use shadowsocks_service::{
     acl::AccessControl,
     config::{
-        read_variable_field_value, Config, ConfigType, LocalConfig, LocalInstanceConfig, ProtocolType,
-        ServerInstanceConfig,
+        Config, ConfigType, LocalConfig, LocalInstanceConfig, ProtocolType, ServerInstanceConfig,
+        read_variable_field_value,
     },
-    local::{loadbalancing::PingBalancer, Server},
+    local::{Server, loadbalancing::PingBalancer},
     shadowsocks::{
         config::{Mode, ServerAddr, ServerConfig, ServerSource},
-        crypto::{available_ciphers, CipherKind},
+        crypto::{CipherKind, available_ciphers},
         plugin::PluginConfig,
     },
 };
@@ -939,8 +939,11 @@ pub fn create(matches: &ArgMatches) -> ShadowsocksResult<(Runtime, impl Future<O
         // DONE READING options
 
         if config.local.is_empty() {
-            return Err(ShadowsocksError::InsufficientParams("missing `local_address`, consider specifying it by --local-addr command line option, \
-                    or \"local_address\" and \"local_port\" in configuration file".to_string()));
+            return Err(ShadowsocksError::InsufficientParams(
+                "missing `local_address`, consider specifying it by --local-addr command line option, \
+                    or \"local_address\" and \"local_port\" in configuration file"
+                    .to_string(),
+            ));
         }
 
         config
@@ -1099,7 +1102,7 @@ impl ServerReloader {
     #[cfg(unix)]
     async fn launch_signal_reload_server_task(self: Arc<Self>) {
         use log::debug;
-        use tokio::signal::unix::{signal, SignalKind};
+        use tokio::signal::unix::{SignalKind, signal};
 
         let mut sigusr1 = signal(SignalKind::user_defined1()).expect("signal");
 
diff --git a/src/service/manager.rs b/src/service/manager.rs
index 9f51b021..ae7f1d5b 100644
--- a/src/service/manager.rs
+++ b/src/service/manager.rs
@@ -2,7 +2,7 @@
 
 use std::{future::Future, net::IpAddr, path::PathBuf, process::ExitCode, time::Duration};
 
-use clap::{builder::PossibleValuesParser, Arg, ArgAction, ArgGroup, ArgMatches, Command, ValueHint};
+use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command, ValueHint, builder::PossibleValuesParser};
 use futures::future::{self, Either};
 use log::{info, trace};
 use tokio::{
@@ -18,7 +18,7 @@ use shadowsocks_service::{
     run_manager,
     shadowsocks::{
         config::{ManagerAddr, Mode},
-        crypto::{available_ciphers, CipherKind},
+        crypto::{CipherKind, available_ciphers},
         plugin::PluginConfig,
     },
 };
@@ -340,11 +340,14 @@ pub fn create(matches: &ArgMatches) -> ShadowsocksResult<(Runtime, impl Future<O
         }
 
         if let Some(addr) = matches.get_one::<ManagerAddr>("MANAGER_ADDR").cloned() {
-            match config.manager { Some(ref mut manager_config) => {
-                manager_config.addr = addr;
-            } _ => {
-                config.manager = Some(ManagerConfig::new(addr));
-            }}
+            match config.manager {
+                Some(ref mut manager_config) => {
+                    manager_config.addr = addr;
+                }
+                _ => {
+                    config.manager = Some(ManagerConfig::new(addr));
+                }
+            }
         }
 
         #[cfg(all(unix, not(target_os = "android")))]
@@ -457,8 +460,11 @@ pub fn create(matches: &ArgMatches) -> ShadowsocksResult<(Runtime, impl Future<O
         // DONE reading options
 
         config.manager.as_ref().ok_or_else(|| {
-            ShadowsocksError::InsufficientParams("missing `manager_address`, consider specifying it by --manager-address command line option, \
-                    or \"manager_address\" and \"manager_port\" keys in configuration file".to_string())
+            ShadowsocksError::InsufficientParams(
+                "missing `manager_address`, consider specifying it by --manager-address command line option, \
+                    or \"manager_address\" and \"manager_port\" keys in configuration file"
+                    .to_string(),
+            )
         })?;
 
         config
diff --git a/src/service/server.rs b/src/service/server.rs
index 8d025000..045243aa 100644
--- a/src/service/server.rs
+++ b/src/service/server.rs
@@ -2,7 +2,7 @@
 
 use std::{future::Future, net::IpAddr, path::PathBuf, process::ExitCode, time::Duration};
 
-use clap::{builder::PossibleValuesParser, Arg, ArgAction, ArgGroup, ArgMatches, Command, ValueHint};
+use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command, ValueHint, builder::PossibleValuesParser};
 use futures::future::{self, Either};
 use log::{info, trace};
 use tokio::{
@@ -12,11 +12,11 @@ use tokio::{
 
 use shadowsocks_service::{
     acl::AccessControl,
-    config::{read_variable_field_value, Config, ConfigType, ManagerConfig, ServerInstanceConfig},
+    config::{Config, ConfigType, ManagerConfig, ServerInstanceConfig, read_variable_field_value},
     run_server,
     shadowsocks::{
         config::{ManagerAddr, Mode, ServerAddr, ServerConfig},
-        crypto::{available_ciphers, CipherKind},
+        crypto::{CipherKind, available_ciphers},
         plugin::PluginConfig,
     },
 };
@@ -418,11 +418,14 @@ pub fn create(matches: &ArgMatches) -> ShadowsocksResult<(Runtime, impl Future<O
         }
 
         if let Some(addr) = matches.get_one::<ManagerAddr>("MANAGER_ADDR").cloned() {
-            match config.manager { Some(ref mut manager_config) => {
-                manager_config.addr = addr;
-            } _ => {
-                config.manager = Some(ManagerConfig::new(addr));
-            }}
+            match config.manager {
+                Some(ref mut manager_config) => {
+                    manager_config.addr = addr;
+                }
+                _ => {
+                    config.manager = Some(ManagerConfig::new(addr));
+                }
+            }
         }
 
         #[cfg(all(unix, not(target_os = "android")))]
@@ -481,9 +484,12 @@ pub fn create(matches: &ArgMatches) -> ShadowsocksResult<(Runtime, impl Future<O
         // DONE READING options
 
         if config.server.is_empty() {
-            return Err(ShadowsocksError::InsufficientParams("missing proxy servers, consider specifying it by \
+            return Err(ShadowsocksError::InsufficientParams(
+                "missing proxy servers, consider specifying it by \
                     --server-addr, --encrypt-method, --password command line option, \
-                        or configuration file, check more details in https://shadowsocks.org/doc/configs.html".to_string()));
+                        or configuration file, check more details in https://shadowsocks.org/doc/configs.html"
+                    .to_string(),
+            ));
         }
 
         config
diff --git a/src/vparser/mod.rs b/src/vparser/mod.rs
index 9c2f71bf..ccdf8c96 100644
--- a/src/vparser/mod.rs
+++ b/src/vparser/mod.rs
@@ -12,7 +12,7 @@ use shadowsocks_service::config::RedirType;
 use shadowsocks_service::local::dns::NameServerAddr;
 use shadowsocks_service::{
     config::{ManagerServerHost, ManagerServerMode},
-    shadowsocks::{crypto::CipherKind, relay::socks5::Address, ManagerAddr, ServerAddr, ServerConfig},
+    shadowsocks::{ManagerAddr, ServerAddr, ServerConfig, crypto::CipherKind, relay::socks5::Address},
 };
 
 macro_rules! value_parser_type {
diff --git a/tests/udp.rs b/tests/udp.rs
index 06caabeb..c0d2c04c 100644
--- a/tests/udp.rs
+++ b/tests/udp.rs
@@ -9,7 +9,7 @@ use shadowsocks_service::{
     config::{Config, ConfigType, LocalConfig, LocalInstanceConfig, ProtocolType, ServerInstanceConfig},
     local::socks::client::socks5::Socks5UdpClient,
     run_local, run_server,
-    shadowsocks::{config::Mode, crypto::CipherKind, relay::socks5::Address, ServerConfig},
+    shadowsocks::{ServerConfig, config::Mode, crypto::CipherKind, relay::socks5::Address},
 };
 
 const SERVER_ADDR: &str = "127.0.0.1:8093";