mirror of
https://gitlab.torproject.org/tpo/core/tor.git
synced 2024-11-27 22:03:31 +01:00
rust implementation of protover
This commit is contained in:
Chelsea Holland Komlo
Nick Mathewson
parent
5418aa84ee
commit
d1820c1516
@ -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
|
||||
|
||||
@ -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)
|
||||
|
||||
|
||||
@ -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 \
|
||||
|
||||
55
src/common/rust_types.c
Normal file
55
src/common/rust_types.c
Normal file
@ -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) */
|
||||
|
||||
22
src/common/rust_types.h
Normal file
22
src/common/rust_types.h
Normal file
@ -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
|
||||
|
||||
@ -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 \
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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) */
|
||||
|
||||
111
src/or/protover_rust.c
Normal file
111
src/or/protover_rust.c
Normal file
@ -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
|
||||
|
||||
31
src/rust/Cargo.lock
generated
31
src/rust/Cargo.lock
generated
@ -5,10 +5,41 @@ dependencies = [
|
||||
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "c_string"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "external"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.22"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "protover"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"external 0.0.1",
|
||||
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"smartlist 0.0.1",
|
||||
"tor_util 0.0.1",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "smartlist"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[metadata]
|
||||
"checksum libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)" = "babb8281da88cba992fa1f4ddec7d63ed96280a1a53ec9b919fd37b53d71e502"
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
[workspace]
|
||||
members = ["tor_util"]
|
||||
members = ["tor_util", "protover", "smartlist", "external", "c_string"]
|
||||
|
||||
[profile.release]
|
||||
debug = true
|
||||
|
||||
13
src/rust/c_string/Cargo.toml
Normal file
13
src/rust/c_string/Cargo.toml
Normal file
@ -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"]
|
||||
|
||||
19
src/rust/c_string/ffi.rs
Normal file
19
src/rust/c_string/ffi.rs
Normal file
@ -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) };
|
||||
}
|
||||
}
|
||||
12
src/rust/c_string/include.am
Normal file
12
src/rust/c_string/include.am
Normal file
@ -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:
|
||||
|
||||
13
src/rust/external/Cargo.toml
vendored
Normal file
13
src/rust/external/Cargo.toml
vendored
Normal file
@ -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"]
|
||||
|
||||
29
src/rust/external/external.rs
vendored
Normal file
29
src/rust/external/external.rs
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
use libc::{c_char, c_int};
|
||||
use std::ffi::CString;
|
||||
|
||||
extern "C" {
|
||||
fn tor_version_as_new_as(
|
||||
platform: *const c_char,
|
||||
cutoff: *const c_char,
|
||||
) -> c_int;
|
||||
}
|
||||
|
||||
/// Wrap calls to tor_version_as_new_as, defined in src/or/routerparse.c
|
||||
pub fn c_tor_version_as_new_as(platform: &str, cutoff: &str) -> bool {
|
||||
// CHK: These functions should log a warning if an error occurs. This
|
||||
// can be added when integration with tor's logger is added to rust
|
||||
let c_platform = match CString::new(platform) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return false,
|
||||
};
|
||||
let c_cutoff = match CString::new(cutoff) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return false,
|
||||
};
|
||||
|
||||
let result: c_int;
|
||||
unsafe {
|
||||
result = tor_version_as_new_as(c_platform.as_ptr(), c_cutoff.as_ptr());
|
||||
result == 1
|
||||
}
|
||||
}
|
||||
14
src/rust/external/lib.rs
vendored
Normal file
14
src/rust/external/lib.rs
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
//! Copyright (c) 2016-2017, The Tor Project, Inc. */
|
||||
//! See LICENSE for licensing information */
|
||||
|
||||
//! Interface for external calls to tor C ABI
|
||||
//!
|
||||
//! The purpose of this module is to provide a clean interface for when Rust
|
||||
//! modules need to interact with functionality in tor C code rather than each
|
||||
//! module implementing this functionality repeatedly.
|
||||
|
||||
extern crate libc;
|
||||
|
||||
mod external;
|
||||
|
||||
pub use external::*;
|
||||
@ -1,4 +1,6 @@
|
||||
include src/rust/tor_util/include.am
|
||||
include src/rust/protover/include.am
|
||||
include src/rust/c_string/include.am
|
||||
|
||||
EXTRA_DIST +=\
|
||||
src/rust/Cargo.toml \
|
||||
|
||||
22
src/rust/protover/Cargo.toml
Normal file
22
src/rust/protover/Cargo.toml
Normal file
@ -0,0 +1,22 @@
|
||||
[package]
|
||||
authors = ["The Tor Project"]
|
||||
version = "0.0.1"
|
||||
name = "protover"
|
||||
|
||||
[dependencies]
|
||||
libc = "0.2.22"
|
||||
|
||||
[dependencies.smartlist]
|
||||
path = "../smartlist"
|
||||
|
||||
[dependencies.external]
|
||||
path = "../external"
|
||||
|
||||
[dependencies.tor_util]
|
||||
path = "../tor_util"
|
||||
|
||||
[lib]
|
||||
name = "protover"
|
||||
path = "lib.rs"
|
||||
crate_type = ["rlib", "staticlib"]
|
||||
|
||||
205
src/rust/protover/ffi.rs
Normal file
205
src/rust/protover/ffi.rs
Normal file
@ -0,0 +1,205 @@
|
||||
//! FFI functions, only to be called from C.
|
||||
//!
|
||||
//! Equivalent C versions of this api are in `src/or/protover.c`
|
||||
|
||||
use libc::{c_char, c_int, uint32_t};
|
||||
use std::ffi::CStr;
|
||||
use std::ffi::CString;
|
||||
|
||||
use protover::*;
|
||||
use smartlist::*;
|
||||
|
||||
/// Translate C enums to Rust Proto enums, using the integer value of the C
|
||||
/// enum to map to its associated Rust enum
|
||||
/// This is dependant on the associated C enum preserving ordering.
|
||||
/// Modify the C documentation to give warnings- you must also re-order the rust
|
||||
fn translate_to_rust(c_proto: uint32_t) -> Result<Proto, &'static str> {
|
||||
match c_proto {
|
||||
0 => Ok(Proto::Link),
|
||||
1 => Ok(Proto::LinkAuth),
|
||||
2 => Ok(Proto::Relay),
|
||||
3 => Ok(Proto::DirCache),
|
||||
4 => Ok(Proto::HSDir),
|
||||
5 => Ok(Proto::HSIntro),
|
||||
6 => Ok(Proto::HSRend),
|
||||
7 => Ok(Proto::Desc),
|
||||
8 => Ok(Proto::Microdesc),
|
||||
9 => Ok(Proto::Cons),
|
||||
_ => Err("Invalid protocol type"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Provide an interface for C to translate arguments and return types for
|
||||
/// protover::all_supported
|
||||
#[no_mangle]
|
||||
pub extern "C" fn rust_protover_all_supported(
|
||||
c_relay_version: *const c_char,
|
||||
missing_out: *mut *mut c_char,
|
||||
) -> c_int {
|
||||
|
||||
if c_relay_version.is_null() {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Require an unsafe block to read the version from a C string. The pointer
|
||||
// is checked above to ensure it is not null.
|
||||
let c_str: &CStr;
|
||||
unsafe {
|
||||
c_str = CStr::from_ptr(c_relay_version);
|
||||
}
|
||||
|
||||
let relay_version = match c_str.to_str() {
|
||||
Ok(n) => n,
|
||||
Err(_) => return 1,
|
||||
};
|
||||
|
||||
let (is_supported, unsupported) = all_supported(relay_version);
|
||||
|
||||
if unsupported.len() > 0 {
|
||||
let c_unsupported = match CString::new(unsupported) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return 1,
|
||||
};
|
||||
|
||||
let ptr = c_unsupported.into_raw();
|
||||
unsafe { *missing_out = ptr };
|
||||
}
|
||||
|
||||
return if is_supported { 1 } else { 0 };
|
||||
}
|
||||
|
||||
/// Provide an interface for C to translate arguments and return types for
|
||||
/// protover::list_supports_protocol
|
||||
#[no_mangle]
|
||||
pub extern "C" fn rust_protocol_list_supports_protocol(
|
||||
c_protocol_list: *const c_char,
|
||||
c_protocol: uint32_t,
|
||||
version: uint32_t,
|
||||
) -> c_int {
|
||||
if c_protocol_list.is_null() {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Require an unsafe block to read the version from a C string. The pointer
|
||||
// is checked above to ensure it is not null.
|
||||
let c_str: &CStr;
|
||||
unsafe {
|
||||
c_str = CStr::from_ptr(c_protocol_list);
|
||||
}
|
||||
|
||||
let protocol_list = match c_str.to_str() {
|
||||
Ok(n) => n,
|
||||
Err(_) => return 1,
|
||||
};
|
||||
|
||||
let protocol = match translate_to_rust(c_protocol) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return 0,
|
||||
};
|
||||
|
||||
let is_supported =
|
||||
protover_string_supports_protocol(protocol_list, protocol, version);
|
||||
|
||||
return if is_supported { 1 } else { 0 };
|
||||
}
|
||||
|
||||
/// Provide an interface for C to translate arguments and return types for
|
||||
/// protover::get_supported_protocols
|
||||
#[no_mangle]
|
||||
pub extern "C" fn rust_protover_get_supported_protocols() -> *mut c_char {
|
||||
// Not handling errors when unwrapping as the content is controlled
|
||||
// and is an empty string
|
||||
let empty = CString::new("").unwrap();
|
||||
|
||||
let supported = get_supported_protocols();
|
||||
let c_supported = match CString::new(supported) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return empty.into_raw(),
|
||||
};
|
||||
|
||||
c_supported.into_raw()
|
||||
}
|
||||
|
||||
/// Provide an interface for C to translate arguments and return types for
|
||||
/// protover::compute_vote
|
||||
#[no_mangle]
|
||||
pub extern "C" fn rust_protover_compute_vote(
|
||||
list: *const Stringlist,
|
||||
threshold: c_int,
|
||||
) -> *mut c_char {
|
||||
// Not handling errors when unwrapping as the content is controlled
|
||||
// and is an empty string
|
||||
let empty = CString::new("").unwrap();
|
||||
|
||||
if list.is_null() {
|
||||
return empty.into_raw();
|
||||
}
|
||||
|
||||
// Dereference of raw pointer requires an unsafe block. The pointer is
|
||||
// checked above to ensure it is not null.
|
||||
let data: Vec<String>;
|
||||
unsafe {
|
||||
data = (*list).get_list();
|
||||
}
|
||||
|
||||
let vote = compute_vote(data, threshold);
|
||||
let c_vote = match CString::new(vote) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return empty.into_raw(),
|
||||
};
|
||||
|
||||
c_vote.into_raw()
|
||||
}
|
||||
|
||||
/// Provide an interface for C to translate arguments and return types for
|
||||
/// protover::is_supported_here
|
||||
#[no_mangle]
|
||||
pub extern "C" fn rust_protover_is_supported_here(
|
||||
c_protocol: uint32_t,
|
||||
version: uint32_t,
|
||||
) -> c_int {
|
||||
let protocol = match translate_to_rust(c_protocol) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return 0,
|
||||
};
|
||||
|
||||
let is_supported = is_supported_here(protocol, version);
|
||||
|
||||
return if is_supported { 1 } else { 0 };
|
||||
}
|
||||
|
||||
/// Provide an interface for C to translate arguments and return types for
|
||||
/// protover::compute_for_old_tor
|
||||
#[no_mangle]
|
||||
pub extern "C" fn rust_protover_compute_for_old_tor(
|
||||
version: *const c_char,
|
||||
) -> *mut c_char {
|
||||
// Not handling errors when unwrapping as the content is controlled
|
||||
// and is an empty string
|
||||
let empty = CString::new("").unwrap();
|
||||
|
||||
if version.is_null() {
|
||||
return empty.into_raw();
|
||||
}
|
||||
|
||||
// Require an unsafe block to read the version from a C string. The pointer
|
||||
// is checked above to ensure it is not null.
|
||||
let c_str: &CStr;
|
||||
unsafe {
|
||||
c_str = CStr::from_ptr(version);
|
||||
}
|
||||
|
||||
let version = match c_str.to_str() {
|
||||
Ok(n) => n,
|
||||
Err(_) => return empty.into_raw(),
|
||||
};
|
||||
|
||||
let supported = compute_for_old_tor(&version);
|
||||
|
||||
let c_supported = match CString::new(supported) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return empty.into_raw(),
|
||||
};
|
||||
|
||||
c_supported.into_raw()
|
||||
}
|
||||
14
src/rust/protover/include.am
Normal file
14
src/rust/protover/include.am
Normal file
@ -0,0 +1,14 @@
|
||||
EXTRA_DIST +=\
|
||||
src/rust/protover/Cargo.toml \
|
||||
src/rust/protover/lib.rs \
|
||||
src/rust/protover/ffi.rs \
|
||||
src/rust/protover/external.rs
|
||||
|
||||
src/rust/target/release/@TOR_RUST_PROTOVER_STATIC_NAME@: FORCE
|
||||
( cd "$(abs_top_srcdir)/src/rust/protover" ; \
|
||||
CARGO_TARGET_DIR="$(abs_top_builddir)/src/rust/target" \
|
||||
CARGO_HOME="$(abs_top_builddir)/src/rust" \
|
||||
$(CARGO) build --release --quiet $(CARGO_ONLINE) )
|
||||
|
||||
FORCE:
|
||||
|
||||
34
src/rust/protover/lib.rs
Normal file
34
src/rust/protover/lib.rs
Normal file
@ -0,0 +1,34 @@
|
||||
#![feature(inclusive_range_syntax)]
|
||||
|
||||
//! Copyright (c) 2016-2017, The Tor Project, Inc. */
|
||||
//! See LICENSE for licensing information */
|
||||
|
||||
//! Versioning information for different pieces of the Tor protocol.
|
||||
//!
|
||||
//! The below description is taken from src/rust/protover.c, which is currently
|
||||
//! enabled by default. We are in the process of experimenting with Rust in
|
||||
//! tor, and this protover module is implemented to help achieve this goal.
|
||||
//!
|
||||
//! Starting in version 0.2.9.3-alpha, Tor places separate version numbers on
|
||||
//! each of the different components of its protocol. Relays use these numbers
|
||||
//! to advertise what versions of the protocols they can support, and clients
|
||||
//! use them to find what they can ask a given relay to do. Authorities vote
|
||||
//! on the supported protocol versions for each relay, and also vote on the
|
||||
//! which protocols you should have to support in order to be on the Tor
|
||||
//! network. All Tor instances use these required/recommended protocol versions
|
||||
//! to tell what level of support for recent protocols each relay has, and
|
||||
//! to decide whether they should be running given their current protocols.
|
||||
//!
|
||||
//! The main advantage of these protocol versions numbers over using Tor
|
||||
//! version numbers is that they allow different implementations of the Tor
|
||||
//! protocols to develop independently, without having to claim compatibility
|
||||
//! with specific versions of Tor.
|
||||
|
||||
extern crate libc;
|
||||
extern crate smartlist;
|
||||
extern crate external;
|
||||
|
||||
mod protover;
|
||||
pub mod ffi;
|
||||
|
||||
pub use protover::*;
|
||||
847
src/rust/protover/protover.rs
Normal file
847
src/rust/protover/protover.rs
Normal file
@ -0,0 +1,847 @@
|
||||
use external::c_tor_version_as_new_as;
|
||||
|
||||
use std::str::FromStr;
|
||||
use std::str::SplitN;
|
||||
use std::fmt;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::HashSet;
|
||||
use std::string::String;
|
||||
|
||||
/// The first version of Tor that included "proto" entries in its descriptors.
|
||||
/// Authorities should use this to decide whether to guess proto lines.
|
||||
const FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS: &'static str = "0.2.9.3-alpha";
|
||||
|
||||
/// The maximum number of subprotocol version numbers we will attempt to expand
|
||||
/// before concluding that someone is trying to DoS us
|
||||
const MAX_PROTOCOLS_TO_EXPAND: u32 = 500;
|
||||
|
||||
/// Currently supported protocols and their versions
|
||||
const SUPPORTED_PROTOCOLS: &'static [&'static str] = &[
|
||||
"Cons=1-2",
|
||||
"Desc=1-2",
|
||||
"DirCache=1-2",
|
||||
"HSDir=1-2",
|
||||
"HSIntro=3-4",
|
||||
"HSRend=1-2",
|
||||
"Link=1-4",
|
||||
"LinkAuth=1,3",
|
||||
"Microdesc=1-2",
|
||||
"Relay=1-2",
|
||||
];
|
||||
|
||||
/// Known subprotocols in Tor. Indicates which subprotocol a relay supports.
|
||||
#[derive(Hash, Eq, PartialEq, Debug)]
|
||||
pub enum Proto {
|
||||
Cons,
|
||||
Desc,
|
||||
DirCache,
|
||||
HSDir,
|
||||
HSIntro,
|
||||
HSRend,
|
||||
Link,
|
||||
LinkAuth,
|
||||
Microdesc,
|
||||
Relay,
|
||||
}
|
||||
|
||||
impl fmt::Display for Proto {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "{:?}", self)
|
||||
}
|
||||
}
|
||||
|
||||
/// Translates a string representation of a protocol into a Proto type.
|
||||
/// Error if the string is an unrecognized protocol name.
|
||||
impl FromStr for Proto {
|
||||
type Err = &'static str;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
match s {
|
||||
"Cons" => Ok(Proto::Cons),
|
||||
"Desc" => Ok(Proto::Desc),
|
||||
"DirCache" => Ok(Proto::DirCache),
|
||||
"HSDir" => Ok(Proto::HSDir),
|
||||
"HSIntro" => Ok(Proto::HSIntro),
|
||||
"HSRend" => Ok(Proto::HSRend),
|
||||
"Link" => Ok(Proto::Link),
|
||||
"LinkAuth" => Ok(Proto::LinkAuth),
|
||||
"Microdesc" => Ok(Proto::Microdesc),
|
||||
"Relay" => Ok(Proto::Relay),
|
||||
_ => Err("Not a valid protocol type"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the string representation of current supported protocols
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `String` whose value is the existing protocols supported by tor.
|
||||
/// Returned data is in the format as follows:
|
||||
///
|
||||
/// "HSDir=1-1 LinkAuth=1"
|
||||
///
|
||||
pub fn get_supported_protocols() -> String {
|
||||
SUPPORTED_PROTOCOLS.join(" ")
|
||||
}
|
||||
|
||||
/// Translates a vector representation of a protocol list into a HashMap
|
||||
fn parse_protocols(
|
||||
protocols: &[&str],
|
||||
) -> Result<HashMap<Proto, HashSet<u32>>, &'static str> {
|
||||
let mut parsed = HashMap::new();
|
||||
|
||||
for subproto in protocols {
|
||||
let (name, version) = get_proto_and_vers(subproto)?;
|
||||
parsed.insert(name, version);
|
||||
}
|
||||
Ok(parsed)
|
||||
}
|
||||
|
||||
/// Translates a string representation of a protocol list to a HashMap
|
||||
fn parse_protocols_from_string<'a>(
|
||||
protocol_string: &'a str,
|
||||
) -> Result<HashMap<Proto, HashSet<u32>>, &'static str> {
|
||||
let protocols: &[&'a str] =
|
||||
&protocol_string.split(" ").collect::<Vec<&'a str>>()[..];
|
||||
|
||||
parse_protocols(protocols)
|
||||
}
|
||||
|
||||
/// Translates supported tor versions from a string into a HashMap, which is
|
||||
/// useful when looking up a specific subprotocol.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `Result` whose `Ok` value is a `HashMap<Proto, <u32>>` holding all
|
||||
/// subprotocols and versions currently supported by tor.
|
||||
///
|
||||
/// The returned `Result`'s `Err` value is an `&'static str` with a description
|
||||
/// of the error.
|
||||
///
|
||||
fn tor_supported() -> Result<HashMap<Proto, HashSet<u32>>, &'static str> {
|
||||
parse_protocols(&SUPPORTED_PROTOCOLS)
|
||||
}
|
||||
|
||||
/// Get the unique version numbers supported by a subprotocol.
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// * `version_string`, a string comprised of "[0-9,-]"
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `Result` whose `Ok` value is a `HashSet<u32>` holding all of the unique
|
||||
/// version numbers. If there were ranges in the `version_string`, then these
|
||||
/// are expanded, i.e. `"1-3"` would expand to `HashSet<u32>::new([1, 2, 3])`.
|
||||
/// The returned HashSet is *unordered*.
|
||||
///
|
||||
/// The returned `Result`'s `Err` value is an `&'static str` with a description
|
||||
/// of the error.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will error if:
|
||||
///
|
||||
/// * the `version_string` is empty or contains an equals (`"="`) sign,
|
||||
/// * the expansion of a version range produces an error (see `expand_version_range`),
|
||||
/// * any single version number is not parseable as an `u32` in radix 10, or
|
||||
/// * there are greater than 2^16 version numbers to expand.
|
||||
///
|
||||
fn get_versions(version_string: &str) -> Result<HashSet<u32>, &'static str> {
|
||||
if version_string.is_empty() {
|
||||
return Err("version string is empty");
|
||||
}
|
||||
|
||||
let mut versions = HashSet::<u32>::new();
|
||||
|
||||
for piece in version_string.split(",") {
|
||||
if piece.contains("-") {
|
||||
for p in expand_version_range(piece)? {
|
||||
versions.insert(p);
|
||||
}
|
||||
} else {
|
||||
versions.insert(u32::from_str(piece).or(
|
||||
Err("invalid protocol entry"),
|
||||
)?);
|
||||
}
|
||||
|
||||
if versions.len() > MAX_PROTOCOLS_TO_EXPAND as usize {
|
||||
return Err("Too many versions to expand");
|
||||
}
|
||||
}
|
||||
Ok(versions)
|
||||
}
|
||||
|
||||
|
||||
/// Parse the subprotocol type and its version numbers.
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// * A `protocol_entry` string, comprised of a keyword, an "=" sign, and one
|
||||
/// or more version numbers.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `Result` whose `Ok` value is a tuple of `(Proto, HashSet<u32>)`, where the
|
||||
/// first element is the subprotocol type (see `protover::Proto`) and the last
|
||||
/// element is a(n unordered) set of unique version numbers which are supported.
|
||||
/// Otherwise, the `Err` value of this `Result` is a description of the error
|
||||
///
|
||||
fn get_proto_and_vers<'a>(
|
||||
protocol_entry: &'a str,
|
||||
) -> Result<(Proto, HashSet<u32>), &'static str> {
|
||||
let mut parts: SplitN<'a, &str> = protocol_entry.splitn(2, "=");
|
||||
|
||||
let proto: &str = match parts.next() {
|
||||
Some(n) => n,
|
||||
None => return Err("invalid protover entry"),
|
||||
};
|
||||
|
||||
let vers: &str = match parts.next() {
|
||||
Some(n) => n,
|
||||
None => return Err("invalid protover entry"),
|
||||
};
|
||||
|
||||
let versions = get_versions(vers)?;
|
||||
let proto_name = proto.parse()?;
|
||||
|
||||
Ok((proto_name, versions))
|
||||
}
|
||||
|
||||
/// Parses a single subprotocol entry string into subprotocol and version
|
||||
/// parts, and then checks whether any of those versions are unsupported.
|
||||
/// Helper for protover::all_supported
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// Accepted data is in the string format as follows:
|
||||
///
|
||||
/// "HSDir=1-1"
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// Returns `true` if the protocol entry is well-formatted and only contains
|
||||
/// versions that are also supported in tor. Otherwise, returns false
|
||||
///
|
||||
fn contains_only_supported_protocols(proto_entry: &str) -> bool {
|
||||
let (name, mut vers) = match get_proto_and_vers(proto_entry) {
|
||||
Ok(n) => n,
|
||||
Err(_) => return false,
|
||||
};
|
||||
|
||||
let currently_supported: HashMap<Proto, HashSet<u32>> =
|
||||
match tor_supported() {
|
||||
Ok(n) => n,
|
||||
Err(_) => return false,
|
||||
};
|
||||
|
||||
let supported_versions = match currently_supported.get(&name) {
|
||||
Some(n) => n,
|
||||
None => return false,
|
||||
};
|
||||
|
||||
vers.retain(|x| !supported_versions.contains(x));
|
||||
vers.is_empty()
|
||||
}
|
||||
|
||||
/// Determine if we support every protocol a client supports, and if not,
|
||||
/// determine which protocols we do not have support for.
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// Accepted data is in the string format as follows:
|
||||
///
|
||||
/// "HSDir=1-1 LinkAuth=1-2"
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// Return `true` if every protocol version is one that we support.
|
||||
/// Otherwise, return `false`.
|
||||
/// Optionally, return parameters which the client supports but which we do not
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// use protover::all_supported;
|
||||
///
|
||||
/// let (is_supported, unsupported) = all_supported("Link=1");
|
||||
/// assert_eq!(true, is_supported);
|
||||
///
|
||||
/// let (is_supported, unsupported) = all_supported("Link=5-6");
|
||||
/// assert_eq!(false, is_supported);
|
||||
/// assert_eq!("Link=5-6", unsupported);
|
||||
///
|
||||
pub fn all_supported(protocols: &str) -> (bool, String) {
|
||||
let unsupported: Vec<&str> = protocols
|
||||
.split_whitespace()
|
||||
.filter(|v| !contains_only_supported_protocols(v))
|
||||
.collect::<Vec<&str>>();
|
||||
|
||||
(unsupported.is_empty(), unsupported.join(" "))
|
||||
}
|
||||
|
||||
/// Return true iff the provided protocol list includes support for the
|
||||
/// indicated protocol and version.
|
||||
/// Otherwise, return false
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// * `list`, a string representation of a list of protocol entries.
|
||||
/// * `proto`, a `Proto` to test support for
|
||||
/// * `vers`, a `u32` version which we will go on to determine whether the
|
||||
/// specified protocol supports.
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// use protover::*;
|
||||
///
|
||||
/// let is_supported = protover_string_supports_protocol("Link=3-4 Cons=1", Proto::Cons,1);
|
||||
/// assert_eq!(true, is_supported);
|
||||
///
|
||||
/// let is_not_supported = protover_string_supports_protocol("Link=3-4 Cons=1", Proto::Cons,5);
|
||||
/// assert_eq!(false, is_not_supported)
|
||||
/// ```
|
||||
pub fn protover_string_supports_protocol(
|
||||
list: &str,
|
||||
proto: Proto,
|
||||
vers: u32,
|
||||
) -> bool {
|
||||
let supported: HashMap<Proto, HashSet<u32>>;
|
||||
|
||||
match parse_protocols_from_string(list) {
|
||||
Ok(result) => supported = result,
|
||||
Err(_) => return false,
|
||||
}
|
||||
|
||||
let supported_versions = match supported.get(&proto) {
|
||||
Some(n) => n,
|
||||
None => return false,
|
||||
};
|
||||
|
||||
supported_versions.contains(&vers)
|
||||
}
|
||||
|
||||
/// Fully expand a version range. For example, 1-3 expands to 1,2,3
|
||||
/// Helper for get_versions
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// `range`, a string comprised of "[0-9,-]"
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `Result` whose `Ok` value a vector of unsigned integers representing the
|
||||
/// expanded range of supported versions by a single protocol.
|
||||
/// Otherwise, the `Err` value of this `Result` is a description of the error
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will error if:
|
||||
///
|
||||
/// * the specified range is empty
|
||||
/// * the version range does not contain both a valid lower and upper bound.
|
||||
///
|
||||
fn expand_version_range(range: &str) -> Result<Vec<u32>, &'static str> {
|
||||
if range.is_empty() {
|
||||
return Err("version string empty");
|
||||
}
|
||||
|
||||
let mut parts = range.split("-");
|
||||
|
||||
let lower_string: &str = parts.next().ok_or(
|
||||
"cannot parse protocol range lower bound",
|
||||
)?;
|
||||
|
||||
let lower: u32 = u32::from_str_radix(lower_string, 10).or(Err(
|
||||
"cannot parse protocol range lower bound",
|
||||
))?;
|
||||
|
||||
let higher_string: &str = parts.next().ok_or(
|
||||
"cannot parse protocol range upper bound",
|
||||
)?;
|
||||
|
||||
let higher: u32 = u32::from_str_radix(higher_string, 10).or(Err(
|
||||
"cannot parse protocol range upper bound",
|
||||
))?;
|
||||
|
||||
Ok((lower...higher).collect())
|
||||
}
|
||||
|
||||
/// Checks to see if there is a continuous range of integers, starting at the
|
||||
/// first in the list. Returns the last integer in the range if a range exists.
|
||||
/// Helper for compute_vote
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// `list`, an ordered vector of `u32` integers of "[0-9,-]" representing the
|
||||
/// supported versions for a single protocol.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `bool` indicating whether the list contains a range, starting at the
|
||||
/// first in the list, and an `u32` of the last integer in the range.
|
||||
///
|
||||
/// For example, if given vec![1, 2, 3, 5], find_range will return true,
|
||||
/// as there is a continuous range, and 3, which is the last number in the
|
||||
/// continuous range.
|
||||
///
|
||||
fn find_range(list: &Vec<u32>) -> (bool, u32) {
|
||||
if list.len() == 0 {
|
||||
return (false, 0);
|
||||
}
|
||||
|
||||
let mut iterable = list.iter().peekable();
|
||||
let mut range_end: u32 = match iterable.next() {
|
||||
Some(n) => *n,
|
||||
None => return (false, 0),
|
||||
};
|
||||
|
||||
let mut has_range = false;
|
||||
|
||||
while iterable.peek().is_some() {
|
||||
let n = *iterable.next().unwrap();
|
||||
if n != range_end + 1 {
|
||||
break;
|
||||
}
|
||||
|
||||
has_range = true;
|
||||
range_end = n;
|
||||
}
|
||||
|
||||
(has_range, range_end)
|
||||
}
|
||||
|
||||
/// Contracts a HashSet representation of supported versions into a string.
|
||||
/// Helper for compute_vote
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// `supported_set`, a set of integers of "[0-9,-]" representing the
|
||||
/// supported versions for a single protocol.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `String` representation of this set in ascending order.
|
||||
///
|
||||
fn contract_protocol_list<'a>(supported_set: &'a HashSet<u32>) -> String {
|
||||
let mut supported_clone = supported_set.clone();
|
||||
let mut supported: Vec<u32> = supported_clone.drain().collect();
|
||||
supported.sort();
|
||||
|
||||
let mut final_output: Vec<String> = Vec::new();
|
||||
|
||||
while supported.len() != 0 {
|
||||
let (has_range, end) = find_range(&supported);
|
||||
let current = supported.remove(0);
|
||||
|
||||
if has_range {
|
||||
final_output.push(format!(
|
||||
"{}-{}",
|
||||
current.to_string(),
|
||||
&end.to_string(),
|
||||
));
|
||||
supported.retain(|&x| x > end);
|
||||
} else {
|
||||
final_output.push(current.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
final_output.join(",")
|
||||
}
|
||||
|
||||
/// Parses a protocol list without validating the protocol names
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// * `protocol_string`, a string comprised of keys and values, both which are
|
||||
/// strings. The keys are the protocol names while values are a string
|
||||
/// representation of the supported versions.
|
||||
///
|
||||
/// The input is _not_ expected to be a subset of the Proto types
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `Result` whose `Ok` value is a `HashSet<u32>` holding all of the unique
|
||||
/// version numbers.
|
||||
///
|
||||
/// The returned `Result`'s `Err` value is an `&'static str` with a description
|
||||
/// of the error.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will error if:
|
||||
///
|
||||
/// * The protocol string does not follow the "protocol_name=version_list"
|
||||
/// expected format
|
||||
/// * If the version string is malformed. See `get_versions`.
|
||||
///
|
||||
fn parse_protocols_from_string_with_no_validation<'a>(
|
||||
protocol_string: &'a str,
|
||||
) -> Result<HashMap<String, HashSet<u32>>, &'static str> {
|
||||
let protocols: &[&'a str] =
|
||||
&protocol_string.split(" ").collect::<Vec<&'a str>>()[..];
|
||||
|
||||
let mut parsed: HashMap<String, HashSet<u32>> = HashMap::new();
|
||||
|
||||
for subproto in protocols {
|
||||
let mut parts: SplitN<'a, &str> = subproto.splitn(2, "=");
|
||||
|
||||
let name: &str = match parts.next() {
|
||||
Some(n) => n,
|
||||
None => return Err("invalid protover entry"),
|
||||
};
|
||||
|
||||
let vers: &str = match parts.next() {
|
||||
Some(n) => n,
|
||||
None => return Err("invalid protover entry"),
|
||||
};
|
||||
|
||||
let versions = get_versions(vers)?;
|
||||
|
||||
parsed.insert(String::from(name), versions);
|
||||
}
|
||||
Ok(parsed)
|
||||
}
|
||||
|
||||
/// Protocol voting implementation.
|
||||
///
|
||||
/// Given a list of strings describing protocol versions, return a new
|
||||
/// string encoding all of the protocols that are listed by at
|
||||
/// least threshold of the inputs.
|
||||
///
|
||||
/// The string is sorted according to the following conventions:
|
||||
/// - Protocols names are alphabetized
|
||||
/// - Protocols are in order low to high
|
||||
/// - Individual and ranges are listed together. For example,
|
||||
/// "3, 5-10,13"
|
||||
/// - All entries are unique
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// use protover::compute_vote;
|
||||
///
|
||||
/// let protos = vec![String::from("Link=3-4"), String::from("Link=3")];
|
||||
/// let vote = compute_vote(protos, 2);
|
||||
/// assert_eq!("Link=3", vote)
|
||||
/// ```
|
||||
pub fn compute_vote(
|
||||
list_of_proto_strings: Vec<String>,
|
||||
threshold: i32,
|
||||
) -> String {
|
||||
let empty = String::from("");
|
||||
|
||||
if list_of_proto_strings.is_empty() {
|
||||
return empty;
|
||||
}
|
||||
|
||||
// all_count is a structure to represent the count of the number of
|
||||
// supported versions for a specific protocol. For example, in JSON format:
|
||||
// {
|
||||
// "FirstSupportedProtocol": {
|
||||
// "1": "3",
|
||||
// "2": "1"
|
||||
// }
|
||||
// }
|
||||
// means that FirstSupportedProtocol has three votes which support version
|
||||
// 1, and one vote that supports version 2
|
||||
let mut all_count: HashMap<String, HashMap<u32, usize>> = HashMap::new();
|
||||
|
||||
// parse and collect all of the protos and their versions and collect them
|
||||
for vote in list_of_proto_strings {
|
||||
let this_vote: HashMap<String, HashSet<u32>> =
|
||||
match parse_protocols_from_string_with_no_validation(&vote) {
|
||||
Ok(result) => result,
|
||||
Err(_) => continue,
|
||||
};
|
||||
|
||||
for (protocol, versions) in this_vote {
|
||||
let supported_vers: &mut HashMap<u32, usize> =
|
||||
all_count.entry(protocol).or_insert(HashMap::new());
|
||||
|
||||
for version in versions {
|
||||
let counter: &mut usize =
|
||||
supported_vers.entry(version).or_insert(0);
|
||||
*counter += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut final_output: HashMap<String, String> =
|
||||
HashMap::with_capacity(SUPPORTED_PROTOCOLS.len());
|
||||
|
||||
// Go through and remove verstions that are less than the threshold
|
||||
for (protocol, versions) in all_count {
|
||||
let mut meets_threshold = HashSet::new();
|
||||
for (version, count) in versions {
|
||||
if count >= threshold as usize {
|
||||
meets_threshold.insert(version);
|
||||
}
|
||||
}
|
||||
|
||||
// For each protocol, compress its version list into the expected
|
||||
// protocol version string format
|
||||
let contracted = contract_protocol_list(&meets_threshold);
|
||||
if !contracted.is_empty() {
|
||||
final_output.insert(protocol, contracted);
|
||||
}
|
||||
}
|
||||
|
||||
write_vote_to_string(&final_output)
|
||||
}
|
||||
|
||||
/// Return a String comprised of protocol entries in alphabetical order
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// * `vote`, a `HashMap` comprised of keys and values, both which are strings.
|
||||
/// The keys are the protocol names while values are a string representation of
|
||||
/// the supported versions.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `String` whose value is series of pairs, comprising of the protocol name
|
||||
/// and versions that it supports. The string takes the following format:
|
||||
///
|
||||
/// "first_protocol_name=1,2-5, second_protocol_name=4,5"
|
||||
///
|
||||
/// Sorts the keys in alphabetical order and creates the expected subprotocol
|
||||
/// entry format.
|
||||
///
|
||||
fn write_vote_to_string(vote: &HashMap<String, String>) -> String {
|
||||
let mut keys: Vec<&String> = vote.keys().collect();
|
||||
keys.sort();
|
||||
|
||||
let mut output = Vec::new();
|
||||
for key in keys {
|
||||
// TODO error in indexing here?
|
||||
output.push(format!("{}={}", key, vote[key]));
|
||||
}
|
||||
output.join(" ")
|
||||
}
|
||||
|
||||
/// Returns a boolean indicating whether the given protocol and version is
|
||||
/// supported in any of the existing Tor protocols
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// use protover::*;
|
||||
///
|
||||
/// let is_supported = is_supported_here(Proto::Link, 5);
|
||||
/// assert_eq!(false, is_supported);
|
||||
///
|
||||
/// let is_supported = is_supported_here(Proto::Link, 1);
|
||||
/// assert_eq!(true, is_supported);
|
||||
/// ```
|
||||
pub fn is_supported_here(proto: Proto, vers: u32) -> bool {
|
||||
let currently_supported: HashMap<Proto, HashSet<u32>>;
|
||||
|
||||
match tor_supported() {
|
||||
Ok(result) => currently_supported = result,
|
||||
Err(_) => return false,
|
||||
}
|
||||
|
||||
let supported_versions = match currently_supported.get(&proto) {
|
||||
Some(n) => n,
|
||||
None => return false,
|
||||
};
|
||||
|
||||
supported_versions.contains(&vers)
|
||||
}
|
||||
|
||||
/// Older versions of Tor cannot infer their own subprotocols
|
||||
/// Used to determine which subprotocols are supported by older Tor versions.
|
||||
///
|
||||
/// # Inputs
|
||||
///
|
||||
/// * `version`, a string comprised of "[0-9,-]"
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// A `String` whose value is series of pairs, comprising of the protocol name
|
||||
/// and versions that it supports. The string takes the following format:
|
||||
///
|
||||
/// "HSDir=1-1 LinkAuth=1"
|
||||
///
|
||||
/// This function returns the protocols that are supported by the version input,
|
||||
/// only for tor versions older than FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS.
|
||||
///
|
||||
pub fn compute_for_old_tor(version: &str) -> String {
|
||||
if c_tor_version_as_new_as(
|
||||
version,
|
||||
FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS,
|
||||
)
|
||||
{
|
||||
return String::new();
|
||||
}
|
||||
|
||||
if c_tor_version_as_new_as(version, "0.2.9.1-alpha") {
|
||||
let ret = "Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \
|
||||
Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2";
|
||||
return String::from(ret);
|
||||
}
|
||||
|
||||
if c_tor_version_as_new_as(version, "0.2.7.5") {
|
||||
let ret = "Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
|
||||
Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2";
|
||||
return String::from(ret);
|
||||
}
|
||||
|
||||
if c_tor_version_as_new_as(version, "0.2.4.19") {
|
||||
let ret = "Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
|
||||
Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2";
|
||||
return String::from(ret);
|
||||
}
|
||||
String::new()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
#[test]
|
||||
fn test_get_versions() {
|
||||
use std::collections::HashSet;
|
||||
|
||||
use super::get_versions;
|
||||
|
||||
assert_eq!(Err("version string is empty"), get_versions(""));
|
||||
assert_eq!(Err("invalid protocol entry"), get_versions("a,b"));
|
||||
assert_eq!(Err("invalid protocol entry"), get_versions("1,!"));
|
||||
|
||||
{
|
||||
let mut versions: HashSet<u32> = HashSet::new();
|
||||
versions.insert(1);
|
||||
assert_eq!(Ok(versions), get_versions("1"));
|
||||
}
|
||||
{
|
||||
let mut versions: HashSet<u32> = HashSet::new();
|
||||
versions.insert(1);
|
||||
versions.insert(2);
|
||||
assert_eq!(Ok(versions), get_versions("1,2"));
|
||||
}
|
||||
{
|
||||
let mut versions: HashSet<u32> = HashSet::new();
|
||||
versions.insert(1);
|
||||
versions.insert(2);
|
||||
versions.insert(3);
|
||||
assert_eq!(Ok(versions), get_versions("1-3"));
|
||||
}
|
||||
{
|
||||
let mut versions: HashSet<u32> = HashSet::new();
|
||||
versions.insert(1);
|
||||
versions.insert(2);
|
||||
versions.insert(5);
|
||||
assert_eq!(Ok(versions), get_versions("1-2,5"));
|
||||
}
|
||||
{
|
||||
let mut versions: HashSet<u32> = HashSet::new();
|
||||
versions.insert(1);
|
||||
versions.insert(3);
|
||||
versions.insert(4);
|
||||
versions.insert(5);
|
||||
assert_eq!(Ok(versions), get_versions("1,3-5"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_contains_only_supported_protocols() {
|
||||
use super::contains_only_supported_protocols;
|
||||
|
||||
assert_eq!(false, contains_only_supported_protocols(""));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons="));
|
||||
assert_eq!(true, contains_only_supported_protocols("Cons=1"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=0"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=0-1"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=5"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=1-5"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=1,5"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=5,6"));
|
||||
assert_eq!(false, contains_only_supported_protocols("Cons=1,5,6"));
|
||||
assert_eq!(true, contains_only_supported_protocols("Cons=1,2"));
|
||||
assert_eq!(true, contains_only_supported_protocols("Cons=1-2"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_range() {
|
||||
use super::find_range;
|
||||
|
||||
assert_eq!((false, 0), find_range(&vec![]));
|
||||
assert_eq!((false, 1), find_range(&vec![1]));
|
||||
assert_eq!((true, 2), find_range(&vec![1, 2]));
|
||||
assert_eq!((true, 3), find_range(&vec![1, 2, 3]));
|
||||
assert_eq!((true, 3), find_range(&vec![1, 2, 3, 5]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_version_range() {
|
||||
use super::expand_version_range;
|
||||
|
||||
assert_eq!(Err("version string empty"), expand_version_range(""));
|
||||
assert_eq!(Ok(vec![1, 2]), expand_version_range("1-2"));
|
||||
assert_eq!(Ok(vec![1, 2, 3, 4]), expand_version_range("1-4"));
|
||||
assert_eq!(
|
||||
Err("cannot parse protocol range lower bound"),
|
||||
expand_version_range("a")
|
||||
);
|
||||
assert_eq!(
|
||||
Err("cannot parse protocol range upper bound"),
|
||||
expand_version_range("1-a")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_contract_protocol_list() {
|
||||
use std::collections::HashSet;
|
||||
use super::contract_protocol_list;
|
||||
|
||||
{
|
||||
let mut versions = HashSet::<u32>::new();
|
||||
assert_eq!(String::from(""), contract_protocol_list(&versions));
|
||||
|
||||
versions.insert(1);
|
||||
assert_eq!(String::from("1"), contract_protocol_list(&versions));
|
||||
|
||||
versions.insert(2);
|
||||
assert_eq!(String::from("1-2"), contract_protocol_list(&versions));
|
||||
}
|
||||
|
||||
{
|
||||
let mut versions = HashSet::<u32>::new();
|
||||
versions.insert(1);
|
||||
versions.insert(3);
|
||||
assert_eq!(String::from("1,3"), contract_protocol_list(&versions));
|
||||
}
|
||||
|
||||
{
|
||||
let mut versions = HashSet::<u32>::new();
|
||||
versions.insert(1);
|
||||
versions.insert(2);
|
||||
versions.insert(3);
|
||||
versions.insert(4);
|
||||
assert_eq!(String::from("1-4"), contract_protocol_list(&versions));
|
||||
}
|
||||
|
||||
{
|
||||
let mut versions = HashSet::<u32>::new();
|
||||
versions.insert(1);
|
||||
versions.insert(3);
|
||||
versions.insert(5);
|
||||
versions.insert(6);
|
||||
versions.insert(7);
|
||||
assert_eq!(
|
||||
String::from("1,3,5-7"),
|
||||
contract_protocol_list(&versions)
|
||||
);
|
||||
}
|
||||
|
||||
{
|
||||
let mut versions = HashSet::<u32>::new();
|
||||
versions.insert(1);
|
||||
versions.insert(2);
|
||||
versions.insert(3);
|
||||
versions.insert(500);
|
||||
assert_eq!(
|
||||
String::from("1-3,500"),
|
||||
contract_protocol_list(&versions)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
288
src/rust/protover/tests/protover.rs
Normal file
288
src/rust/protover/tests/protover.rs
Normal file
@ -0,0 +1,288 @@
|
||||
extern crate protover;
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_single_version_returns_set_of_one(){
|
||||
let protocol = "Cons=1";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_multiple_versions_returns_set_of_one(){
|
||||
let protocol = "Cons=1-2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_different_single_protocol_and_single_version_returns_set_of_one(){
|
||||
let protocol = "HSDir=1";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_supported_version_returns_set_of_one(){
|
||||
let protocol = "Desc=2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_two_protocols_and_single_version_returns_set_of_one(){
|
||||
let protocols = "Cons=1 HSDir=1";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_two_nonsequential_versions_returns_set_of_two(){
|
||||
let protocol = "Desc=1,2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_two_sequential_versions_returns_set_of_two(){
|
||||
let protocol = "Desc=1-2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_protocol_range_returns_set() {
|
||||
let protocol = "Link=1-4";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocol);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_protocol_list_with_single_protocol_and_protocol_set() {
|
||||
let protocols = "Link=3-4 Desc=2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_two_values() {
|
||||
let protocols = "Microdesc=1-2 Relay=2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!("", &unsupported);
|
||||
assert_eq!(true, is_supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_one_value() {
|
||||
let protocols = "Microdesc=1-2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!("", &unsupported);
|
||||
assert_eq!(true, is_supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_empty() {
|
||||
let protocols = "";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(true, is_supported);
|
||||
assert_eq!("", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_three_values() {
|
||||
let protocols = "LinkAuth=1 Microdesc=1-2 Relay=2";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!("", &unsupported);
|
||||
assert_eq!(true, is_supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_unsupported_protocol() {
|
||||
let protocols = "Wombat=9";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(false, is_supported);
|
||||
assert_eq!("Wombat=9", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_unsupported_versions() {
|
||||
let protocols = "Link=3-999";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(false, is_supported);
|
||||
assert_eq!("Link=3-999", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_unsupported_low_version() {
|
||||
let protocols = "Cons=0-1";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(false, is_supported);
|
||||
assert_eq!("Cons=0-1", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_unsupported_high_version() {
|
||||
let protocols = "Cons=1-3";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(false, is_supported);
|
||||
assert_eq!("Cons=1-3", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_mix_of_supported_and_unsupproted() {
|
||||
let protocols = "Link=3-4 Wombat=9";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(false, is_supported);
|
||||
assert_eq!("Wombat=9", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_string_supports_protocol_returns_true_for_single_supported() {
|
||||
let protocols = "Link=3-4 Cons=1";
|
||||
let is_supported = protover::protover_string_supports_protocol(
|
||||
protocols,
|
||||
protover::Proto::Cons,
|
||||
1,
|
||||
);
|
||||
assert_eq!(true, is_supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_string_supports_protocol_returns_false_for_single_unsupported() {
|
||||
let protocols = "Link=3-4 Cons=1";
|
||||
let is_supported = protover::protover_string_supports_protocol(
|
||||
protocols,
|
||||
protover::Proto::Cons,
|
||||
2,
|
||||
);
|
||||
assert_eq!(false, is_supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_string_supports_protocol_returns_false_when_protocol_name_is_not_in_map(){
|
||||
let protocols = "Link=3-4";
|
||||
let is_supported = protover::protover_string_supports_protocol(
|
||||
protocols,
|
||||
protover::Proto::Cons,
|
||||
2,
|
||||
);
|
||||
assert_eq!(false, is_supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_all_supported_with_unexpected_characters() {
|
||||
let protocols = "Cons=*-%";
|
||||
let (is_supported, unsupported) = protover::all_supported(protocols);
|
||||
assert_eq!(false, is_supported);
|
||||
assert_eq!("Cons=*-%", &unsupported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_empty_for_empty_string() {
|
||||
let protocols = vec![String::from("")];
|
||||
let listed = protover::compute_vote(protocols, 1);
|
||||
assert_eq!("", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_single_protocol_for_matching() {
|
||||
let protocols = vec![String::from("Cons=1")];
|
||||
let listed = protover::compute_vote(protocols, 1);
|
||||
assert_eq!("Cons=1", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_two_protocols_for_two_matching() {
|
||||
let protocols = vec![String::from("Link=1 Cons=1")];
|
||||
let listed = protover::compute_vote(protocols, 1);
|
||||
assert_eq!("Cons=1 Link=1", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_one_protocol_when_one_out_of_two_matches() {
|
||||
let protocols = vec![String::from("Cons=1 Link=2"), String::from("Cons=1")];
|
||||
let listed = protover::compute_vote(protocols, 2);
|
||||
assert_eq!("Cons=1", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_protocols_that_it_doesnt_currently_support() {
|
||||
let protocols = vec![String::from("Foo=1 Cons=2"), String::from("Bar=1")];
|
||||
let listed = protover::compute_vote(protocols, 1);
|
||||
assert_eq!("Bar=1 Cons=2 Foo=1", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_matching_for_mix() {
|
||||
let protocols = vec![String::from("Link=1-10,500 Cons=1,3-7,8")];
|
||||
let listed = protover::compute_vote(protocols, 1);
|
||||
assert_eq!("Cons=1,3-8 Link=1-10,500", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_matching_for_longer_mix() {
|
||||
let protocols = vec![
|
||||
String::from("Desc=1-10,500 Cons=1,3-7,8"),
|
||||
String::from("Link=123-456,78 Cons=2-6,8 Desc=9"),
|
||||
];
|
||||
|
||||
let listed = protover::compute_vote(protocols, 1);
|
||||
assert_eq!("Cons=1-8 Desc=1-10,500 Link=78,123-456", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_returns_matching_for_longer_mix_with_threshold_two() {
|
||||
let protocols = vec![
|
||||
String::from("Desc=1-10,500 Cons=1,3-7,8"),
|
||||
String::from("Link=123-456,78 Cons=2-6,8 Desc=9"),
|
||||
];
|
||||
|
||||
let listed = protover::compute_vote(protocols, 2);
|
||||
assert_eq!("Cons=3-6,8 Desc=9", listed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_handles_duplicated_versions() {
|
||||
let protocols = vec![String::from("Cons=1"), String::from("Cons=1")];
|
||||
assert_eq!("Cons=1", protover::compute_vote(protocols, 2));
|
||||
|
||||
let protocols = vec![String::from("Cons=1-2"), String::from("Cons=1-2")];
|
||||
assert_eq!("Cons=1-2", protover::compute_vote(protocols, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_compute_vote_handles_invalid_proto_entries() {
|
||||
let protocols = vec![
|
||||
String::from("Cons=1"),
|
||||
String::from("Cons=1"),
|
||||
String::from("Link=a"),
|
||||
];
|
||||
assert_eq!("Cons=1", protover::compute_vote(protocols, 2));
|
||||
|
||||
let protocols = vec![
|
||||
String::from("Cons=1"),
|
||||
String::from("Cons=1"),
|
||||
String::from("Link=1-%"),
|
||||
];
|
||||
assert_eq!("Cons=1", protover::compute_vote(protocols, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_is_supported_here_returns_true_for_supported_protocol() {
|
||||
assert_eq!(true, protover::is_supported_here(protover::Proto::Cons, 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn protover_is_supported_here_returns_false_for_unsupported_protocol() {
|
||||
assert_eq!(false, protover::is_supported_here(protover::Proto::Cons, 5));
|
||||
}
|
||||
13
src/rust/smartlist/Cargo.toml
Normal file
13
src/rust/smartlist/Cargo.toml
Normal file
@ -0,0 +1,13 @@
|
||||
[package]
|
||||
authors = ["The Tor Project"]
|
||||
version = "0.0.1"
|
||||
name = "smartlist"
|
||||
|
||||
[dependencies]
|
||||
libc = "0.2.22"
|
||||
|
||||
[lib]
|
||||
name = "smartlist"
|
||||
path = "lib.rs"
|
||||
crate_type = ["rlib", "staticlib"]
|
||||
|
||||
5
src/rust/smartlist/lib.rs
Normal file
5
src/rust/smartlist/lib.rs
Normal file
@ -0,0 +1,5 @@
|
||||
extern crate libc;
|
||||
|
||||
mod smartlist;
|
||||
|
||||
pub use smartlist::*;
|
||||
100
src/rust/smartlist/smartlist.rs
Normal file
100
src/rust/smartlist/smartlist.rs
Normal file
@ -0,0 +1,100 @@
|
||||
use std::slice;
|
||||
use libc::c_char;
|
||||
use std::ffi::CStr;
|
||||
|
||||
/// Smartlists are a type used in C code in tor to define a collection of a
|
||||
/// generic type, which has a capacity and a number used. Each Smartlist
|
||||
/// defines how to extract the list of values from the underlying C structure
|
||||
/// Implementations are required to have a C representation
|
||||
pub trait Smartlist<T> {
|
||||
fn get_list(&self) -> Vec<T>;
|
||||
}
|
||||
#[repr(C)]
|
||||
pub struct Stringlist {
|
||||
pub list: *const *const c_char,
|
||||
pub num_used: u8,
|
||||
pub capacity: u8,
|
||||
}
|
||||
|
||||
impl Smartlist<String> for Stringlist {
|
||||
fn get_list(&self) -> Vec<String> {
|
||||
let empty: Vec<String> = Vec::new();
|
||||
let mut v: Vec<String> = Vec::new();
|
||||
|
||||
if self.list.is_null() {
|
||||
return empty;
|
||||
}
|
||||
|
||||
// unsafe, as we need to extract the smartlist list into a vector of
|
||||
// pointers, and then transform each element into a Rust string.
|
||||
unsafe {
|
||||
let elems =
|
||||
slice::from_raw_parts(self.list, self.num_used as usize);
|
||||
|
||||
for i in elems.iter() {
|
||||
let c_str = CStr::from_ptr(*i);
|
||||
let r_str = match c_str.to_str() {
|
||||
Ok(n) => n,
|
||||
Err(_) => return empty,
|
||||
};
|
||||
v.push(String::from(r_str));
|
||||
}
|
||||
}
|
||||
|
||||
v
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
#[test]
|
||||
fn test_get_list_of_strings() {
|
||||
extern crate libc;
|
||||
|
||||
use std::ffi::CString;
|
||||
use libc::c_char;
|
||||
|
||||
use super::Smartlist;
|
||||
use super::Stringlist;
|
||||
|
||||
{
|
||||
// test to verify that null pointers are gracefully handled
|
||||
use std::ptr;
|
||||
|
||||
let sl = Stringlist {
|
||||
list: ptr::null(),
|
||||
num_used: 0,
|
||||
capacity: 0,
|
||||
};
|
||||
|
||||
let data = sl.get_list();
|
||||
assert_eq!(0, data.len());
|
||||
}
|
||||
|
||||
{
|
||||
let args = vec![String::from("a"), String::from("b")];
|
||||
|
||||
// for each string, transform it into a CString
|
||||
let c_strings: Vec<_> = args.iter()
|
||||
.map(|arg| CString::new(arg.as_str()).unwrap())
|
||||
.collect();
|
||||
|
||||
// then, collect a pointer for each CString
|
||||
let p_args: Vec<_> =
|
||||
c_strings.iter().map(|arg| arg.as_ptr()).collect();
|
||||
|
||||
// then, collect a pointer for the list itself
|
||||
let p: *const *const c_char = p_args.as_ptr();
|
||||
|
||||
let sl = Stringlist {
|
||||
list: p,
|
||||
num_used: 2,
|
||||
capacity: 2,
|
||||
};
|
||||
|
||||
let data = sl.get_list();
|
||||
assert_eq!("a", &data[0]);
|
||||
assert_eq!("b", &data[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -9,5 +9,5 @@ path = "lib.rs"
|
||||
crate_type = ["rlib", "staticlib"]
|
||||
|
||||
[dependencies]
|
||||
libc = "*"
|
||||
libc = "0.2.22"
|
||||
|
||||
|
||||
@ -12,6 +12,13 @@ static void
|
||||
test_protover_parse(void *arg)
|
||||
{
|
||||
(void) arg;
|
||||
#ifdef HAVE_RUST
|
||||
/** This test is disabled on rust builds, because it only exists to test
|
||||
* internal C functions. */
|
||||
tt_skip();
|
||||
done:
|
||||
;
|
||||
#else
|
||||
char *re_encoded = NULL;
|
||||
|
||||
const char *orig = "Foo=1,3 Bar=3 Baz= Quux=9-12,14,15-16,900";
|
||||
@ -78,12 +85,18 @@ test_protover_parse(void *arg)
|
||||
SMARTLIST_FOREACH(elts, proto_entry_t *, ent, proto_entry_free(ent));
|
||||
smartlist_free(elts);
|
||||
tor_free(re_encoded);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void
|
||||
test_protover_parse_fail(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
#ifdef HAVE_RUST
|
||||
/** This test is disabled on rust builds, because it only exists to test
|
||||
* internal C functions. */
|
||||
tt_skip();
|
||||
#else
|
||||
smartlist_t *elts;
|
||||
|
||||
/* random junk */
|
||||
@ -109,7 +122,7 @@ test_protover_parse_fail(void *arg)
|
||||
/* Broken range */
|
||||
elts = parse_protocol_list("Link=1,9-8,3");
|
||||
tt_ptr_op(elts, OP_EQ, NULL);
|
||||
|
||||
#endif
|
||||
done:
|
||||
;
|
||||
}
|
||||
@ -182,6 +195,32 @@ test_protover_all_supported(void *arg)
|
||||
tor_free(msg);
|
||||
}
|
||||
|
||||
static void
|
||||
test_protover_list_supports_protocol_returns_true(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
|
||||
const char *protocols = "Link=1";
|
||||
int is_supported = protocol_list_supports_protocol(protocols, PRT_LINK, 1);
|
||||
tt_int_op(is_supported, OP_EQ, 1);
|
||||
|
||||
done:
|
||||
;
|
||||
}
|
||||
|
||||
static void
|
||||
test_protover_list_supports_protocol_for_unsupported_returns_false(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
|
||||
const char *protocols = "Link=1";
|
||||
int is_supported = protocol_list_supports_protocol(protocols, PRT_LINK, 10);
|
||||
tt_int_op(is_supported, OP_EQ, 0);
|
||||
|
||||
done:
|
||||
;
|
||||
}
|
||||
|
||||
#define PV_TEST(name, flags) \
|
||||
{ #name, test_protover_ ##name, (flags), NULL, NULL }
|
||||
|
||||
@ -190,6 +229,8 @@ struct testcase_t protover_tests[] = {
|
||||
PV_TEST(parse_fail, 0),
|
||||
PV_TEST(vote, 0),
|
||||
PV_TEST(all_supported, 0),
|
||||
PV_TEST(list_supports_protocol_for_unsupported_returns_false, 0),
|
||||
PV_TEST(list_supports_protocol_returns_true, 0),
|
||||
END_OF_TESTCASES
|
||||
};
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user