build(toolchain): update to rust 2024 (#731)

Author: ibigbug

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ env:
   REGISTRY: "ghcr.io"
   IMAGE_NAME: "clash-rs"
   RUST_LOG: "clash=TRACE"
-  RUST_TOOLCHAIN: "nightly-2024-12-20"
+  RUST_TOOLCHAIN: "nightly"
 
 # Arm builder https://github.blog/changelog/2024-09-03-github-actions-arm64-linux-and-windows-runners-are-now-generally-available/
 jobs:

Cargo.toml

@@ -12,7 +12,7 @@ members = [
 [workspace.package]
 version = "0.7.5"
 repository = "https://github.com/Watfaq/clash-rs.git"
-edition = "2021"
+edition = "2024"
 
 [profile.release]
 opt-level = "s"

clash/src/main.rs

@@ -81,11 +81,12 @@ fn main() {
 
     if !Path::new(&file).exists() {
         let default_config = "port: 7890";
-        let mut config_file = if let Ok(config_file) = std::fs::File::create(&file) {
-            config_file
-        } else {
-            eprintln!("default profile cannot be created: {}", file);
-            exit(1);
+        let mut config_file = match std::fs::File::create(&file) {
+            Ok(config_file) => config_file,
+            _ => {
+                eprintln!("default profile cannot be created: {}", file);
+                exit(1);
+            }
         };
 
         if config_file.write_all(default_config.as_bytes()).is_err() {

clash_ffi/src/lib.rs

@@ -1,45 +1,47 @@
-use clash_lib::{shutdown, start_scaffold, Config, Options, TokioRuntime};
+use clash_lib::{Config, Options, TokioRuntime, shutdown, start_scaffold};
 use std::{
     ffi::{CStr, CString},
     os::raw::{c_char, c_int},
 };
 
 /// # Safety
 /// This function is unsafe because it dereferences raw pointers.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn clash_start(
     config: *const c_char,
     log: *const c_char,
     cwd: *const c_char,
     multithread: c_int,
 ) -> *mut c_char {
-    let config_str = CStr::from_ptr(config)
-        .to_str()
-        .unwrap_or_default()
-        .to_string();
-    let log_str = CStr::from_ptr(log).to_str().unwrap_or_default().to_string();
-    let cwd_str = CStr::from_ptr(cwd).to_str().unwrap_or_default().to_string();
+    unsafe {
+        let config_str = CStr::from_ptr(config)
+            .to_str()
+            .unwrap_or_default()
+            .to_string();
+        let log_str = CStr::from_ptr(log).to_str().unwrap_or_default().to_string();
+        let cwd_str = CStr::from_ptr(cwd).to_str().unwrap_or_default().to_string();
 
-    let rt = if multithread != 0 {
-        Some(TokioRuntime::MultiThread)
-    } else {
-        Some(TokioRuntime::SingleThread)
-    };
+        let rt = if multithread != 0 {
+            Some(TokioRuntime::MultiThread)
+        } else {
+            Some(TokioRuntime::SingleThread)
+        };
 
-    let options = Options {
-        config: Config::Str(config_str),
-        cwd: Some(cwd_str),
-        rt,
-        log_file: Some(log_str),
-    };
+        let options = Options {
+            config: Config::Str(config_str),
+            cwd: Some(cwd_str),
+            rt,
+            log_file: Some(log_str),
+        };
 
-    match start_scaffold(options) {
-        Ok(_) => CString::new("").unwrap().into_raw(),
-        Err(e) => CString::new(format!("Error: {}", e)).unwrap().into_raw(),
+        match start_scaffold(options) {
+            Ok(_) => CString::new("").unwrap().into_raw(),
+            Err(e) => CString::new(format!("Error: {}", e)).unwrap().into_raw(),
+        }
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn clash_shutdown() -> c_int {
     if shutdown() {
         1 // Success
@@ -50,7 +52,7 @@ pub extern "C" fn clash_shutdown() -> c_int {
 
 /// # Safety
 /// This function is unsafe because it dereferences raw pointers.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[allow(unused_must_use)]
 pub unsafe extern "C" fn clash_free_string(s: *mut c_char) {
     if s.is_null() {

clash_lib/src/app/api/handlers/config.rs

@@ -1,10 +1,10 @@
 use std::{path::PathBuf, sync::Arc};
 
 use axum::{
+    Json, Router,
     extract::{Query, State},
     response::IntoResponse,
     routing::get,
-    Json, Router,
 };
 
 use http::StatusCode;
@@ -13,14 +13,14 @@ use tokio::sync::Mutex;
 use tracing::warn;
 
 use crate::{
+    GlobalState,
     app::{
         api::AppState,
         dispatcher,
         dns::ThreadSafeDNSResolver,
         inbound::manager::{Ports, ThreadSafeInboundManager},
     },
     config::{def, internal::config::BindAddress},
-    GlobalState,
 };
 
 #[derive(Clone)]

clash_lib/src/app/api/handlers/connection.rs

@@ -1,20 +1,20 @@
 use std::sync::Arc;
 
 use axum::{
+    Json, Router,
     body::Body,
     extract::{
-        ws::Message, FromRequest, Path, Query, Request, State, WebSocketUpgrade,
+        FromRequest, Path, Query, Request, State, WebSocketUpgrade, ws::Message,
     },
     response::IntoResponse,
     routing::{delete, get},
-    Json, Router,
 };
 use http::HeaderMap;
 use serde::Deserialize;
 use tracing::{debug, warn};
 
 use crate::app::{
-    api::{handlers::utils::is_request_websocket, AppState},
+    api::{AppState, handlers::utils::is_request_websocket},
     dispatcher::StatisticsManager,
 };
 

clash_lib/src/app/api/handlers/dns.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use axum::{
+    Json, Router,
     extract::{Query, State},
     response::IntoResponse,
     routing::get,
-    Json, Router,
 };
 use hickory_proto::{op::Message, rr::RecordType};
 use http::StatusCode;

clash_lib/src/app/api/handlers/log.rs

@@ -1,7 +1,7 @@
 use std::{net::SocketAddr, sync::Arc};
 
 use axum::{
-    extract::{ws::Message, ConnectInfo, State, WebSocketUpgrade},
+    extract::{ConnectInfo, State, WebSocketUpgrade, ws::Message},
     response::IntoResponse,
 };
 

clash_lib/src/app/api/handlers/memory.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use axum::{
+    Json,
     body::Body,
-    extract::{ws::Message, FromRequest, Query, Request, State, WebSocketUpgrade},
+    extract::{FromRequest, Query, Request, State, WebSocketUpgrade, ws::Message},
     response::IntoResponse,
-    Json,
 };
 use http::HeaderMap;
 use serde::{Deserialize, Serialize};

clash_lib/src/app/api/handlers/provider.rs

@@ -1,12 +1,12 @@
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use axum::{
+    Extension, Router,
     extract::{Path, Query, State},
     http::{Request, StatusCode},
     middleware::{self, Next},
     response::{IntoResponse, Response},
     routing::get,
-    Extension, Router,
 };
 use serde::Deserialize;
 
@@ -79,15 +79,16 @@ async fn find_proxy_provider_by_name(
     next: Next,
 ) -> Response {
     let outbound_manager = state.outbound_manager.clone();
-    if let Some(provider) = outbound_manager.get_proxy_provider(&name) {
-        req.extensions_mut().insert(provider);
-        next.run(req).await
-    } else {
-        (
+    match outbound_manager.get_proxy_provider(&name) {
+        Some(provider) => {
+            req.extensions_mut().insert(provider);
+            next.run(req).await
+        }
+        _ => (
             StatusCode::NOT_FOUND,
             format!("proxy provider {} not found", name),
         )
-            .into_response()
+            .into_response(),
     }
 }