From f0555ad25035b2853a461f1149a57b17664fa658 Mon Sep 17 00:00:00 2001 From: "tejas-claude-bot[bot]" <273638023+tejas-claude-bot[bot]@users.noreply.github.com> Date: Sat, 4 Apr 2026 16:37:27 -0400 Subject: [PATCH 1/6] =?UTF-8?q?fix(clippy):=20code=20style=20=E2=80=94=20F?= =?UTF-8?q?rom/Into,=20derives,=20naming,=20borrows,=20casts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Convert impl Into to impl From for u64 (command_code.rs) - Derive Default for SMBShareType, add Default impls for SMBErrorResponse and SMBIPCShare - Rename IPC() to ipc() for snake_case convention - Remove unnecessary borrows, derefs, and same-type casts - Remove unneeded return statements - Use iterator instead of index loop in des.rs - Use Entry API instead of contains_key+insert in server open table Co-Authored-By: Claude Opus 4.6 (1M context) --- smb/src/protocol/body/create/mod.rs | 2 +- smb/src/protocol/body/error/mod.rs | 10 +++++ smb/src/protocol/body/filetime.rs | 2 +- smb/src/protocol/body/negotiate/mod.rs | 5 +-- smb/src/protocol/body/session_setup/mod.rs | 5 +-- .../protocol/body/tree_connect/access_mask.rs | 2 +- smb/src/protocol/body/tree_connect/context.rs | 2 +- smb/src/protocol/body/tree_connect/mod.rs | 11 ++--- smb/src/protocol/header/command_code.rs | 12 +++--- smb/src/server/message_handler.rs | 42 +++++++++---------- smb/src/server/mod.rs | 14 +++++-- smb/src/server/share/file_system.rs | 4 +- smb/src/server/share/ipc.rs | 11 +++-- smb/src/socket/listener/mod.rs | 4 +- smb/src/util/crypto/des.rs | 4 +- smb/src/util/crypto/ntlm_v2.rs | 4 +- 16 files changed, 74 insertions(+), 60 deletions(-) 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>, } +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) -> Option { + pub fn from_request(_request: SMBSessionSetupRequest, token: Vec) -> Option { 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 for SMBCommandCode { - fn into(self) -> u64 { - self as u16 as u64 +impl From for u64 { + fn from(val: SMBCommandCode) -> Self { + val as u16 as u64 } } @@ -110,9 +110,9 @@ pub enum LegacySMBCommandCode { WriteBulkData } -impl Into for LegacySMBCommandCode { - fn into(self) -> u64 { - self as u8 as u64 +impl From for u64 { + fn from(val: LegacySMBCommandCode) -> Self { + val as u8 as u64 } } 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>> { + fn handle_negotiate(&mut self, _header: &SMBSyncHeader, _message: &SMBNegotiateRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_session_setup(&mut self, header: &SMBSyncHeader, message: &SMBSessionSetupRequest) -> impl Future>> { + fn handle_session_setup(&mut self, _header: &SMBSyncHeader, _message: &SMBSessionSetupRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_logoff(&mut self, header: &SMBSyncHeader, message: &SMBLogoffRequest) -> impl Future>> { + fn handle_logoff(&mut self, _header: &SMBSyncHeader, _message: &SMBLogoffRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_tree_connect(&mut self, header: &SMBSyncHeader, message: &SMBTreeConnectRequest) -> impl Future>> { + fn handle_tree_connect(&mut self, _header: &SMBSyncHeader, _message: &SMBTreeConnectRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_tree_disconnect(&mut self, header: &SMBSyncHeader, message: &SMBTreeDisconnectRequest) -> impl Future>> { + fn handle_tree_disconnect(&mut self, _header: &SMBSyncHeader, _message: &SMBTreeDisconnectRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_create(&mut self, header: &SMBSyncHeader, message: &SMBCreateRequest) -> impl Future>> { + fn handle_create(&mut self, _header: &SMBSyncHeader, _message: &SMBCreateRequest) -> impl Future>> { debug!("create request, passing to next handler"); async { Ok(SMBHandlerState::Next(None)) } } - fn handle_close(&mut self, header: &SMBSyncHeader, message: &SMBCloseRequest) -> impl Future>> { + fn handle_close(&mut self, _header: &SMBSyncHeader, _message: &SMBCloseRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_flush(&mut self, header: &SMBSyncHeader, message: &SMBFlushRequest) -> impl Future>> { + fn handle_flush(&mut self, _header: &SMBSyncHeader, _message: &SMBFlushRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_read(&mut self, header: &SMBSyncHeader, message: &SMBReadRequest) -> impl Future>> { + fn handle_read(&mut self, _header: &SMBSyncHeader, _message: &SMBReadRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_write(&mut self, header: &SMBSyncHeader, message: &SMBWriteRequest) -> impl Future>> { + fn handle_write(&mut self, _header: &SMBSyncHeader, _message: &SMBWriteRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_lock(&mut self, header: &SMBSyncHeader, message: &SMBLockRequest) -> impl Future>> { + fn handle_lock(&mut self, _header: &SMBSyncHeader, _message: &SMBLockRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_ioctl(&mut self, header: &SMBSyncHeader, message: &SMBIoCtlRequest) -> impl Future>> { + fn handle_ioctl(&mut self, _header: &SMBSyncHeader, _message: &SMBIoCtlRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_cancel(&mut self, header: &SMBSyncHeader, message: &SMBCancelRequest) -> impl Future>> { + fn handle_cancel(&mut self, _header: &SMBSyncHeader, _message: &SMBCancelRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_echo(&mut self, header: &SMBSyncHeader, message: &SMBEchoRequest) -> impl Future>> { + fn handle_echo(&mut self, _header: &SMBSyncHeader, _message: &SMBEchoRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_query_directory(&mut self, header: &SMBSyncHeader, message: &SMBQueryDirectoryRequest) -> impl Future>> { + fn handle_query_directory(&mut self, _header: &SMBSyncHeader, _message: &SMBQueryDirectoryRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_change_notify(&mut self, header: &SMBSyncHeader, message: &SMBChangeNotifyRequest) -> impl Future>> { + fn handle_change_notify(&mut self, _header: &SMBSyncHeader, _message: &SMBChangeNotifyRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_query_info(&mut self, header: &SMBSyncHeader, message: &SMBQueryInfoRequest) -> impl Future>> { + fn handle_query_info(&mut self, _header: &SMBSyncHeader, _message: &SMBQueryInfoRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_set_info(&mut self, header: &SMBSyncHeader, message: &SMBSetInfoRequest) -> impl Future>> { + fn handle_set_info(&mut self, _header: &SMBSyncHeader, _message: &SMBSetInfoRequest) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } - fn handle_oplock_break(&mut self, header: &SMBSyncHeader, message: &SMBOplockBreakAcknowledgement) -> impl Future>> { + fn handle_oplock_break(&mut self, _header: &SMBSyncHeader, _message: &SMBOplockBreakAcknowledgement) -> impl Future>> { async { Ok(SMBHandlerState::Next(None)) } } } diff --git a/smb/src/server/mod.rs b/smb/src/server/mod.rs index a76e1a8..a9197f7 100644 --- a/smb/src/server/mod.rs +++ b/smb/src/server/mod.rs @@ -92,6 +92,7 @@ type DefaultHandle = Box; #[derive(Debug, Builder)] #[builder(pattern = "owned")] #[builder(build_fn(name = "build_inner", private))] +#[allow(dead_code)] pub struct SMBServer = TcpListener, Auth: AuthProvider = NTLMAuthProvider, Share: SharedResource, Handle=Handle> = DefaultShare, Handle: ResourceHandle = DefaultHandle> { #[builder(default = "Default::default()")] statistics: Arc>, @@ -102,14 +103,17 @@ pub struct SMBServer = TcpListene #[builder(field( type = "HashMap>>>" ))] + #[allow(clippy::type_complexity)] open_table: HashMap>>>, #[builder(field( type = "HashMap>>>" ))] + #[allow(clippy::type_complexity)] session_table: HashMap>>>, #[builder(field( type = "HashMap>" ))] + #[allow(clippy::type_complexity)] connection_list: HashMap>, #[builder(default = "Uuid::new_v4()")] guid: Uuid, @@ -128,6 +132,7 @@ pub struct SMBServer = TcpListene #[builder(field( type = "HashMap>>" ))] + #[allow(clippy::type_complexity)] lease_table_list: HashMap>>, #[builder(default = "5000")] max_resiliency_timeout: u64, @@ -187,11 +192,11 @@ impl, Auth: AuthProvider, Share: async fn add_open(&mut self, open: Arc>) -> u32 { for i in 0..u32::MAX { - if self.open_table.get(&i).is_none() { + if let std::collections::hash_map::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; } } @@ -308,6 +313,7 @@ impl, Auth: AuthProvider, Share: self } + #[allow(clippy::type_complexity)] pub fn build(self) -> SMBResult>>> { let server = self.build_inner().map_err(SMBError::server_error)?; Ok(Arc::new(RwLock::new(server))) @@ -345,7 +351,7 @@ impl< Share: SharedResource, Handle=Handle> + From, Handle>>, Handle: ResourceHandle + 'static + From + TryInto > SMBServerBuilder { - pub fn add_fs_share(mut self, name: String, path: String, connect_allowed: ConnectAllowed>, file_perms: FilePerms>) -> Self { + pub fn add_fs_share(self, name: String, path: String, connect_allowed: ConnectAllowed>, file_perms: FilePerms>) -> Self { let share = SMBFileSystemShare::path(name.clone(), path, connect_allowed, file_perms); self.add_share(name, share.into()) } @@ -394,7 +400,7 @@ impl + 'static, Auth: A let mut stream = socket.lock().await; match SMBConnection::start_message_handler::(&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/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 { - 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 + 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 + Resou _handle: PhantomData, } -impl + ResourceHandle> SMBIPCShare { - pub fn new() -> Self { +impl + ResourceHandle> Default for SMBIPCShare { + fn default() -> Self { Self { _user_name: PhantomData, _handle: PhantomData, @@ -67,6 +66,12 @@ impl + ResourceHandle> SMBIPCS } } +impl + ResourceHandle> SMBIPCShare { + pub fn new() -> Self { + Self::default() + } +} + impl + ResourceHandle> Debug for SMBIPCShare { 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: Send + Sync { } #[cfg(feature = "async")] - fn new_socket(addr: T) -> impl Future> + Send where Self: Sized { + fn new_socket(_addr: T) -> impl Future> + Send where Self: Sized { async { Err(SMBError::precondition_failed("Invalid socket address type")) } 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 { 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)> { // 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], From 3d578ae969d1563fc7b8bc99b34ea7825c597392 Mon Sep 17 00:00:00 2001 From: "tejas-claude-bot[bot]" <273638023+tejas-claude-bot[bot]@users.noreply.github.com> Date: Sat, 4 Apr 2026 17:23:58 -0400 Subject: [PATCH 2/6] fix(clippy): address PR review comments - Remove leftover #[allow(dead_code)] on SMBServer - Replace #[allow(clippy::type_complexity)] with type aliases - Use `Entry` import instead of fully-qualified path - Restore FileAttributes TODO struct removed in error Co-Authored-By: Claude Opus 4.6 (1M context) --- smb/src/server/mod.rs | 27 +++++++++++++-------------- smb/src/server/open.rs | 5 +++++ 2 files changed, 18 insertions(+), 14 deletions(-) diff --git a/smb/src/server/mod.rs b/smb/src/server/mod.rs index a9197f7..8fe5927 100644 --- a/smb/src/server/mod.rs +++ b/smb/src/server/mod.rs @@ -1,3 +1,4 @@ +use std::collections::hash_map::Entry; use std::collections::HashMap; use std::fmt::Debug; use std::future::Future; @@ -86,13 +87,16 @@ type LockedWeakSMBConnection = Weak = SMBSession>; type SMBOpenType = SMBOpen>; type SMBLeaseType = SMBLease>; +type LockedSMBOpen = Arc>>; +type LockedSMBSession = Arc>>; +type LockedSMBServer = Arc>>; +type SMBLeaseTableType = SMBLeaseTable>; type UserName = <::Context as AuthContext>::UserName; pub type DefaultShare = Box::Context as AuthContext>::UserName, Handle=DefaultHandle>>; type DefaultHandle = Box; #[derive(Debug, Builder)] #[builder(pattern = "owned")] #[builder(build_fn(name = "build_inner", private))] -#[allow(dead_code)] pub struct SMBServer = TcpListener, Auth: AuthProvider = NTLMAuthProvider, Share: SharedResource, Handle=Handle> = DefaultShare, Handle: ResourceHandle = DefaultHandle> { #[builder(default = "Default::default()")] statistics: Arc>, @@ -101,19 +105,16 @@ pub struct SMBServer = TcpListene #[builder(field(type = "HashMap>"))] share_list: HashMap>, #[builder(field( - type = "HashMap>>>" + type = "HashMap>" ))] - #[allow(clippy::type_complexity)] - open_table: HashMap>>>, + open_table: HashMap>, #[builder(field( - type = "HashMap>>>" + type = "HashMap>" ))] - #[allow(clippy::type_complexity)] - session_table: HashMap>>>, + session_table: HashMap>, #[builder(field( type = "HashMap>" ))] - #[allow(clippy::type_complexity)] connection_list: HashMap>, #[builder(default = "Uuid::new_v4()")] guid: Uuid, @@ -130,10 +131,9 @@ pub struct SMBServer = TcpListene #[builder(default = "HashLevel::EnableAll")] hash_level: HashLevel, #[builder(field( - type = "HashMap>>" + type = "HashMap>" ))] - #[allow(clippy::type_complexity)] - lease_table_list: HashMap>>, + lease_table_list: HashMap>, #[builder(default = "5000")] max_resiliency_timeout: u64, #[builder(default = "5000")] @@ -192,7 +192,7 @@ impl, Auth: AuthProvider, Share: async fn add_open(&mut self, open: Arc>) -> u32 { for i in 0..u32::MAX { - if let std::collections::hash_map::Entry::Vacant(e) = self.open_table.entry(i) { + 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); @@ -313,8 +313,7 @@ impl, Auth: AuthProvider, Share: self } - #[allow(clippy::type_complexity)] - pub fn build(self) -> SMBResult>>> { + pub fn build(self) -> SMBResult> { let server = self.build_inner().map_err(SMBError::server_error)?; Ok(Arc::new(RwLock::new(server))) } diff --git a/smb/src/server/open.rs b/smb/src/server/open.rs index a3df216..6a8b122 100644 --- a/smb/src/server/open.rs +++ b/smb/src/server/open.rs @@ -145,6 +145,11 @@ impl Open for SMBOpen { self.underlying.metadata() } } + +// TODO: From MS-FSCC section 2.6 +#[derive(Debug)] +struct FileAttributes; + #[derive(Debug)] pub enum SMBOplockState { Held, From 34bd241fa02aa256422702edc7a7d3e99f311a00 Mon Sep 17 00:00:00 2001 From: "tejas-claude-bot[bot]" <273638023+tejas-claude-bot[bot]@users.noreply.github.com> Date: Sat, 4 Apr 2026 17:26:55 -0400 Subject: [PATCH 3/6] fix(clippy): replace type_complexity allow on SMBMessageStream with type alias Co-Authored-By: Claude Opus 4.6 (1M context) --- smb/src/socket/message_stream/mod.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) 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>, SMBMessageIterator<'a, T>); + +#[cfg(feature = "async")] pub struct SMBMessageStream<'a, T: SMBReadStream> { - pub(crate) inner: ReusableBoxFuture<'a, (SMBResult>, SMBMessageIterator<'a, T>)>, + pub(crate) inner: ReusableBoxFuture<'a, SMBMessageStreamResult<'a, T>>, } #[derive(Debug)] From fcccb1cab47cf4f3988c06cb4694e5465718e18e Mon Sep 17 00:00:00 2001 From: "tejas-claude-bot[bot]" <273638023+tejas-claude-bot[bot]@users.noreply.github.com> Date: Sat, 4 Apr 2026 17:37:19 -0400 Subject: [PATCH 4/6] refactor: move locked type aliases to their respective modules Define LockedSMBOpen, LockedSMBSession, and SMBLeaseTableOf in their own files (open.rs, session.rs, lease.rs) instead of mod.rs. This keeps type aliases co-located with the types they wrap. Co-Authored-By: Claude Opus 4.6 (1M context) --- smb/src/server/lease.rs | 2 ++ smb/src/server/mod.rs | 40 ++++++++++++++++----------------------- smb/src/server/open.rs | 3 +++ smb/src/server/session.rs | 1 + 4 files changed, 22 insertions(+), 24 deletions(-) diff --git a/smb/src/server/lease.rs b/smb/src/server/lease.rs index ec59052..24b48e0 100644 --- a/smb/src/server/lease.rs +++ b/smb/src/server/lease.rs @@ -9,6 +9,8 @@ use crate::server::Server; pub trait Lease: Send + Sync {} +pub type SMBLeaseTableOf = SMBLeaseTable>; + #[derive(Debug)] pub struct SMBLeaseTable { client_guid: Uuid, diff --git a/smb/src/server/mod.rs b/smb/src/server/mod.rs index 8fe5927..0046e12 100644 --- a/smb/src/server/mod.rs +++ b/smb/src/server/mod.rs @@ -18,10 +18,10 @@ 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::lease::{Lease, SMBLease, SMBLeaseTable}; -use crate::server::open::{Open, SMBOpen}; +use crate::server::lease::{Lease, SMBLease, SMBLeaseTable, SMBLeaseTableOf}; +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}; @@ -82,15 +82,7 @@ pub trait StartSMBServer { } type SMBConnectionType = SMBConnection<>::ReadStream, >::WriteStream, SMBServer>; - -type LockedWeakSMBConnection = Weak>>; -type SMBSessionType = SMBSession>; -type SMBOpenType = SMBOpen>; -type SMBLeaseType = SMBLease>; -type LockedSMBOpen = Arc>>; -type LockedSMBSession = Arc>>; -type LockedSMBServer = Arc>>; -type SMBLeaseTableType = SMBLeaseTable>; +type WeakLockedSMBConnection = Weak>>; type UserName = <::Context as AuthContext>::UserName; pub type DefaultShare = Box::Context as AuthContext>::UserName, Handle=DefaultHandle>>; type DefaultHandle = Box; @@ -105,17 +97,17 @@ pub struct SMBServer = TcpListene #[builder(field(type = "HashMap>"))] share_list: HashMap>, #[builder(field( - type = "HashMap>" + type = "HashMap>>" ))] - open_table: HashMap>, + open_table: HashMap>>, #[builder(field( - type = "HashMap>" + type = "HashMap>>" ))] - session_table: HashMap>, + session_table: HashMap>>, #[builder(field( - type = "HashMap>" + type = "HashMap>" ))] - connection_list: HashMap>, + connection_list: HashMap>, #[builder(default = "Uuid::new_v4()")] guid: Uuid, #[builder(default = "FileTime::default()")] @@ -131,9 +123,9 @@ pub struct SMBServer = TcpListene #[builder(default = "HashLevel::EnableAll")] hash_level: HashLevel, #[builder(field( - type = "HashMap>" + type = "HashMap>>" ))] - lease_table_list: HashMap>, + lease_table_list: HashMap>>, #[builder(default = "5000")] max_resiliency_timeout: u64, #[builder(default = "5000")] @@ -175,10 +167,10 @@ pub struct SMBServer = TcpListene impl, Auth: AuthProvider, Share: SharedResource, Handle=Handle>, Handle: ResourceHandle> Server for SMBServer { type Connection = SMBConnectionType; - type Session = SMBSessionType; + type Session = SMBSession; type Share = Share; - type Open = SMBOpenType; - type Lease = SMBLeaseType; + type Open = SMBOpen; + type Lease = SMBLease; type AuthProvider = Auth; type Handle = Handle; @@ -313,7 +305,7 @@ impl, Auth: AuthProvider, Share: self } - pub fn build(self) -> SMBResult> { + pub fn build(self) -> SMBResult>>> { let server = self.build_inner().map_err(SMBError::server_error)?; Ok(Arc::new(RwLock::new(server))) } diff --git a/smb/src/server/open.rs b/smb/src/server/open.rs index 6a8b122..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 = Arc>>; + pub trait Open: Send + Sync { type Server: Server; fn file_name(&self) -> &str; 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 = Arc>>; type SMBMessageType = SMBMessage; const _OUTPUT_SIZE_128: usize = 128; From b22084d689c62560292213c2bba6b97012b69d2a Mon Sep 17 00:00:00 2001 From: "tejas-claude-bot[bot]" <273638023+tejas-claude-bot[bot]@users.noreply.github.com> Date: Sat, 4 Apr 2026 17:41:47 -0400 Subject: [PATCH 5/6] refactor: move WeakLockedSMBConnection to connection.rs Co-Authored-By: Claude Opus 4.6 (1M context) --- smb/src/server/connection.rs | 1 + smb/src/server/mod.rs | 9 ++++----- 2 files changed, 5 insertions(+), 5 deletions(-) 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> SMBConnect } type LockedSMBConnection = Arc>>; +pub type WeakLockedSMBConnection = Weak>>; impl> InnerGetter for SMBConnection { type Upper = S; diff --git a/smb/src/server/mod.rs b/smb/src/server/mod.rs index 0046e12..0f9579b 100644 --- a/smb/src/server/mod.rs +++ b/smb/src/server/mod.rs @@ -2,7 +2,7 @@ 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; @@ -17,7 +17,7 @@ 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, SMBLeaseTableOf}; use crate::server::open::{LockedSMBOpen, Open, SMBOpen}; use crate::server::safe_locked_getter::InnerGetter; @@ -82,7 +82,6 @@ pub trait StartSMBServer { } type SMBConnectionType = SMBConnection<>::ReadStream, >::WriteStream, SMBServer>; -type WeakLockedSMBConnection = Weak>>; type UserName = <::Context as AuthContext>::UserName; pub type DefaultShare = Box::Context as AuthContext>::UserName, Handle=DefaultHandle>>; type DefaultHandle = Box; @@ -105,9 +104,9 @@ pub struct SMBServer = TcpListene ))] session_table: HashMap>>, #[builder(field( - type = "HashMap>" + type = "HashMap>::ReadStream, >::WriteStream, SMBServer>>" ))] - connection_list: HashMap>, + connection_list: HashMap>::ReadStream, >::WriteStream, SMBServer>>, #[builder(default = "Uuid::new_v4()")] guid: Uuid, #[builder(default = "FileTime::default()")] From 534e297b5a8600e20d623fbb5730858d1ba40e77 Mon Sep 17 00:00:00 2001 From: "tejas-claude-bot[bot]" <273638023+tejas-claude-bot[bot]@users.noreply.github.com> Date: Sat, 4 Apr 2026 17:44:26 -0400 Subject: [PATCH 6/6] refactor: remove SMBLeaseTableOf alias, use SMBLeaseTable directly Co-Authored-By: Claude Opus 4.6 (1M context) --- smb/src/server/lease.rs | 1 - smb/src/server/mod.rs | 6 +++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/smb/src/server/lease.rs b/smb/src/server/lease.rs index 24b48e0..c06538d 100644 --- a/smb/src/server/lease.rs +++ b/smb/src/server/lease.rs @@ -9,7 +9,6 @@ use crate::server::Server; pub trait Lease: Send + Sync {} -pub type SMBLeaseTableOf = SMBLeaseTable>; #[derive(Debug)] pub struct SMBLeaseTable { diff --git a/smb/src/server/mod.rs b/smb/src/server/mod.rs index 0f9579b..0dd240a 100644 --- a/smb/src/server/mod.rs +++ b/smb/src/server/mod.rs @@ -18,7 +18,7 @@ use crate::protocol::body::dialect::SMBDialect; use crate::protocol::body::filetime::FileTime; use crate::server::client::SMBClient; use crate::server::connection::{Connection, SMBConnection, WeakLockedSMBConnection}; -use crate::server::lease::{Lease, SMBLease, SMBLeaseTable, SMBLeaseTableOf}; +use crate::server::lease::{Lease, SMBLease, SMBLeaseTable}; use crate::server::open::{LockedSMBOpen, Open, SMBOpen}; use crate::server::safe_locked_getter::InnerGetter; use crate::server::session::{LockedSMBSession, Session, SMBSession}; @@ -122,9 +122,9 @@ pub struct SMBServer = TcpListene #[builder(default = "HashLevel::EnableAll")] hash_level: HashLevel, #[builder(field( - type = "HashMap>>" + type = "HashMap>>>" ))] - lease_table_list: HashMap>>, + lease_table_list: HashMap>>>, #[builder(default = "5000")] max_resiliency_timeout: u64, #[builder(default = "5000")]