Merge pull request #41 from SeaLoong:dev

cq01 · web-flow · commit 6945435ba5cc · 2025-02-22T22:39:40.000+08:00
🦄 refactor: code update
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,27 +1,27 @@
 [package]
 name = "drcom4scut"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["SeaLoong <sealoongw@foxmail.com>"]
-edition = "2021"
+edition = "2024"
 description = "A 3rd-party Drcom client for SCUT."
 license = "GPL-3.0-or-later"
 readme = "README.md"
 
 [dependencies]
-bytes = "1.8.0"
-chrono = "0.4.38"
-clap = { version = "4.5.20", features = ["cargo"] }
-crossbeam-channel = "0.5.13"
+bytes = "1.10.0"
+chrono = "0.4.39"
+clap = { version = "4.5.30", features = ["cargo"] }
+crossbeam-channel = "0.5.14"
 encoding_rs = "0.8.35"
 hex = "0.4.3"
 hostname = "0.4.0"
-log = "0.4.22"
+log = "0.4.26"
 md-5 = "0.10.6"
-rand = "0.8.5"
+rand = "0.9.0"
 trust-dns-resolver = "0.23.2"
 
 [dependencies.config]
-version = "0.14.1"
+version = "0.15.8"
 default-features = false
 features = ["yaml"]
 
diff --git a/src/device.rs b/src/device.rs
@@ -1,6 +1,6 @@
 use pnet::datalink::{
-    channel, interfaces, Channel, Config, DataLinkReceiver, DataLinkSender, MacAddr,
-    NetworkInterface,
+    Channel, Config, DataLinkReceiver, DataLinkSender, MacAddr, NetworkInterface, channel,
+    interfaces,
 };
 use pnet::ipnetwork::IpNetwork;
 use std::cell::RefCell;
diff --git a/src/eap.rs b/src/eap.rs
@@ -1,21 +1,21 @@
 use std::cmp::min;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU8, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU8, Ordering};
 use std::thread::{self, JoinHandle};
 use std::time::Duration;
 
 use bytes::{Buf, BufMut, Bytes, BytesMut};
 use chrono::Local;
-use crossbeam_channel::{unbounded, Receiver, Sender, TryRecvError};
+use crossbeam_channel::{Receiver, Sender, TryRecvError, unbounded};
 use log::{debug, error, info, warn};
 use md5::Digest;
 use pnet::datalink::MacAddr;
 
 use crate::device::Device;
 use crate::eap::packet::*;
 use crate::settings::Settings;
-use crate::util::{ip_to_vec, sleep, ChannelData, State};
+use crate::util::{ChannelData, State, ip_to_vec, sleep};
 
 mod packet;
 
