commit 76bbdfbfa9eca46b53d3ec5a44deafce51d2875a
Author: Chelsea Holland Komlo <m...@chelseakomlo.com>
Date: Sat Oct 14 23:05:31 2017 -0400
add tor allocator for rust
---
src/rust/protover/ffi.rs | 20 ++++----
src/rust/tor_allocate/Cargo.toml | 13 +++++
src/rust/tor_allocate/include.am | 13 +++++
src/rust/tor_allocate/lib.rs | 12 +++++
src/rust/tor_allocate/tor_allocate.rs | 90 +++++++++++++++++++++++++++++++++++
5 files changed, 138 insertions(+), 10 deletions(-)
diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs
index 539b6c0ba..23a289bd5 100644
--- a/src/rust/protover/ffi.rs
+++ b/src/rust/protover/ffi.rs
@@ -8,7 +8,7 @@ use std::ffi::CString;
use protover::*;
use smartlist::*;
-use tor_allocate::allocate_string;
+use tor_allocate::allocate_and_copy_string;
/// Translate C enums to Rust Proto enums, using the integer value of the C
/// enum to map to its associated Rust enum
@@ -124,17 +124,17 @@ pub extern "C" fn protover_compute_vote(
) -> *mut c_char {
if list.is_null() {
- let mut empty = String::new();
- return allocate_string(&mut empty);
+ let empty = String::new();
+ return allocate_and_copy_string(&empty);
}
// Dereference of raw pointer requires an unsafe block. The pointer is
// checked above to ensure it is not null.
let data: Vec<String> = unsafe { (*list).get_list() };
- let mut vote = compute_vote(data, threshold);
+ let vote = compute_vote(data, threshold);
- allocate_string(&mut vote)
+ allocate_and_copy_string(&vote)
}
/// Provide an interface for C to translate arguments and return types for
@@ -162,10 +162,10 @@ pub extern "C" fn protover_compute_for_old_tor(
) -> *mut c_char {
// Not handling errors when unwrapping as the content is controlled
// and is an empty string
- let mut empty = String::new();
+ let empty = String::new();
if version.is_null() {
- return allocate_string(&mut empty);
+ return allocate_and_copy_string(&empty);
}
// Require an unsafe block to read the version from a C string. The pointer
@@ -174,10 +174,10 @@ pub extern "C" fn protover_compute_for_old_tor(
let version = match c_str.to_str() {
Ok(n) => n,
- Err(_) => return allocate_string(&mut empty),
+ Err(_) => return allocate_and_copy_string(&empty),
};
- let mut supported = compute_for_old_tor(&version);
+ let supported = compute_for_old_tor(&version);
- allocate_string(&mut supported)
+ allocate_and_copy_string(&supported)
}
diff --git a/src/rust/tor_allocate/Cargo.toml b/src/rust/tor_allocate/Cargo.toml
new file mode 100644
index 000000000..ceb08b78a
--- /dev/null
+++ b/src/rust/tor_allocate/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+authors = ["The Tor Project"]
+version = "0.0.1"
+name = "tor_allocate"
+
+[dependencies]
+libc = "0.2.22"
+
+[lib]
+name = "tor_allocate"
+path = "lib.rs"
+crate_type = ["rlib", "staticlib"]
+
diff --git a/src/rust/tor_allocate/include.am b/src/rust/tor_allocate/include.am
new file mode 100644
index 000000000..9e770dbc0
--- /dev/null
+++ b/src/rust/tor_allocate/include.am
@@ -0,0 +1,13 @@
+EXTRA_DIST +=\
+ src/rust/tor_allocate/Cargo.toml \
+ src/rust/tor_allocate/lib.rs \
+ src/rust/tor_allocate/tor_allocate.rs
+
+src/rust/target/release/@TOR_RUST_C_STRING_STATIC_NAME@: FORCE
+ ( cd "$(abs_top_srcdir)/src/rust/tor_allocate" ; \
+ CARGO_TARGET_DIR="$(abs_top_builddir)/src/rust/target" \
+ CARGO_HOME="$(abs_top_builddir)/src/rust" \
+ $(CARGO) build --release --quiet $(CARGO_ONLINE) )
+
+FORCE:
+
diff --git a/src/rust/tor_allocate/lib.rs b/src/rust/tor_allocate/lib.rs
new file mode 100644
index 000000000..81afd095f
--- /dev/null
+++ b/src/rust/tor_allocate/lib.rs
@@ -0,0 +1,12 @@
+//! Allocation helper functions that allow data to be allocated in Rust
+//! using tor's specified allocator. In doing so, this can be later freed
+//! from C.
+//!
+//! This is currently a temporary solution, we will later use tor's allocator
+//! by default for any allocation that occurs in Rust. However, as this will
+//! stabalize in 2018, we can use this as a temporary measure.
+
+extern crate libc;
+
+mod tor_allocate;
+pub use tor_allocate::*;
diff --git a/src/rust/tor_allocate/tor_allocate.rs
b/src/rust/tor_allocate/tor_allocate.rs
new file mode 100644
index 000000000..de1d13942
--- /dev/null
+++ b/src/rust/tor_allocate/tor_allocate.rs
@@ -0,0 +1,90 @@
+use libc::{c_char, c_void};
+use std::{ptr, slice};
+
+#[cfg(not(test))]
+extern "C" {
+ fn tor_malloc_ ( size: usize) -> *mut c_void;
+}
+
+// Defined only for tests, used for testing purposes, so that we don't need
+// to link to tor C files. Uses the system allocator
+#[cfg(test)]
+extern "C" fn tor_malloc_ ( size: usize) -> *mut c_void {
+ use libc::malloc;
+ unsafe { malloc(size) }
+}
+
+/// Allocate memory using tor_malloc_ and copy an existing string into the
+/// allocated buffer, returning a pointer that can later be called in C.
+///
+/// # Inputs
+///
+/// * `src`, a reference to a String that will be copied.
+///
+/// # Returns
+///
+/// A `String` that should be freed by tor_free in C
+///
+pub fn allocate_and_copy_string(src: &String) -> *mut c_char {
+ let bytes = s.as_bytes();
+
+ let size = s.len();
+ let size_with_null_byte = size + 1;
+
+ let dest = unsafe { tor_malloc_(size_with_null_byte) as *mut u8 };
+
+ if dest.is_null() {
+ return dest as *mut c_char;
+ }
+
+ unsafe { ptr::copy_nonoverlapping(bytes.as_ptr(), dest, size) };
+
+ // set the last byte as null, using the ability to index into a slice
+ // rather than doing pointer arithmatic
+ let slice = unsafe { slice::from_raw_parts_mut(dest, size_with_null_byte)
};
+ slice[size] = 0; // add a null terminator
+
+ dest as *mut c_char
+}
+
+#[cfg(test)]
+mod test {
+
+ #[test]
+ fn test_allocate_and_copy_string_with_empty() {
+ use std::ffi::CStr;
+ use libc::{free, c_void};
+
+ use tor_allocate::allocate_and_copy_string;
+
+ let empty = String::new();
+ let allocated_empty = allocate_and_copy_string(&empty);
+
+ let allocated_empty_rust = unsafe {
+ CStr::from_ptr(allocated_empty).to_str().unwrap()
+ };
+
+ assert_eq!("", allocated_empty_rust);
+
+ unsafe { free(allocated_empty as *mut c_void) };
+ }
+
+ #[test]
+ fn test_allocate_and_copy_string_with_not_empty_string() {
+ use std::ffi::CStr;
+ use libc::{free, c_void};
+
+ use tor_allocate::allocate_and_copy_string;
+
+ let empty = String::from("foo bar biz");
+ let allocated_empty = allocate_and_copy_string(&empty);
+
+ let allocated_empty_rust = unsafe {
+ CStr::from_ptr(allocated_empty).to_str().unwrap()
+ };
+
+ assert_eq!("foo bar biz", allocated_empty_rust);
+
+ unsafe { free(allocated_empty as *mut c_void) };
+ }
+}
_______________________________________________
tor-commits mailing list
tor-commits@lists.torproject.org
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits
