fix bugs and improve user experiance (#86)

* correctly set mtu, and allow set mtu manually

* communicate between enc and non-enc should not panic

* allow loading cfg from file

* allow change file log level dynamically

easytier/src/peers/encrypt/aes_gcm.rs

@@ -38,7 +38,7 @@ impl Encryptor for AesGcmCipher {
     fn decrypt(&self, zc_packet: &mut ZCPacket) -> Result<(), Error> {
         let pm_header = zc_packet.peer_manager_header().unwrap();
         if !pm_header.is_encrypted() {
-            return Err(Error::NotEcrypted);
+            return Ok(());
         }
 
         let payload_len = zc_packet.payload().len();

easytier/src/peers/encrypt/mod.rs

@@ -8,8 +8,6 @@ pub mod aes_gcm;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
-    #[error("packet is not encrypted")]
-    NotEcrypted,
     #[error("packet is too short. len: {0}")]
     PacketTooShort(usize),
     #[error("decryption failed")]
@@ -32,7 +30,12 @@ impl Encryptor for NullCipher {
         Ok(())
     }
 
-    fn decrypt(&self, _zc_packet: &mut ZCPacket) -> Result<(), Error> {
-        Ok(())
+    fn decrypt(&self, zc_packet: &mut ZCPacket) -> Result<(), Error> {
+        let pm_header = zc_packet.peer_manager_header().unwrap();
+        if pm_header.is_encrypted() {
+            return Err(Error::DecryptionFailed);
+        } else {
+            Ok(())
+        }
     }
 }

easytier/src/peers/encrypt/ring_aes_gcm.rs

@@ -54,7 +54,7 @@ impl Encryptor for AesGcmCipher {
     fn decrypt(&self, zc_packet: &mut ZCPacket) -> Result<(), Error> {
         let pm_header = zc_packet.peer_manager_header().unwrap();
         if !pm_header.is_encrypted() {
-            return Err(Error::NotEcrypted);
+            return Ok(());
         }
 
         let payload_len = zc_packet.payload().len();

easytier/src/peers/peer_manager.rs

@@ -338,11 +338,9 @@ impl PeerManager {
                         tracing::error!(?ret, ?to_peer_id, ?from_peer_id, "forward packet error");
                     }
                 } else {
-                    if let Err(e) = encryptor
-                        .decrypt(&mut ret)
-                        .with_context(|| "decrypt failed")
-                    {
+                    if let Err(e) = encryptor.decrypt(&mut ret) {
                         tracing::error!(?e, "decrypt failed");
+                        continue;
                     }
 
                     let mut processed = false;
@@ -680,14 +678,16 @@ impl PeerManager {
 #[cfg(test)]
 mod tests {
 
-    use std::{fmt::Debug, sync::Arc};
+    use std::{fmt::Debug, sync::Arc, time::Duration};
 
     use crate::{
+        common::{config::Flags, global_ctx::tests::get_mock_global_ctx},
         connector::{
             create_connector_by_url, udp_hole_punch::tests::create_mock_peer_manager_with_mock_stun,
         },
         instance::listeners::get_listener_by_url,
         peers::{
+            peer_manager::RouteAlgoType,
             peer_rpc::tests::{MockService, TestRpcService, TestRpcServiceClient},
             tests::{connect_peer_manager, wait_for_condition, wait_route_appear},
         },
@@ -822,4 +822,36 @@ mod tests {
             .unwrap();
         assert_eq!(ret, "hello c abc");
     }
+
+    #[tokio::test]
+    async fn communicate_between_enc_and_non_enc() {
+        let create_mgr = |enable_encryption| async move {
+            let (s, _r) = tokio::sync::mpsc::channel(1000);
+            let mock_global_ctx = get_mock_global_ctx();
+            mock_global_ctx.config.set_flags(Flags {
+                enable_encryption,
+                ..Default::default()
+            });
+            let peer_mgr = Arc::new(PeerManager::new(RouteAlgoType::Ospf, mock_global_ctx, s));
+            peer_mgr.run().await.unwrap();
+            peer_mgr
+        };
+
+        let peer_mgr_a = create_mgr(true).await;
+        let peer_mgr_b = create_mgr(false).await;
+
+        connect_peer_manager(peer_mgr_a.clone(), peer_mgr_b.clone()).await;
+
+        // wait 5sec should not crash.
+        tokio::time::sleep(Duration::from_secs(5)).await;
+
+        // both mgr should alive
+        let mgr_c = create_mgr(true).await;
+        connect_peer_manager(peer_mgr_a.clone(), mgr_c.clone()).await;
+        wait_route_appear(mgr_c, peer_mgr_a).await.unwrap();
+
+        let mgr_d = create_mgr(false).await;
+        connect_peer_manager(peer_mgr_b.clone(), mgr_d.clone()).await;
+        wait_route_appear(mgr_d, peer_mgr_b).await.unwrap();
+    }
 }