Rust 💖 C/C++

`whoami(1)`

Katharina Fey ( @spacekookie )

Active FOSS developer
Avid tea drinker
Hobbyist hardware maker

`whoami(2)`

I do Rust things!

Contributer to the CLI-WG
Author of (too) many use[ful|less] crates
Member of berlin.rs

Why

Why would you do that?

Integrate into larger projects
Replace application piece by piece
Write plugins

Why give this talk?

Rust promises efficient FFI to C code

What does this mean?

ABI

Application Binary Interface

Defines the function signature & types
Much like an API but for linkers

ABI

extern "C" fn foo() { /* ... */ }

#[repr(C)]
struct Bar { /* ... */ }

#[repr(C)]
enum Biz { /* ... */ }

union Fuzz { /* unions are just cool by default */ }

ABI

Let’s talk about stability

Neither does C++

C doesn’t have an ABI

The operating system does

C code from Rust

Boring FFI

Bind to native API with extern functions
Wrap function calls in unsafe
Make data C-compatible

extern "C" {
    fn reverse(const *c_char) -> const *c_char;
}

fn stuff(value: &str) {
    println!("{:?}", 
        unsafe { reverse(CStr::from(value).unwrap()) }
    );
}

Boring FFI

std::os::raw & std::ffi contain FFI types

(Rust) String becomes CString
(Rust) &str becomes CStr
void becomes c_void
… etc …

Turning tables

Same extern "C" as before
Take data in C-form
Use #[no_mangle] to preserve the function name

#[no_mangle]
pub extern "C" fn reverse(word: *const c_char) -> *const c_char {
    /* ... implementation really not important right now ... */
}

Turning tables

Some special fields in Cargo.toml

# ...

[lib]
name = "reverso"            # Practise my reversing. Ha-HAA!
crate-type = ["cdylib"]     #  dynamic library (.so)
#            ["staticlib"]     static library (.a)

Turning tables

Integrating the Rust code into your build toolchain

├── CMakeLists.txt
├── reverso
│   ├── Cargo.toml 
│   └── src 
│       └── lib.rs
├── reverso.h
└── main.c

Note the header reverso.h

// Safely reverse a unicode string
const char *reverse(const char *in);

Turning tables

Calling this from C is easy

#include "reverso.h"
void main() {
    char * greeting = "привет RustConf 👩🏽‍💻";
    printf("'%s' reversed: '%s' \n", greeting, reverse(greeting));
}

'ривет RustConf 👩🏽‍💻' reversed: '💻👩🏽 fnoCtsuR тевирп'

Thank you

Tweet at me @spacekookie

Like, Share & Subscribe…

Alright, not quite

Some Problems

I don’t want to write headers
How to deal with anything going wrong?
Oh god, real memory management! 😨
How to build pretty APIs?

Tooling

cbindgen

Don’t write headers yourself. Use cbindgen

Like bindgen, but in reverse
Can generate .h files at compile-time

Build system support

😏

Memory management

Put your troubles in a box ✨

#[repr(C)]
struct MyThing {
    /* ... */
}

#[no_mangle]
extern "C" fn make_thing() -> Box<MyThing> {
    Box::new(MyThing {
        /* ... */
    })
}

📦 Boxes 📦

let ptr: c_void = /* ... */;

let thing: &mut MyThing = unsafe {
        &mut *ctx as &mut MyThing
    };

thing.foo();

Remember: C is now responsible for the memory.

You can’t make the native code memory safe

void main() {
    MyThing *t = make_thing();
    free(t);

    printf("%s", t.value); // kaboom!
}

Communicating Errors

enum Result<T, E> {
    Ok(T),
    Err(E),
}

enum Option<T> {
    Some(T),
    None,
}

Errors in C
Errors in C++

Emulate Result<T,E> with a structure

#[repr(C)]
pub struct rvalue_t<T> {
    thing: Box<Option<T>>,
    code: u32,
}

C

struct rvalue_t {
    void         *ignore_me;
    unsigned int code;
};

rvalue_t val = myfunction();
if (val.code) {
    // Handle errors
}

👉 Pointers

Errors in C

uint32_t get_client(server_t *ctx, client_t **client);

/* ... */

client_t *client;
ret = get_client(ctx, &client);
if(ret) {
    // Handle errors
}

Errors in C

uint32_t initialise(server_t **ctx, uint16_t port);

/* ... */

server_t *server;
ret = initialise(&server, 1337);
if(ret) {
    // Handle errors
}

Errors in C Rust

/// Initialise <thing>
#[no_mangle]
pub extern "C" fn initialise(ctx: *mut *mut c_void, 
                             port: c_uint) -> c_uint {

    /* ... check if port valid ... */ 

    let server = Box::new(server_t { port });
    unsafe { *ctx = Box::into_raw(server) as *mut c_void };
    return 0;
}

/* rust.h */
struct server_t {
    uint16_t port;
};
uint32_t initialise(struct server_t **, uint16_t);

/* main.c */

struct server_t *server;
uint32_t ret = initialise(&server, 8080);
if(ret) {
    // Handle errors
}

Errors in C++

Well…

Errors in C++

Wrap C-errors in exception throwing code

extern "C" {
    #include "cbindgen-made-this.h"
}

class MyRustModule {
    void do_something_dangerous() {
        auto ret = do_rust_things();
        if(ret) throw CorporateExceptionSeven(ret);
    }
}

Errors in C++

namespace Rust {
    extern "C" {
        #include "no_i_made_this.h"
    }
}

/* ... */

auto ret = Rust::do_something_dangerous();
if(ret) return new MyResultNine(ret, "Oh no!");

Can you throw a `C++` exception from Rust?

😱

Yes!

Exceptions

try - throw – catch

try creates a “landing pad”

throw walks up the stack

Then calls catch

`try`

Landing pad determines how to continue

`catch`

But which one? Filter or rethrow!

Throw

Replaced with calls into libc++

This is a talk about Rust

exception.rs

extern crate exception_rs as exception;

pub extern "C" fn oh_no() {
    exception::throw(RustException { text: "Oh noes!" });
}

Oh god please don’t use this! (soon™ on crates.io)

No libc++ bindings in Rust

Invoke apropriate functions via C shim layer

extern void *__cxa_allocate_exception(size_t thrown_size);
extern void __cxa_throw(void *e, void **t, void (*dest)(void *));

Functions are linked when C++ project is compiled

Can you catch a C++ exception in Rust?

Yes. But not today

Thank you (for real)

Follow me on twitter @spacekookie

Or: kookie@spacekookie.de

💚 My employer: Ferrous Systems
🧡 Mozilla
❤ All of you