CodeBlanks Logo Icon CodeBlanks
Login Register

FFI call

Call foreign functions with extern "C".

An FFI call

The foreign function interface (FFI) lets you call functions written in other languages (mostly C). The functions are declared in an extern "C" block. Since the compiler can't verify their signatures, the call is unsafe; since Rust 1.82 the block itself is also marked unsafe extern:

unsafe extern "C" {
    fn abs(x: i32) -> i32;      // from the C standard library
}

let n = unsafe { abs(-7) };   // 7

"C" specifies the calling convention (ABI): how arguments are passed and how the result returns.

A safe wrapper

Wrapping FFI calls in small safe functions gathers the unsafe in one place:

fn mutlak(x: i32) -> i32 {
    // SAFETY: abs is defined for every i32; no overflow except i32::MIN.
    unsafe { abs(x) }
}

The reverse direction is possible too: with #[no_mangle] pub extern "C" fn, Rust functions become callable from C. We'll look at FFI in detail in the next group.

Practice abs from C

Declare fn abs(x: i32) -> i32; in an unsafe extern "C" block and write a safe fn mutlak(x: i32) -> i32 wrapping it. Print the results of mutlak(-7) and mutlak(3) separated by a space.

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
unsafe extern "C" {
    fn abs(x: i32) -> i32;
}

fn mutlak(x: i32) -> i32 {
    // SAFETY: abs her i32 için tanımlıdır.
    unsafe { abs(x) }
}

fn main() {
    println!("{} {}", mutlak(-7), mutlak(3));
}

Expected output

7 3

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What happens if the declared signature doesn't match the real C signature?

  • Compile error
  • Always a linker error
  • It's fixed automatically
  • Undefined behaviour; the compiler can't catch it Correct answer

Explanation: That's why declarations are usually generated from C header files with tools like bindgen.

2 Foreign block

Question 
unsafe extern "____" {
    fn abs(x: i32) -> i32;
}
Answer 
unsafe extern "C" {
    fn abs(x: i32) -> i32;
}

Explanation: The "C" calling convention is the ABI compatible with C functions.

3 Item and meaning

Term Meaning
extern "C" C calling convention
unsafe { abs(-7) } FFI call
#[no_mangle] Keeps the name
bindgen Generates declarations from headers

All lessons in Advanced

1 async/await

  1. async fn
  2. await
  3. Future trait
  4. async block
  5. Pin
  6. Summary - async/await

2 Tokio

  1. Tokio runtime
  2. spawn
  3. tokio::sync
  4. tokio::fs
  5. select!
  6. Summary - Tokio

3 Concurrency

  1. thread::spawn
  2. Mutex<T>
  3. RwLock<T>
  4. Arc<T>
  5. Send and Sync
  6. Summary - Concurrency

4 Channels

  1. mpsc channel
  2. send and recv
  3. Multiple producers
  4. try_recv
  5. tokio::sync::mpsc
  6. Summary - Channels

5 Project: Chat server

  1. TCP listener
  2. Client thread
  3. Channel messaging
  4. Broadcast
  5. Arc<Mutex> state

6 Unsafe Rust

  1. unsafe block
  2. Raw pointers
  3. unsafe fn
  4. static mut
  5. FFI call
  6. Summary - Unsafe Rust

7 FFI

  1. extern block
  2. #[repr(C)]
  3. CString and CStr
  4. Callback
  5. Drop and cleanup
  6. Summary - FFI

8 Declarative macros

  1. macro_rules!
  2. Repetitions
  3. Types
  4. Macro hygiene
  5. Inspecting println!
  6. Summary - Declarative macros

9 Procedural macros

  1. proc_macro crate
  2. derive macro
  3. attribute macro
  4. syn and quote
  5. TokenStream
  6. Summary - Procedural macros

10 Trait objects

  1. dyn Trait
  2. Box<dyn Trait>
  3. Static vs dynamic dispatch
  4. Object safety
  5. &dyn Trait
  6. Summary - Trait objects

11 Advanced traits

  1. Associated type
  2. Associated constant
  3. GAT
  4. Supertrait
  5. Newtype pattern
  6. Summary - Advanced traits

12 Const generics

  1. [T; N]
  2. const fn
  3. Const trait bound
  4. Min_const_generics
  5. Array and slice
  6. Summary - Const generics

13 Advanced patterns

  1. Struct patterns
  2. Destructuring
  3. @ binding
  4. Guard
  5. Binding modes
  6. Summary - Advanced patterns

14 Advanced final

  1. Async web server
  2. ThreadPool
  3. derive macro
  4. FFI wrapper