rust implementation of protover

Makefile.am

@@ -27,6 +27,8 @@ endif
 
 if USE_RUST
 rust_ldadd=$(top_builddir)/src/rust/target/release/@TOR_RUST_UTIL_STATIC_NAME@
+rust_ldadd+=$(top_builddir)/src/rust/target/release/@TOR_RUST_PROTOVER_STATIC_NAME@
+rust_ldadd+=$(top_builddir)/src/rust/target/release/@TOR_RUST_C_STRING_STATIC_NAME@
 else
 rust_ldadd=
 endif

configure.ac

@@ -440,11 +440,17 @@ if test "x$enable_rust" = "xyes"; then
  dnl the MSVC naming convention.
  if test "$bwin32" = "true"; then
  TOR_RUST_UTIL_STATIC_NAME=tor_util.lib
+ TOR_RUST_PROTOVER_STATIC_NAME=libprotover.lib
+ TOR_RUST_C_STRING_STATIC_NAME=libc_string.lib
  else
  TOR_RUST_UTIL_STATIC_NAME=libtor_util.a
+ TOR_RUST_PROTOVER_STATIC_NAME=libprotover.a
+ TOR_RUST_C_STRING_STATIC_NAME=libc_string.a
  fi
 
  AC_SUBST(TOR_RUST_UTIL_STATIC_NAME)
+ AC_SUBST(TOR_RUST_PROTOVER_STATIC_NAME)
+ AC_SUBST(TOR_RUST_C_STRING_STATIC_NAME)
  AC_SUBST(CARGO_ONLINE)
  AC_SUBST(RUST_DL)
 

src/common/include.am

@@ -94,6 +94,7 @@ LIBOR_A_SRC = \
  src/common/util_bug.c \
  src/common/util_format.c \
  src/common/util_process.c \
+ src/common/rust_types.c \
  src/common/sandbox.c \
  src/common/storagedir.c \
  src/common/workqueue.c \
@@ -179,6 +180,7 @@ COMMONHEADERS = \
  src/common/procmon.h \
  src/common/pubsub.h \
  src/common/sandbox.h \
+ src/common/rust_types.h \
  src/common/storagedir.h \
  src/common/testsupport.h \
  src/common/timers.h \

src/common/rust_types.c

@@ -0,0 +1,55 @@
+/* Copyright (c) 2017, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/**
+ * \file rust_types.c
+ * \brief This file is used for handling types returned from Rust to C.
+ **/
+
+#include "or.h"
+#include "rust_types.h"
+
+#ifdef HAVE_RUST
+
+void free_rust_str(char *ret);
+
+/* Because Rust strings can only be freed from Rust, we first copy the string's
+ * contents to a c pointer, and then free the Rust string.
+ * This function can be extended to return a success/error value if needed.
+ */
+void
+move_rust_str_to_c_and_free(rust_str_ref_t src, char **dest)
+{
+ if (!src) {
+ log_warn(LD_BUG, "Received a null pointer from protover rust.");
+ return;
+ }
+
+ if (!dest) {
+ log_warn(LD_BUG, "Received a null pointer from caller to protover rust. "
+ "This results in a memory leak due to not freeing the rust "
+ "string that was meant to be copied..");
+ return;
+ }
+
+ *dest = tor_strdup(src);
+ free_rust_str(src);
+ return;
+}
+
+#else
+
+/* When Rust is not enabled, this function should never be used. Log a warning
+ * in the case that it is ever called when Rust is not enabled.
+ */
+void
+move_rust_str_to_c_and_free(rust_str_ref_t src, char **dest)
+{
+ (void) src;
+ (void) dest;
+ log_warn(LD_BUG, "Received a call to free a Rust string when we are "
+ " not running with Rust enabled.");
+ return;
+}
+#endif /* defined(HAVE_RUST) */
+

src/common/rust_types.h

@@ -0,0 +1,22 @@
+/* Copyright (c) 2017, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/**
+ * \file rust_types.h
+ * \brief Headers for rust_types.c
+ **/
+
+#include "or.h"
+
+#ifndef TOR_RUST_TYPES_H
+#define TOR_RUST_TYPES_H
+
+/* This type is used to clearly mark strings that have been allocated in Rust,
+ * and therefore strictly need to use the free_rust_str method to free.
+ */
+typedef char *rust_str_ref_t;
+
+void move_rust_str_to_c_and_free(rust_str_ref_t src, char **dest);
+
+#endif
+

src/or/include.am

@@ -78,6 +78,7 @@ LIBTOR_A_SOURCES = \
  src/or/parsecommon.c \
  src/or/periodic.c \
  src/or/protover.c \
+ src/or/protover_rust.c \
  src/or/proto_cell.c \
  src/or/proto_control0.c \
  src/or/proto_ext_or.c \

src/or/protover.c

@@ -27,6 +27,8 @@
 #include "protover.h"
 #include "routerparse.h"
 
+#ifndef HAVE_RUST
+
 static const smartlist_t *get_supported_protocol_list(void);
 static int protocol_list_contains(const smartlist_t *protos,
  protocol_type_t pr, uint32_t ver);
@@ -735,3 +737,5 @@ protover_free_all(void)
  }
 }
 
+#endif
+

src/or/protover.h

@@ -70,11 +70,15 @@ typedef struct proto_entry_t {
  smartlist_t *ranges;
 } proto_entry_t;
 
+#if !defined(HAVE_RUST) && defined(TOR_UNIT_TESTS)
 STATIC smartlist_t *parse_protocol_list(const char *s);
-STATIC void proto_entry_free(proto_entry_t *entry);
 STATIC char *encode_protocol_list(const smartlist_t *sl);
 STATIC const char *protocol_type_to_str(protocol_type_t pr);
 STATIC int str_to_protocol_type(const char *s, protocol_type_t *pr_out);
+STATIC void proto_entry_free(proto_entry_t *entry);
+
+#endif
+
 #endif /* defined(PROTOVER_PRIVATE) */
 
 #endif /* !defined(TOR_PROTOVER_H) */

src/or/protover_rust.c

