add query file+dir for integration tests

Author: afiffon

smb-cli/src/info.rs

@@ -23,7 +23,7 @@ pub async fn info(info: &InfoCmd, cli: &Cli) -> Result<(), Box<dyn Error>> {
                 let security = file.query_security_info().await?;
                 log::info!("Security info: {:?}", security);
             }
-            Resource::Directory(mut dir) => {
+            Resource::Directory(dir) => {
                 let infos = dir.query::<FileIdBothDirectoryInformation>("*").await?;
                 for item in infos.iter() {
                     log::info!(

smb/src/packets/smb2/fscc/common_info.rs

@@ -93,5 +93,5 @@ pub struct FileNameInformation {
     #[bw(try_calc = file_name.size().try_into())]
     file_name_length: u32,
     #[br(args(file_name_length as u64))]
-    file_name: SizedWideString,
+    pub file_name: SizedWideString,
 }

smb/src/packets/smb2/fscc/query_file_info.rs

@@ -51,21 +51,21 @@ pub type QueryFileFullEaInformation = FileFullEaInformation;
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileAccessInformation {
-    access_flags: FileAccessMask,
+    pub access_flags: FileAccessMask,
 }
 
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileAllInformation {
-    basic: FileBasicInformation,
-    standard: FileStandardInformation,
-    internal: FileInternalInformation,
-    ea: FileEaInformation,
-    access: FileAccessInformation,
-    position: FilePositionInformation,
-    mode: FileModeInformation,
-    alignment: FileAlignmentInformation,
-    name: FileNameInformation,
+    pub basic: FileBasicInformation,
+    pub standard: FileStandardInformation,
+    pub internal: FileInternalInformation,
+    pub ea: FileEaInformation,
+    pub access: FileAccessInformation,
+    pub position: FilePositionInformation,
+    pub mode: FileModeInformation,
+    pub alignment: FileAlignmentInformation,
+    pub name: FileNameInformation,
 }
 
 #[binrw::binrw]
@@ -101,18 +101,18 @@ impl Deref for FileAlternateNameInformation {
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileAttributeTagInformation {
-    file_attributes: u32,
-    reparse_tag: u32,
+    pub file_attributes: u32,
+    pub reparse_tag: u32,
 }
 
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileCompressionInformation {
-    compressed_file_size: u64,
-    compression_format: FileCompressionFormat,
-    compression_unit: u8,
-    chunk_shift: u8,
-    cluster_shift: u8,
+    pub compressed_file_size: u64,
+    pub compression_format: FileCompressionFormat,
+    pub compression_unit: u8,
+    pub chunk_shift: u8,
+    pub cluster_shift: u8,
     #[br(parse_with = binrw::helpers::read_u24)]
     #[br(assert(reserved == 0))]
     #[bw(align_before = 4)]
@@ -131,32 +131,32 @@ pub enum FileCompressionFormat {
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileEaInformation {
-    ea_size: u32,
+    pub ea_size: u32,
 }
 
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileIdInformation {
-    volume_serial_number: u64,
-    file_id: u128,
+    pub volume_serial_number: u64,
+    pub file_id: u128,
 }
 
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileInternalInformation {
-    index_number: u64,
+    pub index_number: u64,
 }
 
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileNetworkOpenInformation {
-    creation_time: FileTime,
-    last_access_time: FileTime,
-    last_write_time: FileTime,
-    change_time: FileTime,
-    allocation_size: u64,
-    end_of_file: u64,
-    file_attributes: FileAttributes,
+    pub creation_time: FileTime,
+    pub last_access_time: FileTime,
+    pub last_write_time: FileTime,
+    pub change_time: FileTime,
+    pub allocation_size: u64,
+    pub end_of_file: u64,
+    pub file_attributes: FileAttributes,
     #[bw(calc = 0)]
     _reserved: u32,
 }
@@ -178,15 +178,15 @@ impl Deref for FileNormalizedNameInformation {
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FilePipeLocalInformation {
-    named_pipe_type: NamedPipeType,
-    named_pipe_configuration: NamedPipeConfiguration,
-    maximum_instances: u32,
-    current_instances: u32,
-    inbound_quota: u32,
-    outbound_quota: u32,
-    write_quota: u32,
-    named_pipe_state: NamedPipeState,
-    named_pipe_end: NamedPipeEnd,
+    pub named_pipe_type: NamedPipeType,
+    pub named_pipe_configuration: NamedPipeConfiguration,
+    pub maximum_instances: u32,
+    pub current_instances: u32,
+    pub inbound_quota: u32,
+    pub outbound_quota: u32,
+    pub write_quota: u32,
+    pub named_pipe_state: NamedPipeState,
+    pub named_pipe_end: NamedPipeEnd,
 }
 
 #[binrw::binrw]
@@ -227,18 +227,18 @@ pub enum NamedPipeEnd {
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FilePipeRemoteInformation {
-    collect_data_time: FileTime,
-    maximum_collection_count: u32,
+    pub collect_data_time: FileTime,
+    pub maximum_collection_count: u32,
 }
 
 #[binrw::binrw]
 #[derive(Debug, PartialEq, Eq)]
 pub struct FileStandardInformation {
-    allocation_size: u64,
-    end_of_file: u64,
-    number_of_links: u32,
-    delete_pending: Boolean,
-    directory: Boolean,
+    pub allocation_size: u64,
+    pub end_of_file: u64,
+    pub number_of_links: u32,
+    pub delete_pending: Boolean,
+    pub directory: Boolean,
     #[bw(calc = 0)]
     #[br(assert(reserved == 0))]
     reserved: u16,
@@ -249,8 +249,8 @@ pub struct FileStandardInformation {
 pub struct FileStreamInformation {
     #[bw(try_calc = stream_name.size().try_into())]
     stream_name_length: u32,
-    stream_size: u64,
-    stream_allocation_size: u64,
+    pub stream_size: u64,
+    pub stream_allocation_size: u64,
     #[br(args(stream_name_length as u64))]
     stream_name: SizedWideString,
 }

smb/src/packets/smb2/info/query.rs

@@ -276,7 +276,9 @@ mod tests {
                 .with_dacl_security_information(true)
                 .with_sacl_security_information(true),
             flags: QueryInfoFlags::new(),
-            file_id: Guid::from_str("0000002b-000d-0000-3100-00000d000000").unwrap().into(),
+            file_id: Guid::from_str("0000002b-000d-0000-3100-00000d000000")
+                .unwrap()
+                .into(),
             data: GetInfoRequestData::None(()),
         }));
         assert_eq!(

smb/src/packets/smb2/info/set.rs

@@ -5,10 +5,7 @@ use crate::{packets::smb2::SecurityDescriptor, query_info_data};
 
 use super::common::*;
 use super::{
-    super::{
-        super::binrw_util::prelude::*,
-        fscc::*,
-    },
+    super::{super::binrw_util::prelude::*, fscc::*},
     QueryQuotaInfo,
 };
 use binrw::io::TakeSeekExt;

smb/src/resource/directory.rs

@@ -15,7 +15,7 @@ impl Directory {
 
     // Query the directory for it's contents.
     #[maybe_async]
-    pub async fn query<T>(&mut self, pattern: &str) -> crate::Result<Vec<T>>
+    pub async fn query<T>(&self, pattern: &str) -> crate::Result<Vec<T>>
     where
         T: QueryDirectoryInfoValue,
     {

smb/tests/integration_tests.rs

@@ -2,43 +2,41 @@ use log::info;
 use serial_test::serial;
 use smb::{
     connection::EncryptionMode,
-    packets::smb2::{CreateDisposition, Dialect, FileAccessMask},
+    packets::smb2::{
+        CreateDisposition, Dialect, FileAccessMask, FileAllInformation, FileDirectoryInformation,
+    },
     Connection, ConnectionConfig,
 };
 use std::env::var;
 
 macro_rules! parametrize_dialect {
-    ($($dialect:ident),*) => {
+    ([$dialect:ident], [$($encrypt_mode:ident),*]) => {
         $(
             paste::paste! {
                 #[maybe_async::test(
                     feature = "sync",
                     async(feature = "async", tokio::test(flavor = "multi_thread"))
                 )]
                 #[serial]
-                pub async fn [<test_smb_integration_ $dialect:lower>]() -> Result<(), Box<dyn std::error::Error>> {
-                    test_smb_integration_basic(Dialect::$dialect).await
+                pub async fn [<test_smbint_ $dialect:lower _e $encrypt_mode:lower>]() -> Result<(), Box<dyn std::error::Error>> {
+                    test_smb_integration_basic(Dialect::$dialect, EncryptionMode::$encrypt_mode).await
                 }
             }
         )*
     };
-}
 
-parametrize_dialect!(Smb030, Smb0302, Smb0311);
+    ([$($dialect:ident),*], $encrypt_modes:tt) => {
+        $(
+            parametrize_dialect!([$dialect],  $encrypt_modes);
+        )*
+    };
 
-#[maybe_async::maybe_async]
-pub async fn test_smb_integration_basic(
-    force_dialect: Dialect,
-) -> Result<(), Box<dyn std::error::Error>> {
-    for encryption_mode in &[EncryptionMode::Required, EncryptionMode::Disabled] {
-        info!("Testing with encryption mode: {:?}", encryption_mode);
-        test_smb_integration_basic_with_encryption(force_dialect, *encryption_mode).await?;
-    }
-    Ok(())
 }
 
+parametrize_dialect!([Smb030, Smb0302, Smb0311], [Disabled, Required]);
+
 #[maybe_async::maybe_async]
-async fn test_smb_integration_basic_with_encryption(
+async fn test_smb_integration_basic(
     force_dialect: Dialect,
     encryption_mode: EncryptionMode,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -77,11 +75,14 @@ async fn test_smb_integration_basic_with_encryption(
         .await?;
     info!("Connected to share, start test basic");
 
+    const TEST_FILE: &str = "test.txt";
+    const TEST_DATA: &[u8] = b"Hello, World!";
+
     // Hello, World! > test.txt
     {
         let mut file = tree
             .create(
-                "test.txt",
+                TEST_FILE,
                 CreateDisposition::Create,
                 FileAccessMask::new()
                     .with_generic_read(true)
@@ -90,13 +91,31 @@ async fn test_smb_integration_basic_with_encryption(
             .await?
             .unwrap_file();
 
-        file.write(b"Hello, World!").await?;
+        file.write(TEST_DATA).await?;
+    }
+
+    // Query directory and make sure our file exists there:
+    {
+        let dir_info = tree
+            .create(
+                "",
+                CreateDisposition::Open,
+                FileAccessMask::new().with_generic_read(true),
+            )
+            .await?
+            .unwrap_dir();
+        dir_info
+            .query::<FileDirectoryInformation>("*")
+            .await?
+            .iter()
+            .find(|info| info.file_name.to_string() == TEST_FILE)
+            .expect("File not found in directory");
     }
 
     {
         let file = tree
             .create(
-                "test.txt",
+                TEST_FILE,
                 CreateDisposition::Open,
                 FileAccessMask::new()
                     .with_generic_read(true)
@@ -105,14 +124,23 @@ async fn test_smb_integration_basic_with_encryption(
             .await?
             .unwrap_file();
 
-        let mut buf = [0u8; 15];
-        let read_length = file.read_block(&mut buf, 0).await?;
-        assert_eq!(read_length, 13);
-        assert_eq!(&buf[..13], b"Hello, World!");
+        // So anyway it will be deleted at the end.
         file.set_file_info(FileDispositionInformation {
             delete_pending: true.into(),
         })
         .await?;
+
+        let mut buf = [0u8; TEST_DATA.len() + 2];
+        let read_length = file.read_block(&mut buf, 0).await?;
+        assert_eq!(read_length, TEST_DATA.len());
+        assert_eq!(&buf[..read_length], TEST_DATA);
+
+        let all_info = file.query_info::<FileAllInformation>().await?;
+        assert_eq!(
+            all_info.name.file_name.to_string(),
+            "\\".to_string() + TEST_FILE
+        );
+        assert_eq!(all_info.standard.end_of_file, TEST_DATA.len() as u64);
     }
 
     Ok(())