1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

// #![warn(missing_docs)]
#![doc(html_logo_url = "https://avatars3.githubusercontent.com/u/15439811?v=3&s=200",
       html_favicon_url = "https://iorust.github.io/favicon.ico",
       html_root_url = "https://iorust.github.io",
       html_playground_url = "https://play.rust-lang.org",
       issue_tracker_base_url = "https://github.com/iorust/msgp-rust/issues")]

//! Byte message protocol for Rust.

extern crate libc;
extern crate msgp;

use std::ptr;
use std::slice;
use std::mem::{transmute, forget, drop};

use libc::{uint8_t, size_t};

// A struct that can be passed between C and Rust
#[repr(C)]
#[derive(Debug)]
pub struct Buf {
    ptr: *const uint8_t,
    len: size_t,
}

#[no_mangle]
pub extern fn encode(buf: Buf) -> Buf {
    let val: &[u8] = unsafe {
        assert!(!buf.ptr.is_null());
        slice::from_raw_parts(buf.ptr, buf.len as usize)
    };

    let res = msgp::encode(val);
    let ptr = res.as_ptr();
    let len = res.len();
    forget(res);

    Buf { ptr: ptr, len: len }
}

#[no_mangle]
pub extern fn decode(buf: Buf) -> Buf {
    let val: &[u8] = unsafe {
        assert!(!buf.ptr.is_null());
        slice::from_raw_parts(buf.ptr, buf.len as usize)
    };

    if let Some(res) = msgp::decode(val) {
        let ptr = res.as_ptr();
        let len = res.len();
        forget(res);

        return Buf { ptr: ptr, len: len };
    }

    Buf { ptr: ptr::null(), len: 0 }
}

#[no_mangle]
pub extern fn create_decoder() -> *mut msgp::Decoder {
    let decoder = unsafe { transmute(Box::new(msgp::Decoder::new())) };
    decoder
}

#[no_mangle]
pub extern fn feed_decoder(ptr: *mut msgp::Decoder, buf: Buf) -> size_t {
    let mut decoder = unsafe { &mut *ptr };
    let val: &[u8] = unsafe {
        assert!(!buf.ptr.is_null());
        slice::from_raw_parts(buf.ptr, buf.len as usize)
    };
    if let Ok(size) = decoder.feed(val) {
        return size;
    }
    0
}

#[no_mangle]
pub extern fn read_decoder(ptr: *mut msgp::Decoder) -> Buf {
    let mut decoder = unsafe { &mut *ptr };
    if let Some(res) = decoder.read() {
        let ptr = res.as_ptr();
        let len = res.len();
        forget(res);
        return Buf { ptr: ptr, len: len };
    }
    Buf { ptr: ptr::null(), len: 0 }
}

#[no_mangle]
pub extern fn get_decoder_buffer_len(ptr: *const msgp::Decoder) -> size_t {
    let decoder = unsafe { &*ptr };
    decoder.buffer_len()
}

#[no_mangle]
pub extern fn get_decoder_result_len(ptr: *const msgp::Decoder) -> size_t {
    let decoder = unsafe { &*ptr };
    decoder.result_len()
}

#[no_mangle]
pub extern fn drop_decoder(ptr: *mut msgp::Decoder) {
    let decoder: Box<msgp::Decoder> = unsafe { transmute(ptr) };
    drop(decoder);
}