@@ -0,0 +1,111 @@
+/* Copyright (c) 2016-2017, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/*
+ * \file protover_rust.c
+ * \brief Provide a C wrapper for functions exposed in /src/rust/protover,
+ * and safe translation/handling between the Rust/C boundary.
+ */
+
+#include "or.h"
+#include "protover.h"
+#include "rust_types.h"
+
+#ifdef HAVE_RUST
+
+int rust_protover_all_supported(const char *s, char **missing);
+rust_str_ref_t rust_protover_compute_for_old_tor(const char *version);
+rust_str_ref_t rust_protover_compute_vote(const smartlist_t *proto_votes,
+ int threshold);
+rust_str_ref_t rust_protover_get_supported_protocols(void);
+int rust_protocol_list_supports_protocol(const char *list, protocol_type_t tp,
+ uint32_t version);
+int rust_protover_is_supported_here(protocol_type_t pr, uint32_t ver);
+
+/* Define for compatibility, used in main.c */
+void protover_free_all(void) {};
+
+/*
+ * Wrap rust_protover_is_supported_here, located in /src/rust/protover
+ */
+int
+protover_is_supported_here(protocol_type_t pr, uint32_t ver)
+{
+ return rust_protover_is_supported_here(pr, ver);
+}
+
+/*
+ * Wrap rust_protover_list_supports_protocol, located in /src/rust/protover
+ */
+int
+protocol_list_supports_protocol(const char *list, protocol_type_t tp,
+ uint32_t version)
+{
+ return rust_protocol_list_supports_protocol(list, tp, version);
+}
+
+/*
+ * Wrap rust_protover_get_supported_protocols, located in /src/rust/protover
+ */
+const char *
+protover_get_supported_protocols(void)
+{
+ rust_str_ref_t rust_protocols = rust_protover_get_supported_protocols();
+
+ char *protocols = NULL;
+ if (rust_protocols != NULL) {
+ move_rust_str_to_c_and_free(rust_protocols, &protocols);
+ }
+ return protocols;
+}
+
+/*
+ * Wrap rust_protover_compute_vote, located in /src/rust/protover
+ */
+char *
+protover_compute_vote(const smartlist_t *proto_strings,
+ int threshold)
+{
+ rust_str_ref_t rust_protocols = rust_protover_compute_vote(proto_strings,
+ threshold);
+
+ char *protocols = NULL;
+ if (rust_protocols != NULL) {
+ move_rust_str_to_c_and_free(rust_protocols, &protocols);
+ }
+ return protocols;
+}
+
+/*
+ * Wrap rust_protover_all_supported, located in /src/rust/protover
+ */
+int
+protover_all_supported(const char *s, char **missing_out)
+{
+ rust_str_ref_t missing_out_copy = NULL;
+ int is_supported = rust_protover_all_supported(s, &missing_out_copy);
+
+ if (!is_supported) {
+ move_rust_str_to_c_and_free(missing_out_copy, missing_out);
+ }
+
+ return is_supported;
+}
+
+/*
+ * Wrap rust_compute_for_old_tor, located in /src/rust/protover
+ */
+const char *
+protover_compute_for_old_tor(const char *version)
+{
+ rust_str_ref_t rust_protocols = rust_protover_compute_for_old_tor(version);
+
+ char *protocols = NULL;
+ if (rust_protocols != NULL) {
+ move_rust_str_to_c_and_free(rust_protocols, &protocols);
+ }
+ return protocols;
+}
+
+#endif
+

src/rust/Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["tor_util"]
+members = ["tor_util", "protover", "smartlist", "external", "c_string"]
 
 [profile.release]
 debug = true

src/rust/c_string/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+authors = ["The Tor Project"]
+version = "0.0.1"
+name = "c_string"
+
+[dependencies]
+libc = "0.2.22"
+
+[lib]
+name = "c_string"
+path = "ffi.rs"
+crate_type = ["rlib", "staticlib"]
+

src/rust/c_string/ffi.rs

@@ -0,0 +1,19 @@
+//! FFI functions, only to be called from C.
+//!
+//! This module provides the ability for C to free strings that have been
+//! allocated in Rust.
+
+extern crate libc;
+
+use libc::c_char;
+use std::ffi::CString;
+
+/// This allows strings allocated in Rust to be freed in Rust. Every string
+/// sent across the Rust/C FFI boundary should utilize this function for
+/// freeing strings allocated in Rust.
+#[no_mangle]
+pub extern "C" fn free_rust_str(ptr: *mut c_char) {
+ if !ptr.is_null() {
+ unsafe { CString::from_raw(ptr) };
+ }
+}

src/rust/c_string/include.am

@@ -0,0 +1,12 @@
+EXTRA_DIST +=\
+ src/rust/c_string/Cargo.toml \
+ src/rust/c_string/ffi.rs
+
+src/rust/target/release/@TOR_RUST_C_STRING_STATIC_NAME@: FORCE
+ ( cd "$(abs_top_srcdir)/src/rust/c_string" ; \
+ CARGO_TARGET_DIR="$(abs_top_builddir)/src/rust/target" \
+ CARGO_HOME="$(abs_top_builddir)/src/rust" \
+ $(CARGO) build --release --quiet $(CARGO_ONLINE) )
+
+FORCE:
+

src/rust/external/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+authors = ["The Tor Project"]
+version = "0.0.1"
+name = "external"
+
+[dependencies]
+libc = "0.2.22"
+
+[lib]
+name = "external"
+path = "lib.rs"
+crate_type = ["rlib", "staticlib"]
+