Wrapper FFI seguro
Rust tem ótimo suporte para chamar funções por meio de uma interface para funções externas (Function Foreign Interface - FFI). Usaremos isso para construir um wrapper (invólucro) seguro para as funções da libc
de C que você usaria para ler os nomes dos arquivos de um diretório.
Você vai querer consultar as páginas do manual:
Você também vai querer navegar pelo módulo std::ffi
. Lá você encontrará um número de tipos de string que você precisará para o exercício:
Tipos | Codificação | Uso |
---|---|---|
str e String | UTF-8 | Processamento de texto em Rust |
CStr e CString | terminado em NUL | Comunicação com funções em C |
OsStr e OsString | específico ao SO | Comunicação com o SO |
Você irá converter entre todos estes tipos:
&str
paraCString
: você precisa alocar espaço para o caracter terminador\0
,CString
para*const i8
: você precisa de um ponteiro para chamar funções em C,*const i8
para&CStr
: você você precisa de algo que pode encontrar o caracter terminador\0
,&CStr
para&[u8]
: um slice de bytes é a interface universal para “algum dado desconhecido”,&[u8]
para&OsStr
:&OsStr
é um passo em direção aOsString
, useOsStrExt
para criá-lo,&OsStr
paraOsString
: você precisa clonar os dados em&OsStr
para poder retorná-lo e chamarreaddir
novamente.
O Nomicon também tem um capítulo bastante útil sobre FFI.
Copie o código abaixo para https://play.rust-lang.org/ e implemente as funções e métodos que faltam:
// TODO: remova isto quando você terminar sua implementação.
#![allow(unused_imports, unused_variables, dead_code)]
mod ffi {
use std::os::raw::{c_char, c_int};
#[cfg(not(target_os = "macos"))]
use std::os::raw::{c_long, c_uchar, c_ulong, c_ushort};
// Tipo opaco. Veja https://doc.rust-lang.org/nomicon/ffi.html.
#[repr(C)]
pub struct DIR {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
// Layout de acordo com a página man do Linux para readdir(3), onde ino_t e
// off_t são resolvidos de acordo com as definições em
// /usr/include/x86_64-linux-gnu/{sys/types.h, bits/typesizes.h}.
#[cfg(not(target_os = "macos"))]
#[repr(C)]
pub struct dirent {
pub d_ino: c_ulong,
pub d_off: c_long,
pub d_reclen: c_ushort,
pub d_type: c_uchar,
pub d_name: [c_char; 256],
}
// Layout de acordo com a página man do macOS man page para dir(5).
#[cfg(all(target_os = "macos"))]
#[repr(C)]
pub struct dirent {
pub d_fileno: u64,
pub d_seekoff: u64,
pub d_reclen: u16,
pub d_namlen: u16,
pub d_type: u8,
pub d_name: [c_char; 1024],
}
extern "C" {
pub fn opendir(s: *const c_char) -> *mut DIR;
#[cfg(not(all(target_os = "macos", target_arch = "x86_64")))]
pub fn readdir(s: *mut DIR) -> *const dirent;
// Veja https://github.com/rust-lang/libc/issues/414 e a seção sobre
// _DARWIN_FEATURE_64_BIT_INODE na página man do macOS para stat(2).
//
// "Plataformas que existiram antes destas atualizações estarem disponíveis" refere-se
// ao macOS (ao contrário do iOS / wearOS / etc.) em Intel e PowerPC.
#[cfg(all(target_os = "macos", target_arch = "x86_64"))]
#[link_name = "readdir$INODE64"]
pub fn readdir(s: *mut DIR) -> *const dirent;
pub fn closedir(s: *mut DIR) -> c_int;
}
}
use std::ffi::{CStr, CString, OsStr, OsString};
use std::os::unix::ffi::OsStrExt;
#[derive(Debug)]
struct DirectoryIterator {
path: CString,
dir: *mut ffi::DIR,
}
impl DirectoryIterator {
fn new(path: &str) -> Result<DirectoryIterator, String> {
// Chama opendir e retorna um valor Ok se funcionar,
// ou retorna Err com uma mensagem.
unimplemented!()
}
}
impl Iterator for DirectoryIterator {
type Item = OsString;
fn next(&mut self) -> Option<OsString> {
// Continua chamando readdir até nós obtermos um ponteiro NULL de volta.
unimplemented!()
}
}
impl Drop for DirectoryIterator {
fn drop(&mut self) {
// Chama closedir se necessário.
unimplemented!()
}
}
fn main() -> Result<(), String> {
let iter = DirectoryIterator::new(".")?;
println!("files: {:#?}", iter.collect::<Vec<_>>());
Ok(())
}