@@ -145,27 +145,30 @@ impl Process<'_> {
         let resender_handle = Arc::new(
             thread::Builder::new()
                 .name("EAP-Resender".to_owned())
-                .spawn(move || loop {
-                    if quit.load(Ordering::Relaxed) {
-                        debug!("EAP-Resender thread quit!");
-                        return;
-                    }
-                    if stop.load(Ordering::Relaxed) {
-                        thread::park();
-                    }
-                    while cancel_resend.load(Ordering::Acquire) {
-                        thread::park();
-                    }
-                    let wait_ts = send_ts.load(Ordering::Acquire) - Local::now().timestamp_millis()
-                        + (interval as i64);
-                    if wait_ts > 0 {
-                        thread::sleep(Duration::from_millis(wait_ts as u64));
-                    } else if wait_ts > -interval as i64 {
-                        debug!("Resending...");
-                        cancel_resend.store(true, Ordering::Release);
-                        if tx.send((Vec::new(), true)).is_err() {
-                            error!("Unexpected! Send channel is disconnected!");
-                            quit.store(true, Ordering::Release);
+                .spawn(move || {
+                    loop {
+                        if quit.load(Ordering::Relaxed) {
+                            debug!("EAP-Resender thread quit!");
+                            return;
+                        }
+                        if stop.load(Ordering::Relaxed) {
+                            thread::park();
+                        }
+                        while cancel_resend.load(Ordering::Acquire) {
+                            thread::park();
+                        }
+                        let wait_ts = send_ts.load(Ordering::Acquire)
+                            - Local::now().timestamp_millis()
+                            + (interval as i64);
+                        if wait_ts > 0 {
+                            thread::sleep(Duration::from_millis(wait_ts as u64));
+                        } else if wait_ts > -interval as i64 {
+                            debug!("Resending...");
+                            cancel_resend.store(true, Ordering::Release);
+                            if tx.send((Vec::new(), true)).is_err() {
+                                error!("Unexpected! Send channel is disconnected!");
+                                quit.store(true, Ordering::Release);
+                            }
                         }
                     }
                 })
@@ -378,11 +381,7 @@ impl Process<'_> {
                 ),
             }
         }
-        if ret {
-            State::Sleep
-        } else {
-            State::Stop
-        }
+        if ret { State::Sleep } else { State::Stop }
     }
 
     #[inline]
diff --git a/src/logger.rs b/src/logger.rs
@@ -56,11 +56,11 @@ fn init_log4rs(settings: &Settings) {
         append::{
             console::ConsoleAppender,
             rolling_file::{
+                RollingFileAppender,
                 policy::compound::{
-                    roll::fixed_window::FixedWindowRoller, trigger::size::SizeTrigger,
-                    CompoundPolicy,
+                    CompoundPolicy, roll::fixed_window::FixedWindowRoller,
+                    trigger::size::SizeTrigger,
                 },
-                RollingFileAppender,
             },
         },
         config::{Appender, Config, Root},
diff --git a/src/main.rs b/src/main.rs
@@ -15,7 +15,7 @@ use log::{error, info};
 
 use crate::settings::Settings;
 use crate::socket::Socket;
-use crate::util::{sleep_at, ChannelData, State};
+use crate::util::{ChannelData, State, sleep_at};
 
 fn main() {
     let settings = &settings::SETTINGS;
@@ -62,7 +62,7 @@ fn main() {
     let (tx, rx) = crossbeam_channel::unbounded::<ChannelData>();
     let tx1 = tx.clone();
 
-    let eap_handle = thread::Builder::new()
+    let _eap_handle = thread::Builder::new()
         .name("EAP-Process-Generator".to_owned())
         .spawn(move || {
             let device = Arc::new(device);
@@ -210,7 +210,7 @@ fn main() {
     udp_handle
         .join()
         .expect("Fatal error! UDP Process generator thread quit!");
-    eap_handle
+    _eap_handle
         .join()
         .expect("Fatal error! EAP Process generator thread quit!");
 }
diff --git a/src/settings.rs b/src/settings.rs
@@ -333,7 +333,9 @@ impl Settings {
                     if let Ok(v) = hex::decode(s) {
                         settings.data.response_identity.unknown = v;
                     } else {
-                        error!("Invalid config: data.response_identity.unknown! Default value instead.")
+                        error!(
+                            "Invalid config: data.response_identity.unknown! Default value instead."
+                        )
                     }
                 }
             }
@@ -342,7 +344,9 @@ impl Settings {
                     if let Ok(v) = hex::decode(s) {
                         settings.data.response_md5_challenge.unknown = v;
                     } else {
-                        error!("Invalid config: data.response_md5_challenge.unknown! Default value instead.")
+                        error!(
+                            "Invalid config: data.response_md5_challenge.unknown! Default value instead."
+                        )
                     }
                 }
             }
diff --git a/src/socket.rs b/src/socket.rs
@@ -2,8 +2,8 @@ use std::io;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 
 use log::{error, info};
-use trust_dns_resolver::config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts};
 use trust_dns_resolver::Resolver;
+use trust_dns_resolver::config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts};
 
 use crate::settings::Settings;
 
diff --git a/src/udp.rs b/src/udp.rs
@@ -7,17 +7,17 @@ use std::time::Duration;
 
 use bytes::BytesMut;
 use chrono::Local;
-use crossbeam_channel::{unbounded, Receiver, Sender, TryRecvError};
+use crossbeam_channel::{Receiver, Sender, TryRecvError, unbounded};
 use log::{debug, error, info};
 use pnet::datalink::MacAddr;
 
 use crate::settings::Settings;
 use crate::socket::Socket;
 use crate::udp::packet::{
-    decrypt_info, Alive, HeaderType, HeartbeatType, MiscAlive, MiscHeartbeat1, MiscHeartbeat3,
-    MiscInfo,
+    Alive, HeaderType, HeartbeatType, MiscAlive, MiscHeartbeat1, MiscHeartbeat3, MiscInfo,
+    decrypt_info,
 };
-use crate::util::{self, random_vec, sleep, ChannelData, State};
+use crate::util::{self, ChannelData, State, random_vec, sleep};
 
 mod packet;
 
@@ -158,27 +158,30 @@ impl<'a> Process<'a> {
         let resender_handle = Arc::new(
             thread::Builder::new()
                 .name("UDP-ReSender".to_owned())
-                .spawn(move || loop {
-                    if quit.load(Ordering::Relaxed) {
-                        debug!("UDP-Resender thread quit!");
-                        return;
-                    }
-                    if stop.load(Ordering::Relaxed) {
-                        thread::park();
-                    }
-                    while cancel_resend.load(Ordering::Acquire) {
-                        thread::park();
-                    }
-                    let wait_ts = send_ts.load(Ordering::Acquire) - Local::now().timestamp_millis()
-                        + (interval as i64);
-                    if wait_ts > 0 {
-                        thread::sleep(Duration::from_millis(wait_ts as u64));
-                    } else if wait_ts > -interval as i64 {
-                        debug!("Resending...");
-                        cancel_resend.store(true, Ordering::Release);
-                        if tx.send((Vec::new(), true)).is_err() {
-                            error!("Unexpected! Send channel is disconnected!");
-                            quit.store(true, Ordering::Release);
+                .spawn(move || {
+                    loop {
+                        if quit.load(Ordering::Relaxed) {
+                            debug!("UDP-Resender thread quit!");
+                            return;
+                        }
+                        if stop.load(Ordering::Relaxed) {
+                            thread::park();
+                        }
+                        while cancel_resend.load(Ordering::Acquire) {
+                            thread::park();
+                        }
+                        let wait_ts = send_ts.load(Ordering::Acquire)
+                            - Local::now().timestamp_millis()
+                            + (interval as i64);
+                        if wait_ts > 0 {
+                            thread::sleep(Duration::from_millis(wait_ts as u64));
+                        } else if wait_ts > -interval as i64 {
+                            debug!("Resending...");
+                            cancel_resend.store(true, Ordering::Release);
+                            if tx.send((Vec::new(), true)).is_err() {
+                                error!("Unexpected! Send channel is disconnected!");
+                                quit.store(true, Ordering::Release);
+                            }
                         }
                     }
                 })
@@ -294,47 +297,49 @@ impl<'a> Process<'a> {
         self.receiving_eap_handle = Some(Arc::new(
             thread::Builder::new()
                 .name("EAPtoUDP".to_owned())
-                .spawn(move || loop {
-                    if quit.load(Ordering::Relaxed) {
-                        info!("Stop receiving message from EAP.");
-                        debug!("EAPtoUDP thread quit!");
-                        return;
-                    }
-                    if stop.load(Ordering::Relaxed) {
-                        thread.unpark();
-                        thread::park();
-                    }
-                    match rx.recv() {
-                        Ok(x) => match x.state {
-                            State::Success => {
-                                info!("Receive SUCCESS from EAP.");
-                                loop {
-                                    if let Ok(mut r) = data.try_write() {
-                                        r.cks_md5 = x.data;
-                                        info!("cks_md5(md5): {}", hex::encode(&r.cks_md5));
-                                        break;
+                .spawn(move || {
+                    loop {
+                        if quit.load(Ordering::Relaxed) {
+                            info!("Stop receiving message from EAP.");
+                            debug!("EAPtoUDP thread quit!");
+                            return;
+                        }
+                        if stop.load(Ordering::Relaxed) {
+                            thread.unpark();
+                            thread::park();
+                        }
+                        match rx.recv() {
+                            Ok(x) => match x.state {
+                                State::Success => {
+                                    info!("Receive SUCCESS from EAP.");
+                                    loop {
+                                        if let Ok(mut r) = data.try_write() {
+                                            r.cks_md5 = x.data;
+                                            info!("cks_md5(md5): {}", hex::encode(&r.cks_md5));
+                                            break;
+                                        }
+                                        util::sleep();
                                     }
-                                    util::sleep();
+                                    thread.unpark();
                                 }
-                                thread.unpark();
-                            }
-                            State::Stop => {
-                                info!("Receive STOP from EAP.");
-                                stop.store(true, Ordering::Release);
-                            }
-                            State::Sleep => {
-                                info!("Receive SLEEP from EAP.");
-                                sleep.store(true, Ordering::Release);
-                                stop.store(true, Ordering::Release);
-                            }
-                            State::Quit => {
-                                info!("Receive QUIT from EAP.");
+                                State::Stop => {
+                                    info!("Receive STOP from EAP.");
+                                    stop.store(true, Ordering::Release);
+                                }
+                                State::Sleep => {
+                                    info!("Receive SLEEP from EAP.");
+                                    sleep.store(true, Ordering::Release);
+                                    stop.store(true, Ordering::Release);
+                                }
+                                State::Quit => {
+                                    info!("Receive QUIT from EAP.");
+                                    quit.store(true, Ordering::Release);
+                                }
+                            },
+                            Err(_) => {
+                                error!("Unexpected! EAPtoUDP channel is closed.");
                                 quit.store(true, Ordering::Release);
                             }
-                        },
-                        Err(_) => {
-                            error!("Unexpected! EAPtoUDP channel is closed.");
-                            quit.store(true, Ordering::Release);
                         }
                     }
                 })
diff --git a/src/udp/packet.rs b/src/udp/packet.rs
@@ -237,11 +237,17 @@ impl Alive {
 fn test() {
     let mut v = hex::decode("0701f400030cb025aa286db97dd9fee10222002a3bab4e04c72f3101000000003230313833363433313135345365614c6f6f6e67000000000000000000000000000000000000000000000000ca26c12100000000ca7011210000000000000000940000000600000002000000f0230000020000004472434f4d0096022a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034656238316663303438613535383562376466653137383331353532343161333238623130336336000000000000000000000000000000000000000000000000").unwrap();
     append_cks32(&mut v);
-    assert_eq!(hex::encode(v), "0701f400030cb025aa286db97dd9fee10222002a3bab4e044af8a726000000003230313833363433313135345365614c6f6f6e67000000000000000000000000000000000000000000000000ca26c12100000000ca7011210000000000000000940000000600000002000000f0230000020000004472434f4d0096022a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034656238316663303438613535383562376466653137383331353532343161333238623130336336000000000000000000000000000000000000000000000000");
+    assert_eq!(
+        hex::encode(v),
+        "0701f400030cb025aa286db97dd9fee10222002a3bab4e044af8a726000000003230313833363433313135345365614c6f6f6e67000000000000000000000000000000000000000000000000ca26c12100000000ca7011210000000000000000940000000600000002000000f0230000020000004472434f4d0096022a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034656238316663303438613535383562376466653137383331353532343161333238623130336336000000000000000000000000000000000000000000000000"
+    );
 
     let mut v = hex::decode("0701f400030cb025aa286db97dd9fee10222002a53513f04c72f3101000000003230313833363433313135345365614c6f6f6e67000000000000000000000000000000000000000000000000ca26c12100000000ca7011210000000000000000940000000600000002000000f0230000020000004472434f4d0096022a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034656238316663303438613535383562376466653137383331353532343161333238623130336336000000000000000000000000000000000000000000000000").unwrap();
     append_cks32(&mut v);
-    assert_eq!(hex::encode(v), "0701f400030cb025aa286db97dd9fee10222002a53513f049adf0351000000003230313833363433313135345365614c6f6f6e67000000000000000000000000000000000000000000000000ca26c12100000000ca7011210000000000000000940000000600000002000000f0230000020000004472434f4d0096022a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034656238316663303438613535383562376466653137383331353532343161333238623130336336000000000000000000000000000000000000000000000000");
+    assert_eq!(
+        hex::encode(v),
+        "0701f400030cb025aa286db97dd9fee10222002a53513f049adf0351000000003230313833363433313135345365614c6f6f6e67000000000000000000000000000000000000000000000000ca26c12100000000ca7011210000000000000000940000000600000002000000f0230000020000004472434f4d0096022a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034656238316663303438613535383562376466653137383331353532343161333238623130336336000000000000000000000000000000000000000000000000"
+    );
 
     let mut v = hex::decode(
         "075628000b03dc02b91900000000000067513f0400000000000000007dd9fee10000000000000000",

Original file line number	Diff line number	Diff line change
`@@ -333,7 +333,9 @@ impl Settings {`
`333`	`333`	`if let Ok(v) = hex::decode(s) {`
`334`	`334`	`settings.data.response_identity.unknown = v;`
`335`	`335`	`} else {`
`336`		`- error!("Invalid config: data.response_identity.unknown! Default value instead.")`
	`336`	`+ error!(`
	`337`	`+ "Invalid config: data.response_identity.unknown! Default value instead."`
	`338`	`+ )`
`337`	`339`	`}`
`338`	`340`	`}`
`339`	`341`	`}`
`@@ -342,7 +344,9 @@ impl Settings {`
`342`	`344`	`if let Ok(v) = hex::decode(s) {`
`343`	`345`	`settings.data.response_md5_challenge.unknown = v;`
`344`	`346`	`} else {`
`345`		`- error!("Invalid config: data.response_md5_challenge.unknown! Default value instead.")`
	`347`	`+ error!(`
	`348`	`+ "Invalid config: data.response_md5_challenge.unknown! Default value instead."`
	`349`	`+ )`
`346`	`350`	`}`
`347`	`351`	`}`
`348`	`352`	`}`