《Rust编程实战》7.3 FFI接口开发

7.3 FFI 接口开发

Rust 的 Foreign Function Interface (FFI) 允许与其他编程语言（特别是 C）无缝交互。这使得 Rust 在底层系统开发和与现有库的集成中表现出色。FFI 是 Unsafe 的一个重要应用场景，需要开发者明确安全性假设并细致验证。

7.3.1 FFI 的基础概念

1. 什么是 FFI？

FFI 是一组机制，用于调用其他语言编写的函数或将 Rust 的函数暴露给其他语言。在 Rust 中，FFI 主要通过 extern 关键字实现。

2. 使用场景

• 调用 C 库函数（如 OpenSSL、libc 等）。
• 将 Rust 函数暴露为 C 接口，供其他语言调用。
• 在跨语言项目中整合高性能模块。

3. FFI 的风险

由于 Rust 无法验证外部代码的内存安全性，FFI 调用被标记为 Unsafe。常见风险包括：

• 外部函数可能不符合约定（例如，指针为空或缓冲区越界）。
• 内存管理不匹配，导致泄漏或未定义行为。

7.3.2 调用 C 函数

Rust 可以直接调用 C 函数，通过 extern "C" 声明接口。

基本步骤

1. 声明外部函数。
2. 确保链接到正确的动态或静态库。
3. 在调用前验证输入输出参数的正确性。

示例：调用标准 C 函数

以下示例调用 C 标准库中的 abs 函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

extern "C" {
    fn abs(input: i32) -> i32;
}

fn call_abs(x: i32) -> i32 {
    unsafe { abs(x) }
}

fn main() {
    let result = call_abs(-42);
    println!("Absolute value: {}", result);
}

注意事项

• extern "C" 声明指明了调用约定（ABI），确保 Rust 和 C 之间的调用兼容。
• 使用 unsafe 调用外部函数，开发者需要确保参数和返回值的正确性。

7.3.3 向 C 暴露 Rust 函数

Rust 函数可以暴露为 C 接口，供其他语言调用。通过 #[no_mangle] 和 extern "C" 配合实现。

示例：暴露函数

1
2
3
4

#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

• #[no_mangle]：防止编译器优化修改函数名。
• extern "C"：指定调用约定。

在 C 中可以这样调用：

1
2
3
4
5
6
7
8
9

#include <stdio.h>

// Rust 编译后生成的库
int add(int a, int b);

int main() {
    printf("Result: %d\n", add(3, 4));
    return 0;
}

注意事项

• 确保编译生成的库文件（如 .so 或 .dll）可以被链接。
• 需要匹配 Rust 和 C 的类型和调用约定。

7.3.4 与指针交互

FFI 经常需要处理指针，包括裸指针、动态分配内存和字符串。

示例：字符串的传递

C 使用以空字符结尾的字符串（C 字符串），与 Rust 的字符串有显著差异。

Rust 调用 C 接口：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

extern "C" {
    fn puts(s: *const i8);
}

fn main() {
    let message = "Hello from Rust!";
    unsafe {
        puts(message.as_ptr() as *const i8);
    }
}

C 调用 Rust 接口：

1
2
3
4
5
6
7
8
9

#[no_mangle]
pub extern "C" fn print_message(ptr: *const i8) {
    unsafe {
        if !ptr.is_null() {
            let c_str = std::ffi::CStr::from_ptr(ptr);
            println!("Message from C: {:?}", c_str);
        }
    }
}

注意事项

• 检查指针是否为空，避免解引用空指针。
• 使用 std::ffi::CStr 和 CString 进行字符串的转换。

7.3.5 动态库与静态库

FFI 通常涉及编译动态库或静态库，以供其他语言使用。

编译动态库

使用 Rust 的 crate-type 属性生成动态库（*.so 或 *.dll）。

Cargo.toml 设置：

1
2
3

[lib]
name = "my_library"
crate-type = ["cdylib"]

执行 cargo build --release 生成动态库文件。

链接库

在 C 或其他语言中链接 Rust 编译的库文件，确保路径和库名正确。

7.3.6 安全性最佳实践

1. 封装 FFI 调用
   将 FFI 调用封装在安全接口中，避免直接暴露不安全的操作。

2. 验证输入参数
   在调用外部函数前检查输入参数的有效性，例如指针是否为空、范围是否符合预期。

3. 匹配 ABI
   确保调用约定（extern "C"）一致，并验证输入输出类型匹配。

4. 文档化假设
   明确记录 FFI 接口的行为和安全性假设，例如传递字符串是否需要手动释放。

5. 工具支持
   使用工具如 bindgen 自动生成 FFI 绑定代码，减少手动错误。

7.3.7 使用 Bindgen 自动生成绑定

Bindgen 是 Rust 提供的工具，用于从 C 头文件生成 Rust 的 FFI 绑定。

示例：生成绑定代码

1

bindgen wrapper.h -o bindings.rs

wrapper.h 包含 C 接口定义，例如：

1

int add(int a, int b);

生成的 Rust 绑定如下：

1
2
3
4

#[link(name = "mylib")]
extern "C" {
    pub fn add(a: i32, b: i32) -> i32;
}

总结

FFI 是 Rust 的重要功能，通过 Unsafe 实现与其他语言的交互。通过封装、不变式检查和文档记录，可以最大限度地降低 FFI 的风险，同时充分利用其性能优势。在实际项目中，结合工具（如 Bindgen）和最佳实践，可以让跨语言开发更加高效、安全。

• Rust
• Rust Programming in Action
• Rust编程实战
• Rust Tutors