Support FreeBSD-specific behavior in readdir interop test.

Filed https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=253411 for the
behavior of `(struct dirent*)->d_off`, which appears to be broken in the
upstream kernel driver.

issue: #5

Author: jmillikin

fuse/src/protocol/readdir/readdir_interop_test.rs

@@ -15,6 +15,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::num::NonZeroU64;
+use std::os::unix::ffi::OsStrExt;
 use std::sync::mpsc;
 use std::{ffi, panic};
 
@@ -70,7 +71,6 @@ impl fuse::FuseHandlers for TestFS {
 		respond: impl for<'a> fuse::Respond<fuse::ReaddirResponse<'a>>,
 	) {
 		self.requests.send(format!("{:#?}", request)).unwrap();
-		//self.requests.send(format!("{:#?}", request));
 
 		let mut cursor: u64 = match request.cursor() {
 			Some(x) => x.into(),
@@ -144,152 +144,203 @@ fn readdir() {
 		assert!(!dir_p.is_null());
 
 		let next_dirent = |expect| {
-			let mut entry = libc::dirent {
-				d_ino: 0,
-				d_off: 0,
-				d_reclen: 0,
-				d_type: 0,
-				d_name: [0; 256],
-			};
-			let mut result = std::ptr::null_mut();
-			let rc = unsafe { libc::readdir_r(dir_p, &mut entry, &mut result) };
-			assert_eq!(rc, 0);
-			if let Some(diff) = diff_dirent(&expect, &entry) {
+			let entry = unsafe { libc::readdir(dir_p) };
+			assert!(!entry.is_null());
+			if let Some(diff) = diff_dirent(expect, unsafe { &*entry }) {
 				println!("{}", diff);
 				assert!(false);
 			}
 		};
 
-		next_dirent(libc::dirent {
+		next_dirent(dirent {
 			d_ino: 10,
 			d_off: 1,
 			d_reclen: 32,
 			d_type: libc::DT_REG,
+			#[cfg(target_os = "freebsd")]
+			d_namlen: 7,
 			d_name: dirent_name_new(b"entry_a"),
 		});
 		let pos = unsafe { libc::telldir(dir_p) };
-		next_dirent(libc::dirent {
+		next_dirent(dirent {
 			d_ino: 11,
 			d_off: 2,
 			d_reclen: 32,
 			d_type: libc::DT_LNK,
+			#[cfg(target_os = "freebsd")]
+			d_namlen: 7,
 			d_name: dirent_name_new(b"entry_b"),
 		});
 		unsafe {
 			libc::seekdir(dir_p, pos)
 		};
-		next_dirent(libc::dirent {
+		next_dirent(dirent {
 			d_ino: 11,
 			d_off: 2,
 			d_reclen: 32,
 			d_type: libc::DT_LNK,
+			#[cfg(target_os = "freebsd")]
+			d_namlen: 7,
 			d_name: dirent_name_new(b"entry_b"),
 		});
-		next_dirent(libc::dirent {
+		next_dirent(dirent {
 			d_ino: 12,
 			d_off: 3,
 			d_reclen: 32,
 			d_type: libc::DT_DIR,
+			#[cfg(target_os = "freebsd")]
+			d_namlen: 7,
 			d_name: dirent_name_new(b"entry_c"),
 		});
 
 		unsafe {
 			libc::closedir(dir_p)
 		};
 	});
-	assert_eq!(requests.len(), 3);
 
-	let expect = r#"ReaddirRequest {
+	#[cfg(target_os = "linux")]
+	{
+		assert_eq!(requests.len(), 3);
+
+		let expect = r#"ReaddirRequest {
     node_id: 2,
     size: 4096,
     cursor: None,
     handle: 12345,
     opendir_flags: 0x00018000,
 }"#;
-	if let Some(diff) = diff_str(expect, &requests[0]) {
-		println!("{}", diff);
-		assert!(false);
-	}
+		if let Some(diff) = diff_str(expect, &requests[0]) {
+			println!("{}", diff);
+			assert!(false);
+		}
 
-	let expect = r#"ReaddirRequest {
+		let expect = r#"ReaddirRequest {
     node_id: 2,
     size: 4096,
     cursor: Some(1),
     handle: 12345,
     opendir_flags: 0x00018000,
 }"#;
-	if let Some(diff) = diff_str(expect, &requests[1]) {
-		println!("{}", diff);
-		assert!(false);
-	}
+		if let Some(diff) = diff_str(expect, &requests[1]) {
+			println!("{}", diff);
+			assert!(false);
+		}
 
-	let expect = r#"ReaddirRequest {
+		let expect = r#"ReaddirRequest {
     node_id: 2,
     size: 4096,
     cursor: Some(2),
     handle: 12345,
     opendir_flags: 0x00018000,
 }"#;
-	if let Some(diff) = diff_str(expect, &requests[2]) {
-		println!("{}", diff);
-		assert!(false);
+		if let Some(diff) = diff_str(expect, &requests[2]) {
+			println!("{}", diff);
+			assert!(false);
+		}
+	}
+
+	#[cfg(target_os = "freebsd")]
+	{
+		assert_eq!(requests.len(), 2);
+
+		let expect = r#"ReaddirRequest {
+    node_id: 2,
+    size: 4096,
+    cursor: None,
+    handle: 12345,
+    opendir_flags: 0x00000000,
+}"#;
+		if let Some(diff) = diff_str(expect, &requests[0]) {
+			println!("{}", diff);
+			assert!(false);
+		}
+
+		let expect = r#"ReaddirRequest {
+    node_id: 2,
+    size: 4096,
+    cursor: Some(2),
+    handle: 12345,
+    opendir_flags: 0x00000000,
+}"#;
+		if let Some(diff) = diff_str(expect, &requests[1]) {
+			println!("{}", diff);
+			assert!(false);
+		}
 	}
 }
 
-#[derive(Debug)]
 #[allow(non_camel_case_types)]
 struct dirent<'a> {
 	d_ino: libc::ino_t,
 	d_off: libc::off_t,
 	d_reclen: libc::c_ushort,
-	d_type: String,
-	d_name: &'a ffi::CStr,
+	d_type: u8,
+	#[cfg(target_os = "freebsd")]
+	d_namlen: u16,
+	d_name: &'a ffi::OsStr,
 }
 
-fn diff_dirent(expect: &libc::dirent, got: &libc::dirent) -> Option<String> {
-	let expect = format!(
-		"{:#?}",
-		&dirent {
-			d_ino: expect.d_ino,
-			d_off: expect.d_off,
-			d_reclen: expect.d_reclen,
-			d_type: dirent_type_name(expect),
-			d_name: dirent_name(expect),
-		}
-	);
+impl std::fmt::Debug for dirent<'_> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		let d_type = dirent_type_name(self);
+		let mut s = fmt.debug_struct("dirent");
+		#[cfg(target_os = "linux")]
+		s.field("d_ino", &self.d_ino);
+		#[cfg(target_os = "freebsd")]
+		s.field("d_fileno", &self.d_ino);
+		s.field("d_off", &self.d_off);
+		s.field("d_reclen", &self.d_reclen);
+		s.field("d_type", &format_args!("{}", &d_type));
+		#[cfg(target_os = "freebsd")]
+		s.field("d_namlen", &self.d_namlen);
+		s.field("d_name", &self.d_name);
+		s.finish()
+	}
+}
+
+#[allow(unused_mut)]
+fn diff_dirent(mut expect: dirent, got: &libc::dirent) -> Option<String> {
+	// https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=253411
+	#[cfg(target_os = "freebsd")]
+	{
+		expect.d_off = 0;
+	}
+
+	let expect = format!("{:#?}", &expect);
 	let got = format!(
 		"{:#?}",
 		dirent {
+			#[cfg(target_os = "linux")]
 			d_ino: got.d_ino,
+			#[cfg(target_os = "freebsd")]
+			d_ino: got.d_fileno,
 			d_off: got.d_off,
 			d_reclen: got.d_reclen,
-			d_type: dirent_type_name(got),
+			d_type: got.d_type,
+			#[cfg(target_os = "freebsd")]
+			d_namlen: got.d_namlen,
 			d_name: dirent_name(got),
 		}
 	);
 	diff_str(&expect, &got)
 }
 
-fn dirent_name(dirent: &libc::dirent) -> &ffi::CStr {
+fn dirent_name(dirent: &libc::dirent) -> &ffi::OsStr {
 	let bytes: &[u8] = unsafe { std::mem::transmute(&dirent.d_name as &[i8]) };
 	for (ii, byte) in bytes.iter().enumerate() {
 		if *byte == 0 {
-			let (cstr, _) = bytes.split_at(ii + 1);
-			return ffi::CStr::from_bytes_with_nul(cstr).unwrap();
+			let (name, _) = bytes.split_at(ii);
+			return ffi::OsStr::from_bytes(name);
 		}
 	}
 	panic!("no NUL in dirent d_name")
 }
 
-fn dirent_name_new(name: &[u8]) -> [i8; 256] {
-	let mut buf = [0i8; 256];
-	let buf_u8: &mut [u8] =
-		unsafe { std::mem::transmute(&mut buf as &mut [i8]) };
-	buf_u8[..name.len()].copy_from_slice(name);
-	buf
+fn dirent_name_new(name: &[u8]) -> &ffi::OsStr {
+	ffi::OsStr::from_bytes(name)
 }
 
-fn dirent_type_name(dirent: &libc::dirent) -> String {
+fn dirent_type_name(dirent: &dirent) -> String {
 	match dirent.d_type {
 		libc::DT_BLK => "DT_BLK".to_string(),
 		libc::DT_CHR => "DT_CHR".to_string(),