Interoperability Between C and Rust

This section of the Rust Embedded Book explains how to interface Rust code with C code. This is crucial for projects that need to leverage existing C libraries or operate in environments where C is the standard language, such as embedded systems.

Key Concepts

• Foreign Function Interface (FFI): This allows Rust to call C functions and vice versa, making it essential for integrating with existing C libraries.
• Safety and Security: Rust emphasizes safety, and interfacing with C requires careful management of memory and safety concerns, as C does not provide the same guarantees as Rust.

Basic Steps to Interoperate with C

1. Handling Data Types: Be mindful of the differences in data types between Rust and C. For example:
   • C’s int is usually represented by Rust's i32.
   • Strings require special handling since Rust uses String and &str, while C uses null-terminated character arrays.

Calling C Functions: Call the C functions inside an unsafe block, as Rust cannot guarantee safety when calling C code.

unsafe {
    let result = c_function(10);
}

Linking C Libraries: To use C libraries, specify the appropriate linking options in your Cargo.toml file.

[dependencies]
libc = "0.2"

[build]
rustflags = ["-C", "link-arg=-l"]

Define C Functions: Use the extern keyword to declare C functions in Rust.

extern "C" {
    fn c_function(arg: i32) -> i32;
}

Example: Calling a C Function from Rust

Here’s a simple example that demonstrates how to call a C function from Rust:

C Code (example.c)

#include 

void hello() {
    printf("Hello from C!\n");
}

Rust Code (main.rs)

#[link(name = "example")]
extern "C" {
    fn hello();
}

fn main() {
    unsafe {
        hello();
    }
}

Build and Link

To compile the C code and link it with Rust, you would typically use a build system like make or specify the C code in your build script.

Conclusion

Interfacing Rust with C allows you to utilize the strengths of both languages. By understanding the basic principles of FFI, memory safety, and data type management, you can effectively integrate C libraries into your Rust applications. Always remember to handle external calls with care to maintain the safety guarantees that Rust provides.