• Rust Intro
• The Example Project
• Challenges
• Conclusions

• Avoid whole classes of bugs
• New languages, new features
• It's getting harder to find C programmers

• 80% C, 7% Python (2)
• ~ 2 million lines of code
• ~ 15-20 regular contributors

• Announced 2010
• C-like, compiled language
• Focus on memory safety
• Package management with cargo
• Still a bit of a moving target
• Programmers call themselves "Rustacians"

fn main() {
    println!("Hello, world!");
}

• Write a DNS parser in Rust
• Build as a shared library
• Link with Samba
• Profit!

Explained in the Rust Book

[lib]
name = "embed"
crate-type = ["dylib"]

• Make up a simple DNS-like protocol
• Build a parser for it in Rust
• Build as a shared library
• Load from a C application
• Profit!

    0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   |                      ID                       |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   |QR|BD|IT|UL|BL|Reserved|         Red           |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   |        Green          |         Blue          |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   | Query ...                                     |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   | ...                                           |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   | Payload ...                                   |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
   | ...                                           |
   +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

• Client sends a query, giving an ID
• Server looks up the query in the database
• Server responds with a payload, using bit flags for formatting and fancy colours

Server

$ cd server
$ cargo run

Client

$ cd client
$ cargo run 127.0.0.1 65432 greeting

pub struct Package {
    pub id: u16,
    pub message_type: MessageType,
    pub bold: bool,
    pub italic: bool,
    pub underlined: bool,
    pub blink: bool,
    pub red: u8,
    pub green: u8,
    pub blue: u8,
    pub query: Option<String>,
    pub payload: Option<String>,
}

pub enum MessageType {
    Query,
    Response,
}

let mut query = Package::new();
query.query = Some(config.query);

let mut out_buf: Vec<u8> = Vec::new();
{
    let mut encoder = Encoder::new(&mut out_buf);
    query.write(&mut encoder).expect("Failed to encode query");
}

// send query
// get response

let mut decoder = Decoder::new(&in_buf);
let response = Package::read(&mut decoder).expect("Parsing the response failed");

// Format, colour and print response

loop {
    // Receive query into inbuf
    
    let mut decoder = Decoder::new(inbuf);
    let query = Package::read(&mut decoder).expect("Parsing query failed");
    
    let response = lookup_message(&mut messages, &query);

    let mut outbuf: Vec<u8> = Vec::new();
    {
        let mut encoder = Encoder::new(&mut outbuf);
        response.write(&mut encoder).expect("Encoding response failed");
    }

    // Send response from outbuf
}

while True {
    // Recieve query into in_buffer
    
    // Call into Rust for parsing in_buf into Package
    query = decode_package(in_buffer, len);
    
    // "Business logic" in C
    lookup_message(query, response);
    
    // Call into Rust again to create out_buf for Package
    encode_package(response, &out_buffer, &len);
    
    // Send response from out_buffer
}

typedef struct package {
  //...
} Package;

Package *decode_package(const uint8_t* buffer, size_t len);
int encode_package(const Package *package, uint8_t **buffer, size_t *len);

Who owns memory for the Package struct in decode_package()?

• Option 1: Rust
• Option 2: C

• Rust handles memory allocation
• C just uses the structs
• Rust needs to handle deallocation
• C needs to call back into Rust to free memory

typedef struct package {
  //...
} Package;

Package *decode_package(const uint8_t* buffer, size_t len);
int encode_package(const Package *package, uint8_t **buffer, size_t *len);
void free_package(Package *package);
void free_buffer(uint8_t *buffer);

• Someone will forget to call the right free soon.

$ cd c-server
$ make run

• Memory ownership passed to calling C code
• C takes care of freeing the memory
• Rust needs to allocate memory in a way C can free
• Idea: Port talloc to Rust

• Load libtalloc via FFI
• Provide talloc_named_const() and talloc_free() calls
• Wrap in Rust layer to make this feel like native code.

use libc::{size_t, c_int, c_char, c_void};

#[link(name="talloc")]
extern {
    pub fn talloc_named_const(context: *const c_void, size: size_t,
                              name: *const c_char) -> *mut c_void;
    pub fn _talloc_free(context: *mut c_void,
                        location: *const c_char) -> c_int;
}

• Now talloc is useable in Rust
• Needs to be wrapped to feel more Rust-like

• Basic datastructure to allocate heap memory is Box<>
• Build a Box<>-like TallocContext<> that uses talloc
• Use that to allocate memory for transferable data structures

impl<T> TallocContext<T> {
    pub fn new<U>(parent: Option<TallocContext<U>>) -> TallocContext<T> {
        let size = size_of::<T>();
        let name = CString::new("Memory context allocated from Rust.")
                   .unwrap();
        let parent_ptr = match parent {
            Some(tc) => tc.ptr,
            None => null(),
        };
        unsafe {
            let ptr = ffi::talloc_named_const(parent_ptr as *const c_void,
                                              size as size_t, name.as_ptr());
            TallocContext {
                ptr: ptr as *mut u8,
                phantom: PhantomData
            }
        }
    }
}

impl<T> Drop for TallocContext<T> {
    fn drop(&mut self) {
        let name = CString::new("Free in the Rust deallocation logic.")
                   .unwrap();
        unsafe {
            let retcode = ffi::_talloc_free(self.ptr as *mut c_void,
                                            name.as_ptr());
            if retcode != 0 {
                panic!("Failed to free memory!");
            }
        };
    }
}

pub struct Package {
    pub id: u16,
    pub message_type: MessageType,
    pub bold: bool,
    pub italic: bool,
    pub underlined: bool,
    pub blink: bool,
    pub red: u8,
    pub green: u8,
    pub blue: u8,
    pub query: Option<String>,
    pub payload: Option<String>,
}

pub struct TallocString {
    inner: TallocContext<[u8]>,
}

pub struct TallocVec<T> {
    context: TallocContext<T>,
    len: usize,
}

• We probably want talloc versions of all heap-allocated structures >- Lots of boilerplate

• Make talloc useable as global allocator in Rust
• Implement Allocate trait
• But: Not a stable feature yet

• Less easy than I had hoped for
• Need to decide which memory handling method to use
• How to integrate build systems?
• How to handle Rust as dependency?
• Rust community is pretty helpful

• Better talloc-sys implementation?
• Auto-generate code from IDL
• Build system integration ☹