feat: implement Close, Read, and QueryInfo handlers for E2E file read

Add the server-side handlers needed for a complete file read flow:
Create → QueryInfo → Read → Close.

Protocol types:
- Add accessor methods to SMBCloseRequest, SMBReadRequest, SMBQueryInfoRequest
- Add constructors for SMBCloseResponse, SMBReadResponse, SMBQueryInfoResponse
- Make close::flags and query_info::info_type modules public

Trait extensions:
- Add read_data() to ResourceHandle trait with implementations for
  SMBFileSystemHandle (seeks + reads) and SMBIPCHandle (stub)
- Add read_data() to Open trait, delegating to the underlying handle
- Add open_table_mut() to Session trait for close cleanup
- Add remove_open() to Server trait for global open table cleanup
- Fix SMBOpen::inner() todo!() → return None (terminal handler)

Handlers (tree_connect.rs):
- handle_close: returns file metadata if POSTQUERY_ATTRIB flag set,
  removes open from server (outer) then session (inner) tables
- handle_read: reads data from the open's underlying handle, enforces
  minimum_count, returns SMBReadResponse
- handle_query_info: supports FileBasicInformation (class 4),
  FileStandardInformation (class 5), FileNetworkOpenInformation (class 34)
  per MS-FSCC; returns InvalidInfoClass for unsupported types
- Fix lock ordering in handle_create: server write before session write

Lock ordering: all handlers acquire locks outer→inner
(server → connection → session → open), readers before writers.

NTStatus: add FileClosed, EndOfFile, InvalidInfoClass, InvalidDeviceRequest

Tests:
- 13 unit tests for request accessor and response constructor round-trips
- 3 integration tests (smbclient E2E: file read, dir listing, missing file)

Author: tmthecoder

smb-core/src/nt_status.rs

@@ -19,6 +19,10 @@ pub enum NTStatus {
     UserSessionDeleted = 0xC0000203,
     NetworkSessionExpired = 0xC000035C,
     FileNotAvailable = 0xC0000467,
+    FileClosed = 0xC0000128,
+    EndOfFile = 0xC0000011,
+    InvalidInfoClass = 0xC0000003,
+    InvalidDeviceRequest = 0xC0000010,
     UnknownError = 0xFFFFFFFF,
 }
 

smb/src/protocol/body/close/mod.rs

@@ -9,7 +9,7 @@ use crate::protocol::body::create::file_attributes::SMBFileAttributes;
 use crate::protocol::body::create::file_id::SMBFileId;
 use crate::protocol::body::filetime::FileTime;
 
-mod flags;
+pub mod flags;
 
 #[derive(
     Debug,
@@ -32,6 +32,16 @@ pub struct SMBCloseRequest {
     file_id: SMBFileId,
 }
 
+impl SMBCloseRequest {
+    pub fn flags(&self) -> SMBCloseFlags {
+        self.flags
+    }
+
+    pub fn file_id(&self) -> &SMBFileId {
+        &self.file_id
+    }
+}
+
 #[derive(
     Debug,
     PartialEq,
