<h2>FFI em Rust: Interoperabilidade com C e Outras Linguagens</h2>
<p>FFI (Foreign Function Interface) é o mecanismo que permite código Rust chamar funções escritas em outras linguagens, particularmente C, e vice-versa. Rust oferece suporte robusto a FFI através de palavras-chave como <code>extern</code> e atributos de compilação, mantendo segurança de memória mesmo ao cruzar fronteiras linguísticas. Este é um tópico crítico para integrar bibliotecas legadas, usar APIs do sistema operacional ou otimizar gargalos com código compilado de terceiros.</p>
<h3>Por que FFI importa</h3>
<p>A maioria dos projetos Rust em produção precisam interagir com código C em algum momento—seja libc no Linux, APIs do Windows, ou bibliotecas científicas como OpenSSL e BLAS. Dominar FFI significa poder aproveitar todo o ecossistema existente enquanto mantém a confiabilidade do Rust.</p>
<h2>Fundamentos: Chamando C a partir de Rust</h2>
<h3>Declarações <code>extern</code></h3>
<p>Para chamar uma função C, você a declara usando <code>extern "C"</code>. O bloco <code>extern "C"</code> instrui o compilador a usar a convenção de chamada C e não fazer name-mangling, essencial para compatibilidade.</p>
<pre><code class="language-rust">// Declarando funções C do libc
extern "C" {
fn strlen(s: *const u8) -> usize;
fn printf(format: *const u8, ...) -> i32;
}
fn main() {
let text = b"Hello, FFI!\0";
unsafe {
let len = strlen(text.as_ptr());
println!("Comprimento: {}", len);
}
}</code></pre>
<p>Todo acesso a código C exige bloco <code>unsafe</code> porque o compilador Rust não pode verificar se a função respeitará os contratos de segurança. A responsabilidade recai sobre o programador: garantir ponteiros válidos, tipos corretos e que a função não violará invariantes de memória.</p>
<h3>Tipos nativos em FFI</h3>
<p>Rust mapeia tipos para C naturalmente: <code>i32</code> → <code>int</code>, <code>u64</code> → <code>uint64_t</code>, <code>f64</code> → <code>double</code>. Para tipos mais complexos ou opacos, use ponteiros (<code><em>const</code> ou <code></em>mut</code>). Strings em C são <code>*const u8</code> (null-terminated). Estruturas podem ser representadas diretamente se seu layout for compatível com <code>#[repr(C)]</code>.</p>
<pre><code class="language-rust">#[repr(C)]
struct Point {
x: f64,
y: f64,
}
extern "C" {
fn process_point(p: Point) -> f64;
}
fn main() {
let pt = Point { x: 3.0, y: 4.0 };
unsafe {
let result = process_point(pt);
println!("Resultado: {}", result);
}
}</code></pre>
<h2>Exportando Rust para C: Tornando Rust uma Biblioteca</h2>
<h3>Compilando como biblioteca C</h3>
<p>Você pode compilar Rust como arquivo objeto <code>.o</code> ou biblioteca dinâmica <code>.so</code>/<code>.dll</code>. Configure seu <code>Cargo.toml</code> com <code>crate-type = ["cdylib"]</code> para gerar uma biblioteca que C pode consumir.</p>
<pre><code class="language-toml">[lib]
crate-type = ["cdylib"]
[package]
name = "minha_lib"
version = "0.1.0"</code></pre>
<p>Funções exportadas devem usar <code>extern "C"</code> e ser públicas. Mantenha a simplicidade: evite tipos complexos de Rust, prefira tipos primitivos e ponteiros.</p>
<pre><code class="language-rust">use std::ffi::CStr;
use std::os::raw::c_char;
#[no_mangle]
pub extern "C" fn saudacao(nome: const c_char) -> mut c_char {
let nome_rust = unsafe {
CStr::from_ptr(nome).to_str().unwrap_or("Desconhecido")
};
let msg = format!("Olá, {}!", nome_rust);
let ptr = Box::into_raw(msg.into_boxed_str() as Box<[u8]>);
ptr as *mut c_char
}
#[no_mangle]
pub extern "C" fn liberar_string(ptr: *mut c_char) {
if !ptr.is_null() {
unsafe { Box::from_raw(ptr); }
}
}</code></pre>
<p>O atributo <code>#[no_mangle]</code> previne que o compilador renomeie a função, garantindo que C a encontre pelo nome esperado. Sempre forneça uma função para liberar memória alocada em Rust.</p>
<h2>Gerenciamento de Segurança em FFI</h2>
<h3>Validação e bounds checking</h3>
<p>Código C não respeita tipos Rust. Um ponteiro pode ser inválido, nulo ou apontar para memória já liberada. Antes de desreferenciar, sempre valide:</p>
<pre><code class="language-rust">extern "C" {
fn get_buffer(size: mut usize) -> mut u8;
fn free_buffer(ptr: *mut u8);
}
fn safe_wrapper() -> Vec<u8> {
let mut size = 0usize;
let ptr = unsafe { get_buffer(&mut size as *mut usize) };
if ptr.is_null() || size == 0 {
return Vec::new();
}
let slice = unsafe { std::slice::from_raw_parts(ptr, size) };
let vec = slice.to_vec();
unsafe { free_buffer(ptr); }
vec
}</code></pre>
<h3>Garantias de thread-safety</h3>
<p>Se sua função será chamada de múltiplas threads, use sincronização explícita. C não garante thread-safety por padrão—essa responsabilidade é sua ao exportar funções.</p>
<pre><code class="language-rust">use std::sync::Mutex;
lazy_static::lazy_static! {
static ref COUNTER: Mutex<i32> = Mutex::new(0);
}
#[no_mangle]
pub extern "C" fn increment() -> i32 {
let mut count = COUNTER.lock().unwrap();
*count += 1;
*count
}</code></pre>
<h2>Boas Práticas e Padrões</h2>
<h3>Use wrappers seguros</h3>
<p>Sempre encapsule <code>unsafe</code> em funções seguras que validam precondições:</p>
<pre><code class="language-rust">pub fn chamar_c_seguro(valor: i32) -> Result<i32, String> {
if valor < 0 {
return Err("Valor negativo não permitido".to_string());
}
unsafe {
Ok(minha_funcao_c(valor))
}
}
extern "C" {
fn minha_funcao_c(x: i32) -> i32;
}</code></pre>
<h3>Crates para FFI</h3>
<p>O ecossistema oferece ferramentas valiosas: <code>bindgen</code> gera automaticamente bindings Rust a partir de headers C, <code>cc</code> compila código C junto com seu projeto, e <code>libc</code> fornece tipos e funções do C padrão. Use-as para reduzir erros manuais.</p>
<pre><code class="language-bash">cargo add bindgen --build</code></pre>
<h2>Conclusão</h2>
<p>FFI em Rust abre acesso a décadas de código C otimizado e testado, mas exige disciplina. Três pontos fundamentais: (1) <strong>use <code>extern "C"</code> e blocos <code>unsafe</code> conscientemente</strong>, validando sempre ponteiros e tamanhos; (2) <strong>encapsule FFI em abstrações seguras</strong> que escondem detalhes perigosos do resto do código; (3) <strong>aproveite ferramentas como <code>bindgen</code></strong> para minimizar erros de tradução manual. Dominar FFI transforma Rust de uma linguagem isolada em um membro de primeira classe do ecossistema de sistemas.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://doc.rust-lang.org/reference/items/external-blocks.html" target="_blank" rel="noopener noreferrer">The Rust Reference - FFI</a></li>
<li><a href="https://doc.rust-lang.org/nomicon/ffi.html" target="_blank" rel="noopener noreferrer">The Rustonomicon - FFI Chapter</a></li>
<li><a href="https://rust-lang.github.io/rust-bindgen/" target="_blank" rel="noopener noreferrer">Bindgen - Automatic C Bindings</a></li>
<li><a href="https://docs.rs/cc/latest/cc/" target="_blank" rel="noopener noreferrer">LLVM CC Crate for Compiling C Code</a></li>
<li><a href="https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/" target="_blank" rel="noopener noreferrer">Programming Rust - Systems Programming by Jim Blandy and Jason Orendorff</a></li>
</ul>