diff --git a/smb/src/protocol/body/create/mod.rs b/smb/src/protocol/body/create/mod.rs
index 5281546..6f8b8c8 100644
--- a/smb/src/protocol/body/create/mod.rs
+++ b/smb/src/protocol/body/create/mod.rs
@@ -112,7 +112,7 @@ impl SMBCreateRequest {
             // TODO make this the right error code
             return Err(SMBError::response_error(NTStatus::NotSupported));
         }
-        Ok((&self.file_name(), self.disposition(), self.create_options.contains(SMBCreateOptions::DIRECTORY_FILE)))
+        Ok((self.file_name(), self.disposition(), self.create_options.contains(SMBCreateOptions::DIRECTORY_FILE)))
     }
 }
 
diff --git a/smb/src/protocol/body/error/mod.rs b/smb/src/protocol/body/error/mod.rs
index e1f0c4a..7e9a02b 100644
--- a/smb/src/protocol/body/error/mod.rs
+++ b/smb/src/protocol/body/error/mod.rs
@@ -34,6 +34,16 @@ pub struct SMBErrorResponse {
     error_data: PhantomData<Vec<u8>>,
 }
 
+impl Default for SMBErrorResponse {
+    fn default() -> Self {
+        Self {
+            reserved: PhantomData,
+            byte_count: PhantomData,
+            error_data: PhantomData,
+        }
+    }
+}
+
 impl SMBErrorResponse {
     pub fn new() -> Self {
         Self {
diff --git a/smb/src/protocol/body/filetime.rs b/smb/src/protocol/body/filetime.rs
index 60d91c4..ac51b51 100644
--- a/smb/src/protocol/body/filetime.rs
+++ b/smb/src/protocol/body/filetime.rs
@@ -18,7 +18,7 @@ const TIME_SINCE_1601_AND_EPOCH: u64 = 11644473600000;
 
 impl FileTime {
     pub fn from_unix(unix_timestamp: u64) -> Self {
-        let filetype_normalized = unix_timestamp + TIME_SINCE_1601_AND_EPOCH as u64;
+        let filetype_normalized = unix_timestamp + TIME_SINCE_1601_AND_EPOCH;
         let bytes = u64_to_bytes(filetype_normalized);
         FileTime {
             low_date_time: bytes_to_u32(&bytes[0..4]),
diff --git a/smb/src/protocol/body/negotiate/mod.rs b/smb/src/protocol/body/negotiate/mod.rs
index 22ffb2e..e0ad207 100644
--- a/smb/src/protocol/body/negotiate/mod.rs
+++ b/smb/src/protocol/body/negotiate/mod.rs
@@ -1,4 +1,3 @@
-use std::any::Any;
 use std::collections::HashSet;
 use std::marker::PhantomData;
 
@@ -62,7 +61,7 @@ impl SMBNegotiateRequest {
             return Err(SMBError::response_error(NTStatus::InvalidParameter));
         }
         let mut update = SMBConnectionUpdate::default();
-        let mut received_ctxs = HashSet::new();
+        let received_ctxs = HashSet::new();
         // TODO: uncomment after signing is fixed + working
         // for context in self.negotiate_contexts.iter() {
         //     let (change, actual) = context.validate_and_set_state(update, server)?;
@@ -104,7 +103,7 @@ impl SMBNegotiateRequest {
         let dialect = SMBDialect::V2_1_0;
         let preauth_value = if dialect == SMBDialect::V3_1_1 {
             let mut sha = Sha512::default();
-            sha.update(&self.smb_to_bytes());
+            sha.update(self.smb_to_bytes());
             sha.finalize().to_vec()
         } else {
             Vec::new()
diff --git a/smb/src/protocol/body/session_setup/mod.rs b/smb/src/protocol/body/session_setup/mod.rs
index 790a9af..253858b 100644
--- a/smb/src/protocol/body/session_setup/mod.rs
+++ b/smb/src/protocol/body/session_setup/mod.rs
@@ -20,7 +20,6 @@ use crate::server::preauth_session::SMBPreauthSession;
 use crate::server::Server;
 use crate::server::session::{Session, SessionState};
 use crate::socket::message_stream::{SMBReadStream, SMBWriteStream};
-use crate::util::auth::AuthProvider;
 
 pub mod security_mode;
 pub mod flags;
@@ -98,7 +97,7 @@ impl SMBSessionSetupRequest {
             if connection.dialect() == SMBDialect::V3_1_1 && !connection.preauth_sessions().contains_key(&session.id()) {
                 let mut sha = Sha512::default();
                 sha.update(connection.preauth_integtiry_hash_value());
-                sha.update(&self.smb_to_bytes());
+                sha.update(self.smb_to_bytes());
                 let bytes = sha.finalize().to_vec();
                 let preauth_session = SMBPreauthSession::new(session.id(), bytes);
                 update = update.preauth_session_table(HashMap::from([(session.id(), preauth_session)]));
@@ -152,7 +151,7 @@ impl SMBSessionSetupResponse {
         }
     }
 
-    pub fn from_request(request: SMBSessionSetupRequest, token: Vec<u8>) -> Option<Self> {
+    pub fn from_request(_request: SMBSessionSetupRequest, token: Vec<u8>) -> Option<Self> {
         Some(Self {
             session_flags: SMBSessionFlags::empty(),
             buffer: token,
diff --git a/smb/src/protocol/body/tree_connect/access_mask.rs b/smb/src/protocol/body/tree_connect/access_mask.rs
index 131dd97..1c09d99 100644
--- a/smb/src/protocol/body/tree_connect/access_mask.rs
+++ b/smb/src/protocol/body/tree_connect/access_mask.rs
@@ -49,7 +49,7 @@ impl SMBAccessMask {
     }
 
     pub fn from_desired_access(desired: &SMBAccessMask) -> Self {
-        let mut mask = desired.clone();
+        let mask = desired.clone();
         if mask.includes_maximum_allowed() {
             match mask {
                 SMBAccessMask::FilePipePrinter(mut x) => x |= SMBFilePipePrinterAccessMask::GENERIC_ALL,
diff --git a/smb/src/protocol/body/tree_connect/context.rs b/smb/src/protocol/body/tree_connect/context.rs
index 6ac76c0..e1f5881 100644
--- a/smb/src/protocol/body/tree_connect/context.rs
+++ b/smb/src/protocol/body/tree_connect/context.rs
@@ -22,7 +22,7 @@ impl SMBByteSize for SMBTreeConnectContext {
 
 impl SMBFromBytes for SMBTreeConnectContext {
     fn smb_from_bytes(input: &[u8]) -> SMBParseResult<&[u8], Self> where Self: Sized {
-        let (remaining, ctx_type) = u16::smb_from_bytes(input)?;
+        let (_remaining, ctx_type) = u16::smb_from_bytes(input)?;
         match ctx_type {
             0x01 => {
                 let (remaining, identity) = RemotedIdentity::smb_from_bytes(input)?;
diff --git a/smb/src/protocol/body/tree_connect/mod.rs b/smb/src/protocol/body/tree_connect/mod.rs
index 958192a..752b01d 100644
--- a/smb/src/protocol/body/tree_connect/mod.rs
+++ b/smb/src/protocol/body/tree_connect/mod.rs
@@ -82,7 +82,7 @@ impl Default for SMBTreeConnectResponse {
 }
 
 impl SMBTreeConnectResponse {
-    pub fn IPC() -> Self {
+    pub fn ipc() -> Self {
         Self {
             maximal_access: SMBAccessMask::FilePipePrinter(SMBFilePipePrinterAccessMask::from_bits_truncate(2032127)),
             share_type: SMBShareType::Pipe,
@@ -113,19 +113,14 @@ impl SMBTreeConnectResponse {
 }
 
 #[repr(u8)]
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Copy, Clone, SMBByteSize, SMBFromBytes, SMBToBytes, TryFromPrimitive)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Copy, Clone, SMBByteSize, SMBFromBytes, SMBToBytes, TryFromPrimitive, Default)]
 pub enum SMBShareType {
+    #[default]
     Disk = 0x01,
     Pipe,
     Print,
 }
 
-impl Default for SMBShareType {
-    fn default() -> Self {
-        Self::Disk
-    }
-}
-
 impl_smb_byte_size_for_bitflag! {
     SMBTreeConnectFlags
     SMBShareFlags
diff --git a/smb/src/protocol/header/command_code.rs b/smb/src/protocol/header/command_code.rs
index a5f337e..8eb68e8 100644
--- a/smb/src/protocol/header/command_code.rs
+++ b/smb/src/protocol/header/command_code.rs
@@ -28,9 +28,9 @@ pub enum SMBCommandCode {
     LegacyNegotiate
 }
 
-impl Into<u64> for SMBCommandCode {
-    fn into(self) -> u64 {
-        self as u16 as u64
+impl From<SMBCommandCode> for u64 {
+    fn from(val: SMBCommandCode) -> Self {
+        val as u16 as u64
     }
 }
 
@@ -110,9 +110,9 @@ pub enum LegacySMBCommandCode {
     WriteBulkData
 }
 
-impl Into<u64> for LegacySMBCommandCode {
-    fn into(self) -> u64 {
-        self as u8 as u64
+impl From<LegacySMBCommandCode> for u64 {
+    fn from(val: LegacySMBCommandCode) -> Self {
+        val as u8 as u64
     }
 }
 
diff --git a/smb/src/server/connection.rs b/smb/src/server/connection.rs
index faef8c9..6d7616c 100644
--- a/smb/src/server/connection.rs
+++ b/smb/src/server/connection.rs
@@ -436,6 +436,7 @@ impl<R: SMBReadStream, W: SMBWriteStream, S: Server<Connection=Self>> SMBConnect
 }
 
 type LockedSMBConnection<R, W, S> = Arc<RwLock<SMBConnection<R, W, S>>>;
+pub type WeakLockedSMBConnection<R, W, S> = Weak<RwLock<SMBConnection<R, W, S>>>;
 
 impl<R: SMBReadStream, W: SMBWriteStream, S: Server<Connection=Self>> InnerGetter for SMBConnection<R, W, S> {
     type Upper = S;
diff --git a/smb/src/server/lease.rs b/smb/src/server/lease.rs
index ec59052..c06538d 100644
--- a/smb/src/server/lease.rs
+++ b/smb/src/server/lease.rs
@@ -9,6 +9,7 @@ use crate::server::Server;
 
 pub trait Lease: Send + Sync {}
 
+
 #[derive(Debug)]
 pub struct SMBLeaseTable<L: Lease> {
     client_guid: Uuid,
diff --git a/smb/src/server/message_handler.rs b/smb/src/server/message_handler.rs
index 92ffb97..50f0a2b 100644
--- a/smb/src/server/message_handler.rs
+++ b/smb/src/server/message_handler.rs
@@ -1,7 +1,7 @@
 use std::future::Future;
 
 use smb_core::error::SMBError;
-use smb_core::logging::{trace, debug, warn};
+use smb_core::logging::{trace, debug};
 use smb_core::nt_status::NTStatus;
 use smb_core::SMBResult;
 
@@ -75,87 +75,87 @@ pub trait SMBLockedMessageHandlerBase {
                 SMBBody::ErrorResponse(_) => {
                     let status = NTStatus::try_from(message.header.channel_sequence)
                         .unwrap_or(NTStatus::NotSupported);
-                    return Err(SMBError::response_error(status));
+                    Err(SMBError::response_error(status))
                 },
                 _ => Err(SMBError::server_error("Command not implemented")),
             }
         }
     }
 
-    fn handle_negotiate(&mut self, header: &SMBSyncHeader, message: &SMBNegotiateRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_negotiate(&mut self, _header: &SMBSyncHeader, _message: &SMBNegotiateRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_session_setup(&mut self, header: &SMBSyncHeader, message: &SMBSessionSetupRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_session_setup(&mut self, _header: &SMBSyncHeader, _message: &SMBSessionSetupRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_logoff(&mut self, header: &SMBSyncHeader, message: &SMBLogoffRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_logoff(&mut self, _header: &SMBSyncHeader, _message: &SMBLogoffRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_tree_connect(&mut self, header: &SMBSyncHeader, message: &SMBTreeConnectRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_tree_connect(&mut self, _header: &SMBSyncHeader, _message: &SMBTreeConnectRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_tree_disconnect(&mut self, header: &SMBSyncHeader, message: &SMBTreeDisconnectRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_tree_disconnect(&mut self, _header: &SMBSyncHeader, _message: &SMBTreeDisconnectRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_create(&mut self, header: &SMBSyncHeader, message: &SMBCreateRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_create(&mut self, _header: &SMBSyncHeader, _message: &SMBCreateRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         debug!("create request, passing to next handler");
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_close(&mut self, header: &SMBSyncHeader, message: &SMBCloseRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_close(&mut self, _header: &SMBSyncHeader, _message: &SMBCloseRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_flush(&mut self, header: &SMBSyncHeader, message: &SMBFlushRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_flush(&mut self, _header: &SMBSyncHeader, _message: &SMBFlushRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_read(&mut self, header: &SMBSyncHeader, message: &SMBReadRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_read(&mut self, _header: &SMBSyncHeader, _message: &SMBReadRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_write(&mut self, header: &SMBSyncHeader, message: &SMBWriteRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_write(&mut self, _header: &SMBSyncHeader, _message: &SMBWriteRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_lock(&mut self, header: &SMBSyncHeader, message: &SMBLockRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_lock(&mut self, _header: &SMBSyncHeader, _message: &SMBLockRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_ioctl(&mut self, header: &SMBSyncHeader, message: &SMBIoCtlRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_ioctl(&mut self, _header: &SMBSyncHeader, _message: &SMBIoCtlRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_cancel(&mut self, header: &SMBSyncHeader, message: &SMBCancelRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_cancel(&mut self, _header: &SMBSyncHeader, _message: &SMBCancelRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_echo(&mut self, header: &SMBSyncHeader, message: &SMBEchoRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_echo(&mut self, _header: &SMBSyncHeader, _message: &SMBEchoRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_query_directory(&mut self, header: &SMBSyncHeader, message: &SMBQueryDirectoryRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_query_directory(&mut self, _header: &SMBSyncHeader, _message: &SMBQueryDirectoryRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_change_notify(&mut self, header: &SMBSyncHeader, message: &SMBChangeNotifyRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_change_notify(&mut self, _header: &SMBSyncHeader, _message: &SMBChangeNotifyRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_query_info(&mut self, header: &SMBSyncHeader, message: &SMBQueryInfoRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_query_info(&mut self, _header: &SMBSyncHeader, _message: &SMBQueryInfoRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_set_info(&mut self, header: &SMBSyncHeader, message: &SMBSetInfoRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_set_info(&mut self, _header: &SMBSyncHeader, _message: &SMBSetInfoRequest) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 
-    fn handle_oplock_break(&mut self, header: &SMBSyncHeader, message: &SMBOplockBreakAcknowledgement) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
+    fn handle_oplock_break(&mut self, _header: &SMBSyncHeader, _message: &SMBOplockBreakAcknowledgement) -> impl Future<Output=SMBResult<SMBHandlerState<Self::Inner>>> {
         async { Ok(SMBHandlerState::Next(None)) }
     }
 }
diff --git a/smb/src/server/mod.rs b/smb/src/server/mod.rs
index a76e1a8..0dd240a 100644
--- a/smb/src/server/mod.rs
+++ b/smb/src/server/mod.rs
@@ -1,7 +1,8 @@
+use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::future::Future;
-use std::sync::{Arc, Weak};
+use std::sync::Arc;
 
 use derive_builder::Builder;
 use tokio::net::TcpListener;
@@ -16,11 +17,11 @@ use smb_core::SMBResult;
 use crate::protocol::body::dialect::SMBDialect;
 use crate::protocol::body::filetime::FileTime;
 use crate::server::client::SMBClient;
-use crate::server::connection::{Connection, SMBConnection};
+use crate::server::connection::{Connection, SMBConnection, WeakLockedSMBConnection};
 use crate::server::lease::{Lease, SMBLease, SMBLeaseTable};
-use crate::server::open::{Open, SMBOpen};
+use crate::server::open::{LockedSMBOpen, Open, SMBOpen};
 use crate::server::safe_locked_getter::InnerGetter;
-use crate::server::session::{Session, SMBSession};
+use crate::server::session::{LockedSMBSession, Session, SMBSession};
 use crate::server::share::{ConnectAllowed, FilePerms, ResourceHandle, SharedResource};
 use crate::server::share::file_system::{SMBFileSystemHandle, SMBFileSystemShare};
 use crate::server::share::ipc::{SMBIPCHandle, SMBIPCShare};
@@ -81,11 +82,6 @@ pub trait StartSMBServer {
 }
 
 type SMBConnectionType<Addr, L, A, S, H> = SMBConnection<<L as SMBSocket<Addr>>::ReadStream, <L as SMBSocket<Addr>>::WriteStream, SMBServer<Addr, L, A, S, H>>;
-
-type LockedWeakSMBConnection<Addr, L, A, S, H> = Weak<RwLock<SMBConnectionType<Addr, L, A, S, H>>>;
-type SMBSessionType<Addr, L, A, S, H> = SMBSession<SMBServer<Addr, L, A, S, H>>;
-type SMBOpenType<Addr, L, A, S, H> = SMBOpen<SMBServer<Addr, L, A, S, H>>;
-type SMBLeaseType<Addr, L, A, S, H> = SMBLease<SMBServer<Addr, L, A, S, H>>;
 type UserName<Auth> = <<Auth as AuthProvider>::Context as AuthContext>::UserName;
 pub type DefaultShare<Auth> = Box<dyn SharedResource<UserName=<<Auth as AuthProvider>::Context as AuthContext>::UserName, Handle=DefaultHandle>>;
 type DefaultHandle = Box<dyn ResourceHandle>;
@@ -100,17 +96,17 @@ pub struct SMBServer<Addrs: Send + Sync, Listener: SMBSocket<Addrs> = TcpListene
     #[builder(field(type = "HashMap<String, Arc<Share>>"))]
     share_list: HashMap<String, Arc<Share>>,
     #[builder(field(
-        type = "HashMap<u32, Arc<RwLock<SMBOpenType<Addrs, Listener, Auth, Share, Handle>>>>"
+        type = "HashMap<u32, LockedSMBOpen<SMBServer<Addrs, Listener, Auth, Share, Handle>>>"
     ))]
-    open_table: HashMap<u32, Arc<RwLock<SMBOpenType<Addrs, Listener, Auth, Share, Handle>>>>,
+    open_table: HashMap<u32, LockedSMBOpen<SMBServer<Addrs, Listener, Auth, Share, Handle>>>,
     #[builder(field(
-        type = "HashMap<u64, Arc<RwLock<SMBSessionType<Addrs, Listener, Auth, Share, Handle>>>>"
+        type = "HashMap<u64, LockedSMBSession<SMBServer<Addrs, Listener, Auth, Share, Handle>>>"
     ))]
-    session_table: HashMap<u64, Arc<RwLock<SMBSessionType<Addrs, Listener, Auth, Share, Handle>>>>,
+    session_table: HashMap<u64, LockedSMBSession<SMBServer<Addrs, Listener, Auth, Share, Handle>>>,
     #[builder(field(
-        type = "HashMap<String, LockedWeakSMBConnection<Addrs, Listener, Auth, Share, Handle>>"
+        type = "HashMap<String, WeakLockedSMBConnection<<Listener as SMBSocket<Addrs>>::ReadStream, <Listener as SMBSocket<Addrs>>::WriteStream, SMBServer<Addrs, Listener, Auth, Share, Handle>>>"
     ))]
-    connection_list: HashMap<String, LockedWeakSMBConnection<Addrs, Listener, Auth, Share, Handle>>,
+    connection_list: HashMap<String, WeakLockedSMBConnection<<Listener as SMBSocket<Addrs>>::ReadStream, <Listener as SMBSocket<Addrs>>::WriteStream, SMBServer<Addrs, Listener, Auth, Share, Handle>>>,
     #[builder(default = "Uuid::new_v4()")]
     guid: Uuid,
     #[builder(default = "FileTime::default()")]
@@ -126,9 +122,9 @@ pub struct SMBServer<Addrs: Send + Sync, Listener: SMBSocket<Addrs> = TcpListene
     #[builder(default = "HashLevel::EnableAll")]
     hash_level: HashLevel,
     #[builder(field(
-        type = "HashMap<Uuid, SMBLeaseTable<SMBLeaseType<Addrs, Listener, Auth, Share, Handle>>>"
+        type = "HashMap<Uuid, SMBLeaseTable<SMBLease<SMBServer<Addrs, Listener, Auth, Share, Handle>>>>"
     ))]
-    lease_table_list: HashMap<Uuid, SMBLeaseTable<SMBLeaseType<Addrs, Listener, Auth, Share, Handle>>>,
+    lease_table_list: HashMap<Uuid, SMBLeaseTable<SMBLease<SMBServer<Addrs, Listener, Auth, Share, Handle>>>>,
     #[builder(default = "5000")]
     max_resiliency_timeout: u64,
     #[builder(default = "5000")]
@@ -170,10 +166,10 @@ pub struct SMBServer<Addrs: Send + Sync, Listener: SMBSocket<Addrs> = TcpListene
 
 impl<Addrs: Send + Sync, Listener: SMBSocket<Addrs>, Auth: AuthProvider, Share: SharedResource<UserName=UserName<Auth>, Handle=Handle>, Handle: ResourceHandle> Server for SMBServer<Addrs, Listener, Auth, Share, Handle> {
     type Connection = SMBConnectionType<Addrs, Listener, Auth, Share, Handle>;
-    type Session = SMBSessionType<Addrs, Listener, Auth, Share, Handle>;
+    type Session = SMBSession<Self>;
     type Share = Share;
-    type Open = SMBOpenType<Addrs, Listener, Auth, Share, Handle>;
-    type Lease = SMBLeaseType<Addrs, Listener, Auth, Share, Handle>;
+    type Open = SMBOpen<Self>;
+    type Lease = SMBLease<Self>;
     type AuthProvider = Auth;
     type Handle = Handle; 
 
@@ -187,11 +183,11 @@ impl<Addrs: Send + Sync, Listener: SMBSocket<Addrs>, Auth: AuthProvider, Share:
 
     async fn add_open(&mut self, open: Arc<RwLock<Self::Open>>) -> u32 {
         for i in 0..u32::MAX {
-            if self.open_table.get(&i).is_none() {
+            if let Entry::Vacant(e) = self.open_table.entry(i) {
                 let mut open_wr = open.write().await;
                 open_wr.set_global_id(i);
                 drop(open_wr);
-                self.open_table.insert(i, open);
+                e.insert(open);
                 return i;
             }
         }
@@ -345,7 +341,7 @@ impl<
     Share: SharedResource<UserName=UserName<Auth>, Handle=Handle> + From<SMBFileSystemShare<UserName<Auth>, Handle>>,
     Handle: ResourceHandle + 'static + From<SMBFileSystemHandle> + TryInto<SMBFileSystemHandle>
 > SMBServerBuilder<Addrs, Listener, Auth, Share, Handle> {
-    pub fn add_fs_share(mut self, name: String, path: String, connect_allowed: ConnectAllowed<UserName<Auth>>, file_perms: FilePerms<UserName<Auth>>) -> Self {
+    pub fn add_fs_share(self, name: String, path: String, connect_allowed: ConnectAllowed<UserName<Auth>>, file_perms: FilePerms<UserName<Auth>>) -> Self {
         let share = SMBFileSystemShare::path(name.clone(), path, connect_allowed, file_perms);
         self.add_share(name, share.into())
     }
@@ -394,7 +390,7 @@ impl<Addrs: Send + Sync + 'static, Listener: SMBSocket<Addrs> + 'static, Auth: A
                 let mut stream = socket.lock().await;
                 match SMBConnection::start_message_handler::<Auth>(&mut stream, wrapped_connection, update_channel).await {
                     Ok(()) => debug!("message handler completed"),
-                    Err(ref e) => warn!(?e, "message handler exited with error"),
+                    Err(_e) => warn!(?e, "message handler exited with error"),
                 }
             });
         }
diff --git a/smb/src/server/open.rs b/smb/src/server/open.rs
index a3df216..c75e766 100644
--- a/smb/src/server/open.rs
+++ b/smb/src/server/open.rs
@@ -1,6 +1,7 @@
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 
+use tokio::sync::RwLock;
 use uuid::Uuid;
 
 use smb_core::SMBResult;
@@ -17,6 +18,8 @@ use crate::server::Server;
 use crate::server::share::{ResourceHandle, SMBFileMetadata};
 use crate::server::tree_connect::SMBTreeConnect;
 
+pub type LockedSMBOpen<S> = Arc<RwLock<SMBOpen<S>>>;
+
 pub trait Open: Send + Sync {
     type Server: Server;
     fn file_name(&self) -> &str;
@@ -145,6 +148,11 @@ impl<S: Server> Open for SMBOpen<S> {
         self.underlying.metadata()
     }
 }
+
+// TODO: From MS-FSCC section 2.6
+#[derive(Debug)]
+struct FileAttributes;
+
 #[derive(Debug)]
 pub enum SMBOplockState {
     Held,
diff --git a/smb/src/server/session.rs b/smb/src/server/session.rs
index 7e2cf87..719d90c 100644
--- a/smb/src/server/session.rs
+++ b/smb/src/server/session.rs
@@ -36,6 +36,7 @@ use crate::util::auth::spnego::{SPNEGOToken, SPNEGOTokenResponseBody};
 use crate::util::crypto::sp800_108::derive_key;
 use crate::util::num_limits::{MaxVal, MinVal, One, Zero};
 
+pub type LockedSMBSession<S> = Arc<RwLock<SMBSession<S>>>;
 type SMBMessageType = SMBMessage<SMBSyncHeader, SMBBody>;
 
 const _OUTPUT_SIZE_128: usize = 128;
diff --git a/smb/src/server/share/file_system.rs b/smb/src/server/share/file_system.rs
index 25d4417..9441b49 100644
--- a/smb/src/server/share/file_system.rs
+++ b/smb/src/server/share/file_system.rs
@@ -70,7 +70,7 @@ impl ResourceHandle for SMBFileSystemHandle {
     }
 
     fn metadata(&self) -> SMBResult<SMBFileMetadata> {
-        let metadata = fs::metadata(&self.path())
+        let metadata = fs::metadata(self.path())
             .map_err(|err| SMBError::server_error(format!("Failed to get metadata for path: {}, error: {}", self.path(), err)))?;
         let time_transform = |time: SystemTime| {
             time.duration_since(UNIX_EPOCH)
@@ -173,7 +173,7 @@ impl<UserName: Send + Sync, Handle: From<SMBFileSystemHandle> + ResourceHandle +
         }?;
         let handle = SMBFileSystemHandle {
             resource,
-            path: path.into(),
+            path,
         };
         debug!(?handle, "created filesystem handle");
         Ok(handle.into())
diff --git a/smb/src/server/share/ipc.rs b/smb/src/server/share/ipc.rs
index b7ef3cc..04e6152 100644
--- a/smb/src/server/share/ipc.rs
+++ b/smb/src/server/share/ipc.rs
@@ -2,7 +2,6 @@ use std::any::Any;
 use std::fmt::{Debug, Formatter};
 use std::marker::PhantomData;
 
-use smb_core::error::SMBError;
 use smb_core::SMBResult;
 
 use crate::protocol::body::create::disposition::SMBCreateDisposition;
@@ -58,8 +57,8 @@ pub struct SMBIPCShare<UserName: Send + Sync, Handle: From<SMBIPCHandle> + Resou
     _handle: PhantomData<Handle>,
 }
 
-impl<UserName: Send + Sync, Handle: From<SMBIPCHandle> + ResourceHandle> SMBIPCShare<UserName, Handle> {
-    pub fn new() -> Self {
+impl<UserName: Send + Sync, Handle: From<SMBIPCHandle> + ResourceHandle> Default for SMBIPCShare<UserName, Handle> {
+    fn default() -> Self {
         Self {
             _user_name: PhantomData,
             _handle: PhantomData,
@@ -67,6 +66,12 @@ impl<UserName: Send + Sync, Handle: From<SMBIPCHandle> + ResourceHandle> SMBIPCS
     }
 }
 
+impl<UserName: Send + Sync, Handle: From<SMBIPCHandle> + ResourceHandle> SMBIPCShare<UserName, Handle> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
 impl<UserName: Send + Sync, Handle: From<SMBIPCHandle> + ResourceHandle> Debug for SMBIPCShare<UserName, Handle> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SMBIPCShare").finish()
diff --git a/smb/src/socket/listener/mod.rs b/smb/src/socket/listener/mod.rs
index f71a45f..ce1512b 100644
--- a/smb/src/socket/listener/mod.rs
+++ b/smb/src/socket/listener/mod.rs
@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 use std::future::Future;
 use std::marker::PhantomData;
-use std::ops::{Add, Deref, DerefMut};
+use std::ops::{Deref, DerefMut};
 
 use smb_core::error::SMBError;
 use smb_core::SMBResult;
@@ -27,7 +27,7 @@ pub trait SMBSocket<T: Send + Sync>: Send + Sync {
     }
 
     #[cfg(feature = "async")]
-    fn new_socket(addr: T) -> impl Future<Output=SMBResult<Self>> + Send where Self: Sized {
+    fn new_socket(_addr: T) -> impl Future<Output=SMBResult<Self>> + Send where Self: Sized {
         async {
             Err(SMBError::precondition_failed("Invalid socket address type"))
         }
diff --git a/smb/src/socket/message_stream/mod.rs b/smb/src/socket/message_stream/mod.rs
index 2a257b9..da4149d 100644
--- a/smb/src/socket/message_stream/mod.rs
+++ b/smb/src/socket/message_stream/mod.rs
@@ -92,9 +92,11 @@ impl<'a, R: SMBReadStream> SMBMessageIterator<'a, R> {
 }
 
 #[cfg(feature = "async")]
-#[allow(clippy::type_complexity)]
+type SMBMessageStreamResult<'a, T> = (SMBResult<SMBMessage<SMBSyncHeader, SMBBody>>, SMBMessageIterator<'a, T>);
+
+#[cfg(feature = "async")]
 pub struct SMBMessageStream<'a, T: SMBReadStream> {
-    pub(crate) inner: ReusableBoxFuture<'a, (SMBResult<SMBMessage<SMBSyncHeader, SMBBody>>, SMBMessageIterator<'a, T>)>,
+    pub(crate) inner: ReusableBoxFuture<'a, SMBMessageStreamResult<'a, T>>,
 }
 
 #[derive(Debug)]
diff --git a/smb/src/util/crypto/des.rs b/smb/src/util/crypto/des.rs
index c45d4d6..005f2f8 100644
--- a/smb/src/util/crypto/des.rs
+++ b/smb/src/util/crypto/des.rs
@@ -32,8 +32,8 @@ fn extend_des_key(key: &[u8]) -> Vec<u8> {
     result[6] = ((key[5] & 0x3F) << 1) | (key[6] >> 7);
     result[7] = key[6] & 0x7F;
 
-    for i in 0..result.len() {
-        result[i] <<= 1;
+    for item in &mut result {
+        *item <<= 1;
     }
 
     result
diff --git a/smb/src/util/crypto/ntlm_v2.rs b/smb/src/util/crypto/ntlm_v2.rs
index 7ee1702..2ba3e7a 100644
--- a/smb/src/util/crypto/ntlm_v2.rs
+++ b/smb/src/util/crypto/ntlm_v2.rs
@@ -11,7 +11,7 @@ use crate::byte_helper::u16_to_bytes;
 pub fn authenticate_v2(domain: &str, account: &str, password: &str, server_challenge: &[u8], lm_response: &[u8], nt_response: &[u8]) -> SMBResult<(bool, Vec<u8>)> {
     // AV-pairs structure
     let server_name = &nt_response[44..(nt_response.len() - 4)];
-    let (nt_exp, lm_exp, nt_proof) = compute_ntlm_v2_response(server_challenge, &nt_response[16..], server_name, password, account, domain)?;
+    let (nt_exp, lm_exp, _nt_proof) = compute_ntlm_v2_response(server_challenge, &nt_response[16..], server_name, password, account, domain)?;
 
     let resp = nt_exp == nt_response || lm_exp == lm_response;
 
@@ -48,7 +48,7 @@ fn compute_ntlm_v2_response(server_challenge: &[u8], client_challenge: &[u8], se
         &[client_challenge[0]][0..],
         &[client_challenge[1]],
         &[0; 6],
-        &time,
+        time,
         // &[0; 8],
         client_challenge,
         &[0; 4],