clippy

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "rust.checkWith": "clippy",
+    "rust.formatOnSave": true,
+    "rust.checkOnSave": true,
+    "rust.useNewErrorFormat": true
+}

libs/hbb_common/build.rs

@@ -6,7 +6,7 @@ fn main() {
     protobuf_codegen::Codegen::new()
         .pure()
         .out_dir(out_dir)
-        .inputs(&["protos/rendezvous.proto", "protos/message.proto"])
+        .inputs(["protos/rendezvous.proto", "protos/message.proto"])
         .include("protos")
         .customize(protobuf_codegen::Customize::default().tokio_bytes(true))
         .run()

libs/hbb_common/src/bytes_codec.rs

@@ -143,32 +143,32 @@ mod tests {
         let mut buf = BytesMut::new();
         let mut bytes: Vec<u8> = Vec::new();
         bytes.resize(0x3F, 1);
-        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert!(codec.encode(bytes.into(), &mut buf).is_ok());
         let buf_saved = buf.clone();
         assert_eq!(buf.len(), 0x3F + 1);
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0x3F);
             assert_eq!(res[0], 1);
         } else {
-            assert!(false);
+            panic!();
         }
         let mut codec2 = BytesCodec::new();
         let mut buf2 = BytesMut::new();
         if let Ok(None) = codec2.decode(&mut buf2) {
         } else {
-            assert!(false);
+            panic!();
         }
         buf2.extend(&buf_saved[0..1]);
         if let Ok(None) = codec2.decode(&mut buf2) {
         } else {
-            assert!(false);
+            panic!();
         }
         buf2.extend(&buf_saved[1..]);
         if let Ok(Some(res)) = codec2.decode(&mut buf2) {
             assert_eq!(res.len(), 0x3F);
             assert_eq!(res[0], 1);
         } else {
-            assert!(false);
+            panic!();
         }
     }
 
@@ -177,21 +177,21 @@ mod tests {
         let mut codec = BytesCodec::new();
         let mut buf = BytesMut::new();
         let mut bytes: Vec<u8> = Vec::new();
-        assert!(!codec.encode("".into(), &mut buf).is_err());
+        assert!(codec.encode("".into(), &mut buf).is_ok());
         assert_eq!(buf.len(), 1);
         bytes.resize(0x3F + 1, 2);
-        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert!(codec.encode(bytes.into(), &mut buf).is_ok());
         assert_eq!(buf.len(), 0x3F + 2 + 2);
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0);
         } else {
-            assert!(false);
+            panic!();
         }
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0x3F + 1);
             assert_eq!(res[0], 2);
         } else {
-            assert!(false);
+            panic!();
         }
     }
 
@@ -201,13 +201,13 @@ mod tests {
         let mut buf = BytesMut::new();
         let mut bytes: Vec<u8> = Vec::new();
         bytes.resize(0x3F - 1, 3);
-        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert!(codec.encode(bytes.into(), &mut buf).is_ok());
         assert_eq!(buf.len(), 0x3F + 1 - 1);
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0x3F - 1);
             assert_eq!(res[0], 3);
         } else {
-            assert!(false);
+            panic!();
         }
     }
     #[test]
@@ -216,13 +216,13 @@ mod tests {
         let mut buf = BytesMut::new();
         let mut bytes: Vec<u8> = Vec::new();
         bytes.resize(0x3FFF, 4);
-        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert!(codec.encode(bytes.into(), &mut buf).is_ok());
         assert_eq!(buf.len(), 0x3FFF + 2);
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0x3FFF);
             assert_eq!(res[0], 4);
         } else {
-            assert!(false);
+            panic!();
         }
     }
 
@@ -232,13 +232,13 @@ mod tests {
         let mut buf = BytesMut::new();
         let mut bytes: Vec<u8> = Vec::new();
         bytes.resize(0x3FFFFF, 5);
-        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert!(codec.encode(bytes.into(), &mut buf).is_ok());
         assert_eq!(buf.len(), 0x3FFFFF + 3);
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0x3FFFFF);
             assert_eq!(res[0], 5);
         } else {
-            assert!(false);
+            panic!();
         }
     }
 
