feat: implement Write handler for E2E file write

smb-core/src/nt_status.rs

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

smb/src/main.rs

@@ -47,7 +47,12 @@ async fn main() -> SMBResult<()> {
     .unencrypted_access(true)
     .require_message_signing(false)
     .encrypt_data(false)
-    .add_fs_share("test".into(), "".into(), file_allowed, get_file_perms)
+    .add_fs_share(
+        "test".into(),
+        std::env::var("SMB_SHARE_PATH").unwrap_or_default(),
+        file_allowed,
+        get_file_perms,
+    )
     .add_ipc_share()
     .auth_provider(NTLMAuthProvider::new(
         vec![

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, PartialEq, Eq, SMBByteSize, SMBToBytes, SMBFromBytes, Serialize, Deserialize, Clone,
@@ -24,6 +24,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, Eq, SMBByteSize, SMBToBytes, SMBFromBytes, Serialize, Deserialize, Clone,
 )]
@@ -48,3 +58,118 @@ pub struct SMBCloseResponse {
     #[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, SMBFromBytes, SMBToBytes};
+
+    #[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::new(
+            FileTime::from_unix(1700000000),
+            FileTime::from_unix(1700000100),
+            FileTime::from_unix(1700000200),
+            FileTime::from_unix(1700000300),
+            4096,
+            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::new(
+            FileTime::from_unix(1700000000),
+            FileTime::from_unix(1700000100),
+            FileTime::from_unix(1700000200),
+            FileTime::from_unix(1700000300),
+            8192,
+            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::new(42, 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/create/file_id.rs

@@ -7,7 +7,75 @@ use smb_derive::{SMBByteSize, SMBFromBytes, SMBToBytes};
 )]
 pub struct SMBFileId {
     #[smb_direct(start(fixed = 0))]
-    pub persistent: u64,
+    persistent: u64,
     #[smb_direct(start(fixed = 8))]
-    pub volatile: u64,
+    volatile: u64,
+}
+
+impl SMBFileId {
+    pub fn new(persistent: u64, volatile: u64) -> Self {
+        Self {
+            persistent,
+            volatile,
+        }
+    }
+
+    pub fn persistent(&self) -> u64 {
+        self.persistent
+    }
+
+    pub fn volatile(&self) -> u64 {
+        self.volatile
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use smb_core::{SMBByteSize, SMBFromBytes, SMBToBytes};
+
+    /// MS-SMB2 section 2.2.14.1: SMB2_FILEID is 16 bytes (Persistent u64 + Volatile u64)
+    #[test]
+    fn file_id_is_16_bytes() {
+        let fid = SMBFileId::new(0, 0);
+        assert_eq!(fid.smb_byte_size(), 16);
+    }
+
+    /// Persistent is at offset 0, Volatile at offset 8
+    #[test]
+    fn file_id_wire_layout() {
+        let fid = SMBFileId::new(0xDEAD, 0xBEEF);
+        let bytes = fid.smb_to_bytes();
+        assert_eq!(bytes.len(), 16);
+        let persistent = u64::from_le_bytes(bytes[0..8].try_into().unwrap());
+        let volatile = u64::from_le_bytes(bytes[8..16].try_into().unwrap());
+        assert_eq!(persistent, 0xDEAD);
+        assert_eq!(volatile, 0xBEEF);
+    }
+
+    #[test]
+    fn file_id_round_trip() {
+        let fid = SMBFileId::new(42, 99);
+        let bytes = fid.smb_to_bytes();
+        let (_, parsed) = SMBFileId::smb_from_bytes(&bytes).unwrap();
+        assert_eq!(fid, parsed);
+    }
+
+    /// Per section 2.2.14.1, persistent and volatile are distinct fields.
+    /// Verify they serialize independently.
+    #[test]
+    fn file_id_persistent_and_volatile_are_independent() {
+        let a = SMBFileId::new(1, 2);
+        let b = SMBFileId::new(2, 1);
+        let bytes_a = a.smb_to_bytes();
+        let bytes_b = b.smb_to_bytes();
+        assert_ne!(bytes_a, bytes_b);
+    }
+
+    #[test]
+    fn file_id_getters() {
+        let fid = SMBFileId::new(100, 200);
+        assert_eq!(fid.persistent(), 100);
+        assert_eq!(fid.volatile(), 200);
+    }
 }

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

@@ -65,7 +65,7 @@ pub struct SMBCreateRequest {
     create_options: SMBCreateOptions,
     #[smb_string(
         order = 0,
-        start(inner(start = 44, num_type = "u16", subtract = 68)),
+        start(inner(start = 44, num_type = "u16", subtract = 64)),
         length(inner(start = 46, num_type = "u16")),
         underlying = "u16"
     )]
@@ -179,12 +179,12 @@ impl SMBCreateResponse {
             oplock_level: open.oplock_level(),
             flags: SMBCreateFlags::empty(),
             action: SMBCreateAction::Created,
-            creation_time: metadata.creation_time,
-            last_access_time: metadata.last_access_time,
-            last_write_time: metadata.last_write_time,
-            change_time: metadata.last_modification_time,
-            allocation_size: metadata.allocated_size,
-            end_of_file: metadata.actual_size,
+            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(),
             attributes: open.file_attributes(),
             reserved: PhantomData,
             file_id: open.file_id(),

smb/src/protocol/body/file_info/access.rs

@@ -0,0 +1,61 @@
+use bitflags::bitflags;
+use serde::{Deserialize, Serialize};
+
+use smb_derive::{SMBByteSize, SMBFromBytes, SMBToBytes};
+
+use crate::util::flags_helper::{
+    impl_smb_byte_size_for_bitflag, impl_smb_from_bytes_for_bitflag, impl_smb_to_bytes_for_bitflag,
+};
+
+bitflags! {
+    /// ACCESS_MASK flags for FILE_ACCESS_INFORMATION (MS-FSCC 2.4.1).
+    ///
+    /// These are the same ACCESS_MASK values defined in [MS-DTYP] §2.4.3 /
+    /// [MS-SMB2] §2.2.13.1, representing the access rights granted on the open.
+    #[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+    pub struct FileAccessFlags: u32 {
+        const FILE_READ_DATA         = 0x00000001;
+        const FILE_WRITE_DATA        = 0x00000002;
+        const FILE_APPEND_DATA       = 0x00000004;
+        const FILE_READ_EA           = 0x00000008;
+        const FILE_WRITE_EA          = 0x00000010;
+        const FILE_EXECUTE           = 0x00000020;
+        const FILE_DELETE_CHILD      = 0x00000040;
+        const FILE_READ_ATTRIBUTES   = 0x00000080;
+        const FILE_WRITE_ATTRIBUTES  = 0x00000100;
+        const DELETE                  = 0x00010000;
+        const READ_CONTROL           = 0x00020000;
+        const WRITE_DAC              = 0x00040000;
+        const WRITE_OWNER            = 0x00080000;
+        const SYNCHRONIZE            = 0x00100000;
+        const ACCESS_SYSTEM_SECURITY = 0x01000000;
+        const MAXIMUM_ALLOWED        = 0x02000000;
+        const GENERIC_ALL            = 0x10000000;
+        const GENERIC_EXECUTE        = 0x20000000;
+        const GENERIC_WRITE          = 0x40000000;
+        const GENERIC_READ           = 0x80000000;
+    }
+}
+
+impl_smb_byte_size_for_bitflag! { FileAccessFlags }
+impl_smb_to_bytes_for_bitflag! { FileAccessFlags }
+impl_smb_from_bytes_for_bitflag! { FileAccessFlags }
+
+/// FILE_ACCESS_INFORMATION (MS-FSCC 2.4.1) — 4 bytes
+#[derive(
+    Debug, PartialEq, Eq, Clone, Serialize, Deserialize, SMBByteSize, SMBFromBytes, SMBToBytes,
+)]
+pub struct FileAccessInformation {
+    #[smb_direct(start(fixed = 0))]
+    access_flags: FileAccessFlags,
+}
+
+impl FileAccessInformation {
+    pub fn new(access_flags: FileAccessFlags) -> Self {
+        Self { access_flags }
+    }
+
+    pub fn access_flags(&self) -> FileAccessFlags {
+        self.access_flags
+    }
+}