@@ -63,4 +73,116 @@ pub struct SMBCloseResponse {
     end_of_file: u64,
     #[smb_direct(start(fixed = 56))]
     file_attributes: SMBFileAttributes,
+}
+
+impl SMBCloseResponse {
+    pub fn from_metadata(metadata: &crate::server::share::SMBFileMetadata, attributes: SMBFileAttributes) -> Self {
+        Self {
+            flags: SMBCloseFlags::POSTQUERY_ATTRIB,
+            reserved: PhantomData,
+            creation_time: metadata.creation_time.clone(),
+            last_access_time: metadata.last_access_time.clone(),
+            last_write_time: metadata.last_write_time.clone(),
+            change_time: metadata.last_modification_time.clone(),
+            allocation_size: metadata.allocated_size,
+            end_of_file: metadata.actual_size,
+            file_attributes: attributes,
+        }
+    }
+
+    pub fn empty() -> Self {
+        Self {
+            flags: SMBCloseFlags::empty(),
+            reserved: PhantomData,
+            creation_time: FileTime::zero(),
+            last_access_time: FileTime::zero(),
+            last_write_time: FileTime::zero(),
+            change_time: FileTime::zero(),
+            allocation_size: 0,
+            end_of_file: 0,
+            file_attributes: SMBFileAttributes::empty(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use smb_core::{SMBByteSize, SMBToBytes, SMBFromBytes};
+
+    #[test]
+    fn close_response_empty_has_zero_fields() {
+        let resp = SMBCloseResponse::empty();
+        assert_eq!(resp.flags, SMBCloseFlags::empty());
+        assert_eq!(resp.allocation_size, 0);
+        assert_eq!(resp.end_of_file, 0);
+        assert_eq!(resp.file_attributes, SMBFileAttributes::empty());
+    }
+
+    #[test]
+    fn close_response_empty_serialization_round_trip() {
+        let resp = SMBCloseResponse::empty();
+        let bytes = resp.smb_to_bytes();
+        assert_eq!(bytes.len(), resp.smb_byte_size());
+        let (_, parsed) = SMBCloseResponse::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(resp, parsed);
+    }
+
+    #[test]
+    fn close_response_from_metadata_sets_postquery_flag() {
+        use crate::server::share::SMBFileMetadata;
+        let metadata = SMBFileMetadata {
+            creation_time: FileTime::from_unix(1700000000),
+            last_access_time: FileTime::from_unix(1700000100),
+            last_write_time: FileTime::from_unix(1700000200),
+            last_modification_time: FileTime::from_unix(1700000300),
+            allocated_size: 4096,
+            actual_size: 1024,
+        };
+        let resp = SMBCloseResponse::from_metadata(&metadata, SMBFileAttributes::NORMAL);
+        assert!(resp.flags.contains(SMBCloseFlags::POSTQUERY_ATTRIB));
+        assert_eq!(resp.allocation_size, 4096);
+        assert_eq!(resp.end_of_file, 1024);
+        assert_eq!(resp.file_attributes, SMBFileAttributes::NORMAL);
+    }
+
+    #[test]
+    fn close_response_from_metadata_serialization_round_trip() {
+        use crate::server::share::SMBFileMetadata;
+        let metadata = SMBFileMetadata {
+            creation_time: FileTime::from_unix(1700000000),
+            last_access_time: FileTime::from_unix(1700000100),
+            last_write_time: FileTime::from_unix(1700000200),
+            last_modification_time: FileTime::from_unix(1700000300),
+            allocated_size: 8192,
+            actual_size: 2048,
+        };
+        let resp = SMBCloseResponse::from_metadata(&metadata, SMBFileAttributes::ARCHIVE);
+        let bytes = resp.smb_to_bytes();
+        assert_eq!(bytes.len(), resp.smb_byte_size());
+        let (_, parsed) = SMBCloseResponse::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(resp, parsed);
+    }
+
+    #[test]
+    fn close_request_accessors() {
+        let file_id = SMBFileId { persistent: 42, volatile: 99 };
+        let bytes = {
+            let mut buf = Vec::new();
+            // struct_size (u16) = 24
+            buf.extend_from_slice(&24u16.to_le_bytes());
+            // flags (u16) = POSTQUERY_ATTRIB = 0x0001
+            buf.extend_from_slice(&1u16.to_le_bytes());
+            // reserved (4 bytes)
+            buf.extend_from_slice(&[0u8; 4]);
+            // file_id: persistent (u64) + volatile (u64)
+            buf.extend_from_slice(&42u64.to_le_bytes());
+            buf.extend_from_slice(&99u64.to_le_bytes());
+            buf
+        };
+        let (_, req) = SMBCloseRequest::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(req.file_id().persistent, file_id.persistent);
+        assert_eq!(req.file_id().volatile, file_id.volatile);
+        assert!(req.flags().contains(SMBCloseFlags::POSTQUERY_ATTRIB));
+    }
 }

smb/src/protocol/body/query_info/mod.rs

@@ -10,7 +10,7 @@ use crate::protocol::body::query_info::info_type::SMBInfoType;
 use crate::protocol::body::query_info::security_information::SMBSecurityInformation;
 
 mod flags;
-mod info_type;
+pub mod info_type;
 mod security_information;
 
 #[derive(
@@ -44,6 +44,24 @@ pub struct SMBQueryInfoRequest {
     buffer: Vec<u8>,
 }
 
+impl SMBQueryInfoRequest {
+    pub fn info_type(&self) -> SMBInfoType {
+        self.info_type
+    }
+
+    pub fn file_info_class(&self) -> u8 {
+        self.file_info_class
+    }
+
+    pub fn output_buffer_length(&self) -> u32 {
+        self.output_buffer_length
+    }
+
+    pub fn file_id(&self) -> &SMBFileId {
+        &self.file_id
+    }
+}
+
 #[derive(
     Debug,
     PartialEq,
@@ -62,4 +80,78 @@ pub struct SMBQueryInfoResponse {
     // TODO make this a struct: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/3b1b3598-a898-44ca-bfac-2dcae065247f
     #[smb_buffer(order = 0, offset(inner(start = 2, num_type = "u16", subtract = 64)), length(inner(start = 4, num_type = "u32")))]
     data: Vec<u8>,
+}
+
+impl SMBQueryInfoResponse {
+    pub fn new(data: Vec<u8>) -> Self {
+        Self {
+            reserved: PhantomData,
+            data,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use smb_core::{SMBByteSize, SMBToBytes, SMBFromBytes};
+
+    #[test]
+    fn query_info_response_new_sets_data() {
+        let data = vec![1, 2, 3, 4, 5, 6, 7, 8];
+        let resp = SMBQueryInfoResponse::new(data.clone());
+        assert_eq!(resp.data, data);
+    }
+
+    #[test]
+    fn query_info_response_serialization_round_trip() {
+        let resp = SMBQueryInfoResponse::new(vec![0xAA; 40]);
+        let bytes = resp.smb_to_bytes();
+        assert_eq!(bytes.len(), resp.smb_byte_size());
+        let (_, parsed) = SMBQueryInfoResponse::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(resp, parsed);
+    }
+
+    #[test]
+    fn query_info_response_empty_data_round_trip() {
+        let resp = SMBQueryInfoResponse::new(vec![]);
+        let bytes = resp.smb_to_bytes();
+        let (_, parsed) = SMBQueryInfoResponse::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(resp, parsed);
+    }
+
+    #[test]
+    fn query_info_request_accessors() {
+        let bytes = {
+            let mut buf = Vec::new();
+            // struct_size (u16) = 41
+            buf.extend_from_slice(&41u16.to_le_bytes());
+            // info_type (u8) = 0 (File)
+            buf.push(0);
+            // file_info_class (u8) = 4 (FileBasicInformation)
+            buf.push(4);
+            // output_buffer_length (u32) = 4096
+            buf.extend_from_slice(&4096u32.to_le_bytes());
+            // input_buffer_offset (u16) = 0
+            buf.extend_from_slice(&0u16.to_le_bytes());
+            // reserved (u16) = 0
+            buf.extend_from_slice(&0u16.to_le_bytes());
+            // input_buffer_length (u32) = 0
+            buf.extend_from_slice(&0u32.to_le_bytes());
+            // additional_information (u32) = 0
+            buf.extend_from_slice(&0u32.to_le_bytes());
+            // flags (u32) = 0
+            buf.extend_from_slice(&0u32.to_le_bytes());
+            // file_id: persistent (u64) + volatile (u64)
+            buf.extend_from_slice(&55u64.to_le_bytes());
+            buf.extend_from_slice(&77u64.to_le_bytes());
+            buf
+        };
+        let (_, req) = SMBQueryInfoRequest::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(req.info_type(), SMBInfoType::File);
+        assert_eq!(req.file_info_class(), 4);
+        assert_eq!(req.output_buffer_length(), 4096);
+        assert_eq!(req.file_id().persistent, 55);
+        assert_eq!(req.file_id().volatile, 77);
+    }
 }

smb/src/protocol/body/read/mod.rs

@@ -42,6 +42,24 @@ pub struct SMBReadRequest {
     channel_information: Vec<u8>,
 }
 
+impl SMBReadRequest {
+    pub fn file_id(&self) -> &SMBFileId {
+        &self.file_id
+    }
+
+    pub fn read_length(&self) -> u32 {
+        self.read_length
+    }
+
+    pub fn read_offset(&self) -> u64 {
+        self.read_offset
+    }
+
+    pub fn minimum_count(&self) -> u32 {
+        self.minimum_count
+    }
+}
+
 #[derive(
     Debug,
     PartialEq,
@@ -63,4 +81,83 @@ pub struct SMBReadResponse {
     flags: SMBReadResponseFlags,
     #[smb_buffer(order = 0, offset(inner(start = 2, num_type = "u8", subtract = 64)), length(inner(start = 4, num_type = "u32")))]
     data: Vec<u8>,
+}
+
+impl SMBReadResponse {
+    pub fn new(data: Vec<u8>, data_remaining: u32) -> Self {
+        Self {
+            reserved: PhantomData,
+            data_remaining,
+            flags: SMBReadResponseFlags::None,
+            data,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use smb_core::{SMBByteSize, SMBToBytes, SMBFromBytes};
+
+    #[test]
+    fn read_response_new_sets_fields() {
+        let data = vec![0xDE, 0xAD, 0xBE, 0xEF];
+        let resp = SMBReadResponse::new(data.clone(), 100);
+        assert_eq!(resp.data, data);
+        assert_eq!(resp.data_remaining, 100);
+        assert_eq!(resp.flags, SMBReadResponseFlags::None);
+    }
+
+    #[test]
+    fn read_response_serialization_round_trip() {
+        let resp = SMBReadResponse::new(vec![1, 2, 3, 4, 5], 0);
+        let bytes = resp.smb_to_bytes();
+        assert_eq!(bytes.len(), resp.smb_byte_size());
+        let (_, parsed) = SMBReadResponse::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(resp, parsed);
+    }
+
+    #[test]
+    fn read_response_empty_data() {
+        let resp = SMBReadResponse::new(vec![], 0);
+        let bytes = resp.smb_to_bytes();
+        let (_, parsed) = SMBReadResponse::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(resp, parsed);
+    }
+
+    #[test]
+    fn read_request_accessors() {
+        let bytes = {
+            let mut buf = Vec::new();
+            // struct_size (u16) = 49
+            buf.extend_from_slice(&49u16.to_le_bytes());
+            // padding (u8)
+            buf.push(0);
+            // flags (u8) = 0
+            buf.push(0);
+            // read_length (u32) = 1024
+            buf.extend_from_slice(&1024u32.to_le_bytes());
+            // read_offset (u64) = 512
+            buf.extend_from_slice(&512u64.to_le_bytes());
+            // file_id: persistent (u64) + volatile (u64)
+            buf.extend_from_slice(&10u64.to_le_bytes());
+            buf.extend_from_slice(&20u64.to_le_bytes());
+            // minimum_count (u32) = 256
+            buf.extend_from_slice(&256u32.to_le_bytes());
+            // channel (u32) = 0
+            buf.extend_from_slice(&0u32.to_le_bytes());
+            // remaining_bytes (u32) = 0
+            buf.extend_from_slice(&0u32.to_le_bytes());
+            // channel_info_offset (u16) = 0, channel_info_length (u16) = 0
+            buf.extend_from_slice(&0u16.to_le_bytes());
+            buf.extend_from_slice(&0u16.to_le_bytes());
+            buf
+        };
+        let (_, req) = SMBReadRequest::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(req.read_length(), 1024);
+        assert_eq!(req.read_offset(), 512);
+        assert_eq!(req.minimum_count(), 256);
+        assert_eq!(req.file_id().persistent, 10);
+        assert_eq!(req.file_id().volatile, 20);
+    }
 }

smb/src/server/mod.rs

@@ -52,6 +52,7 @@ pub trait Server: Send + Sync {
     fn shares(&self) -> &HashMap<String, Arc<Self::Share>>;
     fn opens(&self) -> &HashMap<u32, Arc<RwLock<Self::Open>>>;
     fn add_open(&mut self, open: Arc<RwLock<Self::Open>>) -> impl Future<Output=u32>;
+    fn remove_open(&mut self, global_id: u32);
     fn sessions(&self) -> &HashMap<u64, Arc<RwLock<Self::Session>>>;
     fn sessions_mut(&mut self) -> &mut HashMap<u64, Arc<RwLock<Self::Session>>>;
     fn guid(&self) -> Uuid;
@@ -198,6 +199,10 @@ impl<Addrs: Send + Sync, Listener: SMBSocket<Addrs>, Auth: AuthProvider, Share:
         0
     }
 
+    fn remove_open(&mut self, global_id: u32) {
+        self.open_table.remove(&global_id);
+    }
+
     fn sessions(&self) -> &HashMap<u64, Arc<RwLock<Self::Session>>> {
         &self.session_table
     }