@@ -248,33 +248,33 @@ mod tests {
         let mut buf = BytesMut::new();
         let mut bytes: Vec<u8> = Vec::new();
         bytes.resize(0x3FFFFF + 1, 6);
-        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert!(codec.encode(bytes.into(), &mut buf).is_ok());
         let buf_saved = buf.clone();
         assert_eq!(buf.len(), 0x3FFFFF + 4 + 1);
         if let Ok(Some(res)) = codec.decode(&mut buf) {
             assert_eq!(res.len(), 0x3FFFFF + 1);
             assert_eq!(res[0], 6);
         } else {
-            assert!(false);
+            panic!();
         }
         let mut codec2 = BytesCodec::new();
         let mut buf2 = BytesMut::new();
         buf2.extend(&buf_saved[0..1]);
         if let Ok(None) = codec2.decode(&mut buf2) {
         } else {
-            assert!(false);
+            panic!();
         }
         buf2.extend(&buf_saved[1..6]);
         if let Ok(None) = codec2.decode(&mut buf2) {
         } else {
-            assert!(false);
+            panic!();
         }
         buf2.extend(&buf_saved[6..]);
         if let Ok(Some(res)) = codec2.decode(&mut buf2) {
             assert_eq!(res.len(), 0x3FFFFF + 1);
             assert_eq!(res[0], 6);
         } else {
-            assert!(false);
+            panic!();
         }
     }
 }

libs/hbb_common/src/config.rs

@@ -525,7 +525,7 @@ impl Config {
             let mut path: PathBuf = format!("/tmp/{}", *APP_NAME.read().unwrap()).into();
             fs::create_dir(&path).ok();
             fs::set_permissions(&path, fs::Permissions::from_mode(0o0777)).ok();
-            path.push(format!("ipc{}", postfix));
+            path.push(format!("ipc{postfix}"));
             path.to_str().unwrap_or("").to_owned()
         }
     }
@@ -562,7 +562,7 @@ impl Config {
                 .unwrap_or_default();
         }
         if !rendezvous_server.contains(':') {
-            rendezvous_server = format!("{}:{}", rendezvous_server, RENDEZVOUS_PORT);
+            rendezvous_server = format!("{rendezvous_server}:{RENDEZVOUS_PORT}");
         }
         rendezvous_server
     }

libs/hbb_common/src/lib.rs

