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

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

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

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

// 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

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

• 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,
}

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

👉 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;
}

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

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

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

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