Day 3 Afternoon Exercises

Safe FFI Wrapper

(back to exercise)

  1. // Copyright 2022 Google LLC
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //      http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. // ANCHOR: ffi
  16. mod ffi {
  17.     use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};
  19.     // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.
  20.     #[repr(C)]
  21.     pub struct DIR {
  22.         _data: [u8; 0],
  23.         _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
  24.     }
  26.     // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-gnu.
  27.     #[repr(C)]
  28.     pub struct dirent {
  29.         pub d_ino: c_long,
  30.         pub d_off: c_ulong,
  31.         pub d_reclen: c_ushort,
  32.         pub d_type: c_char,
  33.         pub d_name: [c_char; 256],
  34.     }
  36.     extern "C" {
  37.         pub fn opendir(s: *const c_char) -> *mut DIR;
  38.         pub fn readdir(s: *mut DIR) -> *const dirent;
  39.         pub fn closedir(s: *mut DIR) -> c_int;
  40.     }
  41. }
  43. use std::ffi::{CStr, CString, OsStr, OsString};
  44. use std::os::unix::ffi::OsStrExt;
  46. #[derive(Debug)]
  47. struct DirectoryIterator {
  48.     path: CString,
  49.     dir: *mut ffi::DIR,
  50. }
  51. // ANCHOR_END: ffi
  53. // ANCHOR: DirectoryIterator
  54. impl DirectoryIterator {
  55.     fn new(path: &str) -> Result<DirectoryIterator, String> {
  56.         // Call opendir and return a Ok value if that worked,
  57.         // otherwise return Err with a message.
  58.         // ANCHOR_END: DirectoryIterator
  59.         let path = CString::new(path).map_err(|err| format!("Invalid path: {err}"))?;
  60.         // SAFETY: path.as_ptr() cannot be NULL.
  61.         let dir = unsafe { ffi::opendir(path.as_ptr()) };
  62.         if dir.is_null() {
  63.             Err(format!("Could not open {:?}", path))
  64.         } else {
  65.             Ok(DirectoryIterator { path, dir })
  66.         }
  67.     }
  68. }
  70. // ANCHOR: Iterator
  71. impl Iterator for DirectoryIterator {
  72.     type Item = OsString;
  73.     fn next(&mut self) -> Option<OsString> {
  74.         // Keep calling readdir until we get a NULL pointer back.
  75.         // ANCHOR_END: Iterator
  76.         // SAFETY: self.dir is never NULL.
  77.         let dirent = unsafe { ffi::readdir(self.dir) };
  78.         if dirent.is_null() {
  79.             // We have reached the end of the directory.
  80.             return None;
  81.         }
  82.         // SAFETY: dirent is not NULL and dirent.d_name is NUL
  83.         // terminated.
  84.         let d_name = unsafe { CStr::from_ptr((*dirent).d_name.as_ptr()) };
  85.         let os_str = OsStr::from_bytes(d_name.to_bytes());
  86.         Some(os_str.to_owned())
  87.     }
  88. }
  90. // ANCHOR: Drop
  91. impl Drop for DirectoryIterator {
  92.     fn drop(&mut self) {
  93.         // Call closedir as needed.
  94.         // ANCHOR_END: Drop
  95.         if !self.dir.is_null() {
  96.             // SAFETY: self.dir is not NULL.
  97.             if unsafe { ffi::closedir(self.dir) } != 0 {
  98.                 panic!("Could not close {:?}", self.path);
  99.             }
  100.         }
  101.     }
  102. }
  104. // ANCHOR: main
  105. fn main() -> Result<(), String> {
  106.     let iter = DirectoryIterator::new(".")?;
  107.     println!("files: {:#?}", iter.collect::<Vec<_>>());
  108.     Ok(())
  109. }
  110. // ANCHOR_END: main