@@ -212,8 +212,7 @@ pub fn gen_version() {
     let build_date = format!("{}", chrono::Local::now().format("%Y-%m-%d %H:%M"));
     file.write_all(
         format!(
-            "#[allow(dead_code)]\npub const BUILD_DATE: &str = \"{}\";",
-            build_date
+            "#[allow(dead_code)]\npub const BUILD_DATE: &str = \"{build_date}\"\n;"
         )
         .as_bytes(),
     )
@@ -342,39 +341,39 @@ mod test {
 
     #[test]
     fn test_ipv6() {
-        assert_eq!(is_ipv6_str("1:2:3"), true);
-        assert_eq!(is_ipv6_str("[ab:2:3]:12"), true);
-        assert_eq!(is_ipv6_str("[ABEF:2a:3]:12"), true);
-        assert_eq!(is_ipv6_str("[ABEG:2a:3]:12"), false);
-        assert_eq!(is_ipv6_str("1[ab:2:3]:12"), false);
-        assert_eq!(is_ipv6_str("1.1.1.1"), false);
-        assert_eq!(is_ip_str("1.1.1.1"), true);
-        assert_eq!(is_ipv6_str("1:2:"), false);
-        assert_eq!(is_ipv6_str("1:2::0"), true);
-        assert_eq!(is_ipv6_str("[1:2::0]:1"), true);
-        assert_eq!(is_ipv6_str("[1:2::0]:"), false);
-        assert_eq!(is_ipv6_str("1:2::0]:1"), false);
+        assert!(is_ipv6_str("1:2:3"));
+        assert!(is_ipv6_str("[ab:2:3]:12"));
+        assert!(is_ipv6_str("[ABEF:2a:3]:12"));
+        assert!(!is_ipv6_str("[ABEG:2a:3]:12"));
+        assert!(!is_ipv6_str("1[ab:2:3]:12"));
+        assert!(!is_ipv6_str("1.1.1.1"));
+        assert!(is_ip_str("1.1.1.1"));
+        assert!(!is_ipv6_str("1:2:"));
+        assert!(is_ipv6_str("1:2::0"));
+        assert!(is_ipv6_str("[1:2::0]:1"));
+        assert!(!is_ipv6_str("[1:2::0]:"));
+        assert!(!is_ipv6_str("1:2::0]:1"));
     }
 
     #[test]
     fn test_hostname_port() {
-        assert_eq!(is_domain_port_str("a:12"), false);
-        assert_eq!(is_domain_port_str("a.b.c:12"), false);
-        assert_eq!(is_domain_port_str("test.com:12"), true);
-        assert_eq!(is_domain_port_str("test-UPPER.com:12"), true);
-        assert_eq!(is_domain_port_str("some-other.domain.com:12"), true);
-        assert_eq!(is_domain_port_str("under_score:12"), false);
-        assert_eq!(is_domain_port_str("a@bc:12"), false);
-        assert_eq!(is_domain_port_str("1.1.1.1:12"), false);
-        assert_eq!(is_domain_port_str("1.2.3:12"), false);
-        assert_eq!(is_domain_port_str("1.2.3.45:12"), false);
-        assert_eq!(is_domain_port_str("a.b.c:123456"), false);
-        assert_eq!(is_domain_port_str("---:12"), false);
-        assert_eq!(is_domain_port_str(".:12"), false);
+        assert!(!is_domain_port_str("a:12"));
+        assert!(!is_domain_port_str("a.b.c:12"));
+        assert!(is_domain_port_str("test.com:12"));
+        assert!(is_domain_port_str("test-UPPER.com:12"));
+        assert!(is_domain_port_str("some-other.domain.com:12"));
+        assert!(!is_domain_port_str("under_score:12"));
+        assert!(!is_domain_port_str("a@bc:12"));
+        assert!(!is_domain_port_str("1.1.1.1:12"));
+        assert!(!is_domain_port_str("1.2.3:12"));
+        assert!(!is_domain_port_str("1.2.3.45:12"));
+        assert!(!is_domain_port_str("a.b.c:123456"));
+        assert!(!is_domain_port_str("---:12"));
+        assert!(!is_domain_port_str(".:12"));
         // todo: should we also check for these edge cases?
         // out-of-range port
-        assert_eq!(is_domain_port_str("test.com:0"), true);
-        assert_eq!(is_domain_port_str("test.com:98989"), true);
+        assert!(is_domain_port_str("test.com:0"));
+        assert!(is_domain_port_str("test.com:98989"));
     }
 
     #[test]

libs/hbb_common/src/password_security.rs

@@ -192,51 +192,51 @@ mod test {
         let data = "Hello World";
         let encrypted = encrypt_str_or_original(data, version);
         let (decrypted, succ, store) = decrypt_str_or_original(&encrypted, version);
-        println!("data: {}", data);
-        println!("encrypted: {}", encrypted);
-        println!("decrypted: {}", decrypted);
+        println!("data: {data}");
+        println!("encrypted: {encrypted}");
+        println!("decrypted: {decrypted}");
         assert_eq!(data, decrypted);
         assert_eq!(version, &encrypted[..2]);
-        assert_eq!(succ, true);
-        assert_eq!(store, false);
+        assert!(succ);
+        assert!(!store);
         let (_, _, store) = decrypt_str_or_original(&encrypted, "99");
-        assert_eq!(store, true);
-        assert_eq!(decrypt_str_or_original(&decrypted, version).1, false);
+        assert!(store);
+        assert!(!decrypt_str_or_original(&decrypted, version).1);
         assert_eq!(encrypt_str_or_original(&encrypted, version), encrypted);
 
         println!("test vec");
         let data: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
         let encrypted = encrypt_vec_or_original(&data, version);
         let (decrypted, succ, store) = decrypt_vec_or_original(&encrypted, version);
-        println!("data: {:?}", data);
-        println!("encrypted: {:?}", encrypted);
-        println!("decrypted: {:?}", decrypted);
+        println!("data: {data:?}");
+        println!("encrypted: {encrypted:?}");
+        println!("decrypted: {decrypted:?}");
         assert_eq!(data, decrypted);
         assert_eq!(version.as_bytes(), &encrypted[..2]);
-        assert_eq!(store, false);
-        assert_eq!(succ, true);
+        assert!(!store);
+        assert!(succ);
         let (_, _, store) = decrypt_vec_or_original(&encrypted, "99");
-        assert_eq!(store, true);
-        assert_eq!(decrypt_vec_or_original(&decrypted, version).1, false);
+        assert!(store);
+        assert!(!decrypt_vec_or_original(&decrypted, version).1);
         assert_eq!(encrypt_vec_or_original(&encrypted, version), encrypted);
 
         println!("test original");
         let data = version.to_string() + "Hello World";
         let (decrypted, succ, store) = decrypt_str_or_original(&data, version);
         assert_eq!(data, decrypted);
-        assert_eq!(store, true);
-        assert_eq!(succ, false);
+        assert!(store);
+        assert!(!succ);
         let verbytes = version.as_bytes();
-        let data: Vec<u8> = vec![verbytes[0] as u8, verbytes[1] as u8, 1, 2, 3, 4, 5, 6];
+        let data: Vec<u8> = vec![verbytes[0], verbytes[1], 1, 2, 3, 4, 5, 6];
         let (decrypted, succ, store) = decrypt_vec_or_original(&data, version);
         assert_eq!(data, decrypted);
-        assert_eq!(store, true);
-        assert_eq!(succ, false);
+        assert!(store);
+        assert!(!succ);
         let (_, succ, store) = decrypt_str_or_original("", version);
-        assert_eq!(store, false);
-        assert_eq!(succ, false);
-        let (_, succ, store) = decrypt_vec_or_original(&vec![], version);
-        assert_eq!(store, false);
-        assert_eq!(succ, false);
+        assert!(!store);
+        assert!(!succ);
+        let (_, succ, store) = decrypt_vec_or_original(&[], version);
+        assert!(!store);
+        assert!(!succ);
     }
 }

libs/hbb_common/src/socket_client.rs

@@ -13,22 +13,22 @@ use tokio_socks::{IntoTargetAddr, TargetAddr};
 pub fn check_port<T: std::string::ToString>(host: T, port: i32) -> String {
     let host = host.to_string();
     if crate::is_ipv6_str(&host) {
-        if host.starts_with("[") {
+        if host.starts_with('[') {
             return host;
         }
-        return format!("[{}]:{}", host, port);
+        return format!("[{host}]:{port}");
     }
-    if !host.contains(":") {
-        return format!("{}:{}", host, port);
+    if !host.contains(':') {
+        return format!("{host}:{port}");
     }
-    return host;
+    host
 }
 
 #[inline]
 pub fn increase_port<T: std::string::ToString>(host: T, offset: i32) -> String {
     let host = host.to_string();
     if crate::is_ipv6_str(&host) {
-        if host.starts_with("[") {
+        if host.starts_with('[') {
             let tmp: Vec<&str> = host.split("]:").collect();
             if tmp.len() == 2 {
                 let port: i32 = tmp[1].parse().unwrap_or(0);
@@ -37,8 +37,8 @@ pub fn increase_port<T: std::string::ToString>(host: T, offset: i32) -> String {
                 }
             }
         }
-    } else if host.contains(":") {
-        let tmp: Vec<&str> = host.split(":").collect();
+    } else if host.contains(':') {
+        let tmp: Vec<&str> = host.split(':').collect();
         if tmp.len() == 2 {
             let port: i32 = tmp[1].parse().unwrap_or(0);
             if port > 0 {
@@ -46,7 +46,7 @@ pub fn increase_port<T: std::string::ToString>(host: T, offset: i32) -> String {
             }
         }
     }
-    return host;
+    host
 }
 
 pub fn test_if_valid_server(host: &str) -> String {
@@ -148,7 +148,7 @@ pub async fn query_nip_io(addr: &SocketAddr) -> ResultType<SocketAddr> {
 pub fn ipv4_to_ipv6(addr: String, ipv4: bool) -> String {
     if !ipv4 && crate::is_ipv4_str(&addr) {
         if let Some(ip) = addr.split(':').next() {
-            return addr.replace(ip, &format!("{}.nip.io", ip));
+            return addr.replace(ip, &format!("{ip}.nip.io"));
         }
     }
     addr
@@ -163,7 +163,7 @@ async fn test_target(target: &str) -> ResultType<SocketAddr> {
     tokio::net::lookup_host(target)
         .await?
         .next()
-        .context(format!("Failed to look up host for {}", target))
+        .context(format!("Failed to look up host for {target}"))
 }
 
 #[inline]

libs/hbb_common/src/tcp.rs

@@ -100,7 +100,7 @@ impl FramedStream {
                 }
             }
         }
-        bail!(format!("Failed to connect to {}", remote_addr));
+        bail!(format!("Failed to connect to {remote_addr}"));
     }
 
     pub async fn connect<'a, 't, P, T>(

src/lib.rs

@@ -3,5 +3,4 @@ pub use rendezvous_server::*;
 pub mod common;
 mod database;
 mod peer;
-#[rustfmt::skip]
 mod version;