diff --git a/src/client.rs b/src/client.rs
index a762094..05743c3 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -88,7 +88,7 @@ pub async fn client_mode(client_config: ClientConfiguration) {
 
     tokio::spawn(async move {
         while let Ok(bytes) = rx.recv() {
-            info!("Write to tun {:?}", hex::encode(&bytes));
+            //info!("Write to tun {:?}", hex::encode(&bytes));
             dev_writer.write_all(&bytes).unwrap();
         }
     });
@@ -124,7 +124,6 @@ pub async fn client_mode(client_config: ClientConfiguration) {
                                 }
                                 *s_cipher = Some(StaticSecret::from(k1)
                                     .diffie_hellman(&PublicKey::from(k)));
-                                // Aes256Gcm::new(shared_secret.as_bytes().into());
                             }, // handshake
                             1 => {
                                 let wrapped_packet = UDPVpnPacket::deserialize(&(buf[..l].to_vec()));
@@ -162,13 +161,11 @@ pub async fn client_mode(client_config: ClientConfiguration) {
             if s_c.is_some() {
                 let aes = Aes256Gcm::new(s_c.as_ref().unwrap().as_bytes().into());
                 let nonce = Aes256Gcm::generate_nonce(&mut OsRng);
-                info!("Key {:?} / nonce {:?}", s_c.as_ref().unwrap().as_bytes(), &nonce.bytes());
                 let ciphered_data = aes.encrypt(&nonce, &bytes[..]);
                 
                 if let Ok(ciphered_d) = ciphered_data {
                     let vpn_packet = UDPVpnPacket{ data: ciphered_d, nonce: nonce.to_vec()};
                     let serialized_data = vpn_packet.serialize();
-                    info!("Writing to sock: {:?}", serialized_data);
                     sock_snd.send(&serialized_data).await.unwrap();
                 } else {
                     error!("Socket encryption failed.");
diff --git a/src/server.rs b/src/server.rs
index f8edc0c..12652a0 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -49,9 +49,10 @@ pub async fn server_mode(server_config: ServerConfiguration) {
     let addrs_lcl = addresses.clone();
     if keepalive_sec > 0 {
         tokio::spawn(async move {
+            let kp_sc = keepalive_sec.clone();
             loop {
-                time::sleep(time::Duration::from_secs(3)).await;
-                let mut mmp = addrs_lcl.lock().await;
+                time::sleep(time::Duration::from_secs(kp_sc.into())).await;
+                let mmp = addrs_lcl.lock().await;
                 mmp.values().for_each(|p| {
                     let _ = send2hnd_cl.send((UDPKeepAlive{}.serialize(), p.addr));
                 });
@@ -113,9 +114,8 @@ pub async fn server_mode(server_config: ServerConfiguration) {
                 Some(h) => {
                     match h {
                         0 => {
-                            // (&buf[1..len]).to_vec()
                             let handshake = UDPVpnHandshake::deserialize(&buf);
-                            info!("Got handshake! ip: {:?}; key: {:?}", handshake.request_ip, BASE64_STANDARD.encode(&handshake.public_key));
+                            info!("Got handshake from {:?}", handshake.request_ip);
                             let skey = BASE64_STANDARD.encode(&handshake.public_key);
                             if plp.iter().any(|c| c.ip == handshake.request_ip && c.public_key == skey) {
                                 let internal_ip = IpAddr::V4(handshake.request_ip);
@@ -138,13 +138,12 @@ pub async fn server_mode(server_config: ServerConfiguration) {
                                 let _ = send2hnd.send((handshake_response.serialize(), addr));
                             } else {
                                 info!("Bad handshake");
-                                plp.iter().for_each(|c| info!("ip: {:?}; pkey: {:?}", c.ip, c.public_key));
+                                //plp.iter().for_each(|c| info!("ip: {:?}; pkey: {:?}", c.ip, c.public_key));
                             }
                         }, // handshake
                         1 => {
                             let packet = UDPVpnPacket::deserialize(&(buf[..len].to_vec()));
                             mp.values().filter(| p | p.addr == addr).for_each(|p| {
-                                info!("Key {:?} / nonce {:?}", &p.shared_secret, &packet.nonce);
                                 let aes = Aes256Gcm::new(&p.shared_secret.into());
                                 let nonce = Nonce::clone_from_slice(&packet.nonce[..]);
                                 match aes.decrypt(&nonce, &packet.data[..]) {