CodeBlanks Logo Icon CodeBlanks
Login Register

extern block

Declare C functions with extern "C".

The extern block

Functions from C libraries are declared in an extern "C" block. For C types, use the aliases from std::ffi and std::os::raw: C's int may not be Rust's i32 on every platform:

use std::ffi::c_int;

unsafe extern "C" {
    fn toupper(c: c_int) -> c_int;
}

let buyuk = unsafe { toupper('a' as c_int) } as u8 as char;   // 'A'

The standard C library (libc) is already linked. For another library, the #[link(name = "z")] attribute or a build.rs script is used.

Linking

The declaration only gives the signature; the function body is found at link time. If it isn't found, the error comes not at compile time but from the linker: "undefined reference to ...". Static or dynamic linking can be chosen:

#[link(name = "sqlite3")]              // libsqlite3.so / sqlite3.lib
unsafe extern "C" {
    fn sqlite3_libversion() -> *const std::ffi::c_char;
}

For ready-made bindings, crates with a -sys suffix (e.g. libsqlite3-sys) are used; safe wrapper crates are built on top of them.

Practice Calling toupper

Declare C's toupper function in an unsafe extern "C" block. Uppercase the characters 'a' and 'z' and print the results as char separated by a space.

Starter code

main.rs
use std::ffi::c_int;

fn main() {
    // buraya yaz
}

Sample solution

main.rs
use std::ffi::c_int;

unsafe extern "C" {
    fn toupper(c: c_int) -> c_int;
}

fn buyut(c: char) -> char {
    // SAFETY: toupper her ASCII değeri için tanımlıdır.
    (unsafe { toupper(c as c_int) }) as u8 as char
}

fn main() {
    println!("{} {}", buyut('a'), buyut('z'));
}

Expected output

A Z

Questions and answers

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

1 Which Rust type should be used for C's <code>long</code>?

  • isize
  • std::ffi::c_long Correct answer
  • Always i64
  • Always i32

Explanation: long is 64 bits on 64-bit Linux and 32 on Windows; c_long picks the right type for the platform.

2 C integer

Question 
unsafe extern "C" {
    fn toupper(c: ____) -> c_int;
}
Answer 
unsafe extern "C" {
    fn toupper(c: c_int) -> c_int;
}

Explanation: C's int type is expressed as std::ffi::c_int in Rust.

3 C type and Rust counterpart

Term Meaning
int c_int
long c_long
char * *const c_char
void * *mut c_void

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