commit 6b609ce4356423a28e7b421a9f09849d831a0c6f
Author: cypherpunks <cypherpunks(a)torproject.org>
Date: Fri Aug 3 19:48:10 2018 +0000
rust: run rustfmt
---
src/rust/build.rs | 35 ++++-----
src/rust/crypto/digests/sha2.rs | 36 +++++----
src/rust/crypto/lib.rs | 2 +-
src/rust/crypto/rand/rng.rs | 29 +++++---
src/rust/external/crypto_digest.rs | 118 +++++++++++++++++++++---------
src/rust/external/crypto_rand.rs | 7 +-
src/rust/external/external.rs | 9 +--
src/rust/protover/errors.rs | 38 ++++++----
src/rust/protover/ffi.rs | 19 ++---
src/rust/protover/lib.rs | 4 +-
src/rust/protover/protoset.rs | 62 ++++++++++------
src/rust/protover/protover.rs | 134 +++++++++++++++++++++-------------
src/rust/protover/tests/protover.rs | 24 ++++--
src/rust/smartlist/smartlist.rs | 10 +--
src/rust/tor_allocate/tor_allocate.rs | 14 ++--
src/rust/tor_log/tor_log.rs | 35 ++++-----
src/rust/tor_rust/lib.rs | 4 +-
src/rust/tor_util/ffi.rs | 4 +-
src/rust/tor_util/strings.rs | 4 +-
19 files changed, 346 insertions(+), 242 deletions(-)
diff --git a/src/rust/build.rs b/src/rust/build.rs
index 2ac24b334..bf389cf7d 100644
--- a/src/rust/build.rs
+++ b/src/rust/build.rs
@@ -10,14 +10,12 @@
use std::collections::HashMap;
use std::env;
use std::fs::File;
-use std::io::prelude::*;
use std::io;
+use std::io::prelude::*;
use std::path::PathBuf;
/// Wrapper around a key-value map.
-struct Config(
- HashMap<String,String>
-);
+struct Config(HashMap<String, String>);
/// Locate a config.rust file generated by autoconf, starting in the OUT_DIR
/// location provided by cargo and recursing up the directory tree. Note that
@@ -31,9 +29,9 @@ fn find_cfg() -> io::Result<String> {
return Ok(path.to_str().unwrap().to_owned());
}
path.pop(); // remove config.rust
- if ! path.pop() { // can't remove last part of directory
- return Err(io::Error::new(io::ErrorKind::NotFound,
- "No config.rust"));
+ if !path.pop() {
+ // can't remove last part of directory
+ return Err(io::Error::new(io::ErrorKind::NotFound, "No config.rust"));
}
}
}
@@ -55,12 +53,11 @@ impl Config {
}
let idx = match s.find("=") {
None => {
- return Err(io::Error::new(io::ErrorKind::InvalidData,
- "missing ="));
- },
- Some(x) => x
+ return Err(io::Error::new(io::ErrorKind::InvalidData, "missing ="));
+ }
+ Some(x) => x,
};
- let (var,eq_val) = s.split_at(idx);
+ let (var, eq_val) = s.split_at(idx);
let val = &eq_val[1..];
map.insert(var.to_owned(), val.to_owned());
}
@@ -70,34 +67,34 @@ impl Config {
/// Return a reference to the value whose key is 'key'.
///
/// Panics if 'key' is not found in the configuration.
- fn get(&self, key : &str) -> &str {
+ fn get(&self, key: &str) -> &str {
self.0.get(key).unwrap()
}
/// Add a dependency on a static C library that is part of Tor, by name.
- fn component(&self, s : &str) {
+ fn component(&self, s: &str) {
println!("cargo:rustc-link-lib=static={}", s);
}
/// Add a dependency on a native library that is not part of Tor, by name.
- fn dependency(&self, s : &str) {
+ fn dependency(&self, s: &str) {
println!("cargo:rustc-link-lib={}", s);
}
/// Add a link path, relative to Tor's build directory.
- fn link_relpath(&self, s : &str) {
+ fn link_relpath(&self, s: &str) {
let builddir = self.get("BUILDDIR");
println!("cargo:rustc-link-search=native={}/{}", builddir, s);
}
/// Add an absolute link path.
- fn link_path(&self, s : &str) {
+ fn link_path(&self, s: &str) {
println!("cargo:rustc-link-search=native={}", s);
}
/// Parse the CFLAGS in s, looking for -l and -L items, and adding
/// rust configuration as appropriate.
- fn from_cflags(&self, s : &str) {
+ fn from_cflags(&self, s: &str) {
let mut next_is_lib = false;
let mut next_is_path = false;
for ent in self.get(s).split_whitespace() {
@@ -184,7 +181,7 @@ pub fn main() {
cfg.from_cflags("TOR_LZMA_LIBS");
cfg.from_cflags("TOR_ZSTD_LIBS");
cfg.from_cflags("LIBS");
- },
+ }
_ => {
panic!("No configuration in build.rs for package {}", package);
}
diff --git a/src/rust/crypto/digests/sha2.rs b/src/rust/crypto/digests/sha2.rs
index d0246eeb9..55d002766 100644
--- a/src/rust/crypto/digests/sha2.rs
+++ b/src/rust/crypto/digests/sha2.rs
@@ -6,17 +6,17 @@
pub use digest::Digest;
+use digest::generic_array::typenum::U32;
+use digest::generic_array::typenum::U64;
+use digest::generic_array::GenericArray;
use digest::BlockInput;
use digest::FixedOutput;
use digest::Input;
-use digest::generic_array::GenericArray;
-use digest::generic_array::typenum::U32;
-use digest::generic_array::typenum::U64;
-use external::crypto_digest::CryptoDigest;
-use external::crypto_digest::DigestAlgorithm;
use external::crypto_digest::get_256_bit_digest;
use external::crypto_digest::get_512_bit_digest;
+use external::crypto_digest::CryptoDigest;
+use external::crypto_digest::DigestAlgorithm;
pub use external::crypto_digest::DIGEST256_LEN;
pub use external::crypto_digest::DIGEST512_LEN;
@@ -54,7 +54,9 @@ pub struct Sha256 {
/// A new `Sha256` digest.
impl Default for Sha256 {
fn default() -> Sha256 {
- Sha256{ engine: CryptoDigest::new(Some(DigestAlgorithm::SHA2_256)) }
+ Sha256 {
+ engine: CryptoDigest::new(Some(DigestAlgorithm::SHA2_256)),
+ }
}
}
@@ -121,7 +123,9 @@ pub struct Sha512 {
/// A new `Sha512` digest.
impl Default for Sha512 {
fn default() -> Sha512 {
- Sha512{ engine: CryptoDigest::new(Some(DigestAlgorithm::SHA2_512)) }
+ Sha512 {
+ engine: CryptoDigest::new(Some(DigestAlgorithm::SHA2_512)),
+ }
}
}
@@ -182,9 +186,10 @@ mod test {
fn sha256_digest() {
let mut h: Sha256 = Sha256::new();
let mut result: [u8; DIGEST256_LEN] = [0u8; DIGEST256_LEN];
- let expected = [151, 223, 53, 136, 181, 163, 242, 75, 171, 195,
- 133, 27, 55, 47, 11, 167, 26, 157, 205, 222, 212,
- 59, 20, 185, 208, 105, 97, 191, 193, 112, 125, 157];
+ let expected = [
+ 151, 223, 53, 136, 181, 163, 242, 75, 171, 195, 133, 27, 55, 47, 11, 167, 26, 157, 205,
+ 222, 212, 59, 20, 185, 208, 105, 97, 191, 193, 112, 125, 157,
+ ];
h.input(b"foo");
h.input(b"bar");
@@ -209,11 +214,12 @@ mod test {
let mut h: Sha512 = Sha512::new();
let mut result: [u8; DIGEST512_LEN] = [0u8; DIGEST512_LEN];
- let expected = [203, 55, 124, 16, 176, 245, 166, 44, 128, 54, 37, 167,
- 153, 217, 233, 8, 190, 69, 231, 103, 245, 209, 71, 212, 116,
- 73, 7, 203, 5, 89, 122, 164, 237, 211, 41, 160, 175, 20, 122,
- 221, 12, 244, 24, 30, 211, 40, 250, 30, 121, 148, 38, 88, 38,
- 179, 237, 61, 126, 246, 240, 103, 202, 153, 24, 90];
+ let expected = [
+ 203, 55, 124, 16, 176, 245, 166, 44, 128, 54, 37, 167, 153, 217, 233, 8, 190, 69, 231,
+ 103, 245, 209, 71, 212, 116, 73, 7, 203, 5, 89, 122, 164, 237, 211, 41, 160, 175, 20,
+ 122, 221, 12, 244, 24, 30, 211, 40, 250, 30, 121, 148, 38, 88, 38, 179, 237, 61, 126,
+ 246, 240, 103, 202, 153, 24, 90,
+ ];
h.input(b"foo");
h.input(b"bar");
diff --git a/src/rust/crypto/lib.rs b/src/rust/crypto/lib.rs
index 3b58935fd..4eceb4cbd 100644
--- a/src/rust/crypto/lib.rs
+++ b/src/rust/crypto/lib.rs
@@ -42,5 +42,5 @@ extern crate external;
#[macro_use]
extern crate tor_log;
-pub mod digests; // Unfortunately named "digests" plural to avoid name conflict with the digest crate
+pub mod digests; // Unfortunately named "digests" plural to avoid name conflict with the digest crate
pub mod rand;
diff --git a/src/rust/crypto/rand/rng.rs b/src/rust/crypto/rand/rng.rs
index 07a0a7bdc..64ceb2242 100644
--- a/src/rust/crypto/rand/rng.rs
+++ b/src/rust/crypto/rand/rng.rs
@@ -12,15 +12,15 @@
mod internal {
use std::u64;
+ use rand_core::impls::next_u32_via_fill;
+ use rand_core::impls::next_u64_via_fill;
use rand_core::CryptoRng;
use rand_core::Error;
use rand_core::RngCore;
- use rand_core::impls::next_u32_via_fill;
- use rand_core::impls::next_u64_via_fill;
use external::c_tor_crypto_rand;
- use external::c_tor_crypto_strongest_rand;
use external::c_tor_crypto_seed_rng;
+ use external::c_tor_crypto_strongest_rand;
use tor_log::LogDomain;
use tor_log::LogSeverity;
@@ -45,12 +45,15 @@ mod internal {
#[allow(dead_code)]
pub fn new() -> Self {
if !c_tor_crypto_seed_rng() {
- tor_log_msg!(LogSeverity::Warn, LogDomain::General,
- "TorRng::from_seed()",
- "The RNG could not be seeded!");
+ tor_log_msg!(
+ LogSeverity::Warn,
+ LogDomain::General,
+ "TorRng::from_seed()",
+ "The RNG could not be seeded!"
+ );
}
// XXX also log success at info level —isis
- TorRng{ _unused: [0u8; 0] }
+ TorRng { _unused: [0u8; 0] }
}
}
@@ -92,12 +95,15 @@ mod internal {
#[allow(dead_code)]
pub fn new() -> Self {
if !c_tor_crypto_seed_rng() {
- tor_log_msg!(LogSeverity::Warn, LogDomain::General,
- "TorStrongestRng::from_seed()",
- "The RNG could not be seeded!");
+ tor_log_msg!(
+ LogSeverity::Warn,
+ LogDomain::General,
+ "TorStrongestRng::from_seed()",
+ "The RNG could not be seeded!"
+ );
}
// XXX also log success at info level —isis
- TorStrongestRng{ _unused: [0u8; 0] }
+ TorStrongestRng { _unused: [0u8; 0] }
}
}
@@ -137,4 +143,3 @@ mod internal {
// Finally, expose the public functionality of whichever appropriate internal
// module.
pub use self::internal::*;
-
diff --git a/src/rust/external/crypto_digest.rs b/src/rust/external/crypto_digest.rs
index 3e8801f20..ebcf2e88a 100644
--- a/src/rust/external/crypto_digest.rs
+++ b/src/rust/external/crypto_digest.rs
@@ -125,15 +125,35 @@ type smartlist_t = Stringlist;
#[allow(dead_code)]
extern "C" {
fn crypto_digest(digest: *mut c_char, m: *const c_char, len: size_t) -> c_int;
- fn crypto_digest256(digest: *mut c_char, m: *const c_char, len: size_t,
- algorithm: digest_algorithm_t) -> c_int;
- fn crypto_digest512(digest: *mut c_char, m: *const c_char, len: size_t,
- algorithm: digest_algorithm_t) -> c_int;
- fn crypto_common_digests(ds_out: *mut common_digests_t, m: *const c_char, len: size_t) -> c_int;
- fn crypto_digest_smartlist_prefix(digest_out: *mut c_char, len_out: size_t, prepend: *const c_char,
- lst: *const smartlist_t, append: *const c_char, alg: digest_algorithm_t);
- fn crypto_digest_smartlist(digest_out: *mut c_char, len_out: size_t,
- lst: *const smartlist_t, append: *const c_char, alg: digest_algorithm_t);
+ fn crypto_digest256(
+ digest: *mut c_char,
+ m: *const c_char,
+ len: size_t,
+ algorithm: digest_algorithm_t,
+ ) -> c_int;
+ fn crypto_digest512(
+ digest: *mut c_char,
+ m: *const c_char,
+ len: size_t,
+ algorithm: digest_algorithm_t,
+ ) -> c_int;
+ fn crypto_common_digests(ds_out: *mut common_digests_t, m: *const c_char, len: size_t)
+ -> c_int;
+ fn crypto_digest_smartlist_prefix(
+ digest_out: *mut c_char,
+ len_out: size_t,
+ prepend: *const c_char,
+ lst: *const smartlist_t,
+ append: *const c_char,
+ alg: digest_algorithm_t,
+ );
+ fn crypto_digest_smartlist(
+ digest_out: *mut c_char,
+ len_out: size_t,
+ lst: *const smartlist_t,
+ append: *const c_char,
+ alg: digest_algorithm_t,
+ );
fn crypto_digest_algorithm_get_name(alg: digest_algorithm_t) -> *const c_char;
fn crypto_digest_algorithm_get_length(alg: digest_algorithm_t) -> size_t;
fn crypto_digest_algorithm_parse_name(name: *const c_char) -> c_int;
@@ -145,11 +165,21 @@ extern "C" {
fn crypto_digest_get_digest(digest: *mut crypto_digest_t, out: *mut c_char, out_len: size_t);
fn crypto_digest_dup(digest: *const crypto_digest_t) -> *mut crypto_digest_t;
fn crypto_digest_assign(into: *mut crypto_digest_t, from: *const crypto_digest_t);
- fn crypto_hmac_sha256(hmac_out: *mut c_char, key: *const c_char, key_len: size_t,
- msg: *const c_char, msg_len: size_t);
- fn crypto_mac_sha3_256(mac_out: *mut uint8_t, len_out: size_t,
- key: *const uint8_t, key_len: size_t,
- msg: *const uint8_t, msg_len: size_t);
+ fn crypto_hmac_sha256(
+ hmac_out: *mut c_char,
+ key: *const c_char,
+ key_len: size_t,
+ msg: *const c_char,
+ msg_len: size_t,
+ );
+ fn crypto_mac_sha3_256(
+ mac_out: *mut uint8_t,
+ len_out: size_t,
+ key: *const uint8_t,
+ key_len: size_t,
+ msg: *const uint8_t,
+ msg_len: size_t,
+ );
fn crypto_xof_new() -> *mut crypto_xof_t;
fn crypto_xof_add_bytes(xof: *mut crypto_xof_t, data: *const uint8_t, len: size_t);
fn crypto_xof_squeeze_bytes(xof: *mut crypto_xof_t, out: *mut uint8_t, len: size_t);
@@ -238,12 +268,12 @@ impl CryptoDigest {
unsafe {
// XXX This is a pretty awkward API to use from Rust...
digest = match algo {
- DIGEST_SHA1 => crypto_digest_new(),
- DIGEST_SHA256 => crypto_digest256_new(DIGEST_SHA256),
+ DIGEST_SHA1 => crypto_digest_new(),
+ DIGEST_SHA256 => crypto_digest256_new(DIGEST_SHA256),
DIGEST_SHA3_256 => crypto_digest256_new(DIGEST_SHA3_256),
- DIGEST_SHA512 => crypto_digest512_new(DIGEST_SHA512),
+ DIGEST_SHA512 => crypto_digest512_new(DIGEST_SHA512),
DIGEST_SHA3_512 => crypto_digest512_new(DIGEST_SHA3_512),
- _ => abort(),
+ _ => abort(),
}
}
}
@@ -285,9 +315,11 @@ impl CryptoDigest {
/// * `crypto_digest_add_bytes`
pub fn add_bytes(&self, bytes: &[u8]) {
unsafe {
- crypto_digest_add_bytes(self.0 as *mut crypto_digest_t,
- bytes.as_ptr() as *const c_char,
- bytes.len() as size_t)
+ crypto_digest_add_bytes(
+ self.0 as *mut crypto_digest_t,
+ bytes.as_ptr() as *const c_char,
+ bytes.len() as size_t,
+ )
}
}
}
@@ -331,9 +363,11 @@ pub fn get_256_bit_digest(digest: CryptoDigest) -> [u8; DIGEST256_LEN] {
let mut buffer: [u8; DIGEST256_LEN] = [0u8; DIGEST256_LEN];
unsafe {
- crypto_digest_get_digest(digest.0,
- buffer.as_mut_ptr() as *mut c_char,
- DIGEST256_LEN as size_t);
+ crypto_digest_get_digest(
+ digest.0,
+ buffer.as_mut_ptr() as *mut c_char,
+ DIGEST256_LEN as size_t,
+ );
if buffer.as_ptr().is_null() {
abort();
@@ -373,9 +407,11 @@ pub fn get_512_bit_digest(digest: CryptoDigest) -> [u8; DIGEST512_LEN] {
let mut buffer: [u8; DIGEST512_LEN] = [0u8; DIGEST512_LEN];
unsafe {
- crypto_digest_get_digest(digest.0,
- buffer.as_mut_ptr() as *mut c_char,
- DIGEST512_LEN as size_t);
+ crypto_digest_get_digest(
+ digest.0,
+ buffer.as_mut_ptr() as *mut c_char,
+ DIGEST512_LEN as size_t,
+ );
if buffer.as_ptr().is_null() {
abort();
@@ -390,17 +426,29 @@ mod test {
#[test]
fn test_layout_common_digests_t() {
- assert_eq!(::std::mem::size_of::<common_digests_t>(), 64usize,
- concat!("Size of: ", stringify!(common_digests_t)));
- assert_eq!(::std::mem::align_of::<common_digests_t>(), 1usize,
- concat!("Alignment of ", stringify!(common_digests_t)));
+ assert_eq!(
+ ::std::mem::size_of::<common_digests_t>(),
+ 64usize,
+ concat!("Size of: ", stringify!(common_digests_t))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<common_digests_t>(),
+ 1usize,
+ concat!("Alignment of ", stringify!(common_digests_t))
+ );
}
#[test]
fn test_layout_crypto_digest_t() {
- assert_eq!(::std::mem::size_of::<crypto_digest_t>(), 0usize,
- concat!("Size of: ", stringify!(crypto_digest_t)));
- assert_eq!(::std::mem::align_of::<crypto_digest_t>(), 1usize,
- concat!("Alignment of ", stringify!(crypto_digest_t)));
+ assert_eq!(
+ ::std::mem::size_of::<crypto_digest_t>(),
+ 0usize,
+ concat!("Size of: ", stringify!(crypto_digest_t))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<crypto_digest_t>(),
+ 1usize,
+ concat!("Alignment of ", stringify!(crypto_digest_t))
+ );
}
}
diff --git a/src/rust/external/crypto_rand.rs b/src/rust/external/crypto_rand.rs
index af1ade016..b68f98b35 100644
--- a/src/rust/external/crypto_rand.rs
+++ b/src/rust/external/crypto_rand.rs
@@ -2,7 +2,7 @@
// Copyright (c) 2018, isis agora lovecruft
// See LICENSE for licensing information
-//! Bindings to external (P)RNG interfaces and utilities in
+//! Bindings to external (P)RNG interfaces and utilities in
//! src/common/crypto_rand.[ch].
//!
//! We wrap our C implementations in src/common/crypto_rand.[ch] here in order
@@ -80,8 +80,5 @@ pub fn c_tor_crypto_rand_time_range(min: &Duration, max: &Duration) -> Duration
/// Return a pseudorandom 64-bit float, chosen uniformly from the range [0.0, 1.0).
pub fn c_tor_crypto_rand_double() -> f64 {
- unsafe {
- crypto_rand_double()
- }
+ unsafe { crypto_rand_double() }
}
-
diff --git a/src/rust/external/external.rs b/src/rust/external/external.rs
index 059fdd0df..874c7c315 100644
--- a/src/rust/external/external.rs
+++ b/src/rust/external/external.rs
@@ -5,10 +5,7 @@ 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;
+ 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 routerparse.c
@@ -25,9 +22,7 @@ pub fn c_tor_version_as_new_as(platform: &str, cutoff: &str) -> bool {
Err(_) => return false,
};
- let result: c_int = unsafe {
- tor_version_as_new_as(c_platform.as_ptr(), c_cutoff.as_ptr())
- };
+ let result: c_int = unsafe { tor_version_as_new_as(c_platform.as_ptr(), c_cutoff.as_ptr()) };
result == 1
}
diff --git a/src/rust/protover/errors.rs b/src/rust/protover/errors.rs
index 56473d12e..71fbc53e1 100644
--- a/src/rust/protover/errors.rs
+++ b/src/rust/protover/errors.rs
@@ -24,20 +24,30 @@ pub enum ProtoverError {
impl Display for ProtoverError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- ProtoverError::Overlap
- => write!(f, "Two or more (low, high) protover ranges would overlap once expanded."),
- ProtoverError::LowGreaterThanHigh
- => write!(f, "The low in a (low, high) protover range was greater than high."),
- ProtoverError::Unparseable
- => write!(f, "The protover string was unparseable."),
- ProtoverError::ExceedsMax
- => write!(f, "The high in a (low, high) protover range exceeds u32::MAX."),
- ProtoverError::ExceedsExpansionLimit
- => write!(f, "The protover string would exceed the maximum expansion limit."),
- ProtoverError::UnknownProtocol
- => write!(f, "A protocol in the protover string we attempted to parse is unknown."),
- ProtoverError::ExceedsNameLimit
- => write!(f, "An unrecognised protocol name was too long."),
+ ProtoverError::Overlap => write!(
+ f,
+ "Two or more (low, high) protover ranges would overlap once expanded."
+ ),
+ ProtoverError::LowGreaterThanHigh => write!(
+ f,
+ "The low in a (low, high) protover range was greater than high."
+ ),
+ ProtoverError::Unparseable => write!(f, "The protover string was unparseable."),
+ ProtoverError::ExceedsMax => write!(
+ f,
+ "The high in a (low, high) protover range exceeds u32::MAX."
+ ),
+ ProtoverError::ExceedsExpansionLimit => write!(
+ f,
+ "The protover string would exceed the maximum expansion limit."
+ ),
+ ProtoverError::UnknownProtocol => write!(
+ f,
+ "A protocol in the protover string we attempted to parse is unknown."
+ ),
+ ProtoverError::ExceedsNameLimit => {
+ write!(f, "An unrecognised protocol name was too long.")
+ }
}
}
}
diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs
index 91bd83add..0c28d032c 100644
--- a/src/rust/protover/ffi.rs
+++ b/src/rust/protover/ffi.rs
@@ -62,8 +62,7 @@ pub extern "C" fn protover_all_supported(
};
if let Some(unsupported) = relay_proto_entry.all_supported() {
- let c_unsupported: CString = match CString::new(unsupported.to_string())
- {
+ let c_unsupported: CString = match CString::new(unsupported.to_string()) {
Ok(n) => n,
Err(_) => return 1,
};
@@ -113,9 +112,7 @@ pub extern "C" fn protocol_list_supports_protocol(
}
#[no_mangle]
-pub extern "C" fn protover_contains_long_protocol_names_(
- c_protocol_list: *const c_char,
-) -> c_int {
+pub extern "C" fn protover_contains_long_protocol_names_(c_protocol_list: *const c_char) -> c_int {
if c_protocol_list.is_null() {
return 1;
}
@@ -216,8 +213,7 @@ pub extern "C" fn protover_compute_vote(
};
proto_entries.push(entry);
}
- let vote: UnvalidatedProtoEntry =
- ProtoverVote::compute(&proto_entries, &hold);
+ let vote: UnvalidatedProtoEntry = ProtoverVote::compute(&proto_entries, &hold);
allocate_and_copy_string(&vote.to_string())
}
@@ -225,10 +221,7 @@ pub extern "C" fn protover_compute_vote(
/// Provide an interface for C to translate arguments and return types for
/// protover::is_supported_here
#[no_mangle]
-pub extern "C" fn protover_is_supported_here(
- c_protocol: uint32_t,
- version: uint32_t,
-) -> c_int {
+pub extern "C" fn 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,
@@ -242,9 +235,7 @@ pub extern "C" fn protover_is_supported_here(
/// Provide an interface for C to translate arguments and return types for
/// protover::compute_for_old_tor
#[no_mangle]
-pub extern "C" fn protover_compute_for_old_tor(
- version: *const c_char,
-) -> *const c_char {
+pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const c_char {
let supported: &'static CStr;
let empty: &'static CStr;
diff --git a/src/rust/protover/lib.rs b/src/rust/protover/lib.rs
index 4ea20665c..9625cb58a 100644
--- a/src/rust/protover/lib.rs
+++ b/src/rust/protover/lib.rs
@@ -25,16 +25,16 @@
// XXX: add missing docs
//#![deny(missing_docs)]
+extern crate external;
extern crate libc;
extern crate smartlist;
-extern crate external;
extern crate tor_allocate;
#[macro_use]
extern crate tor_util;
pub mod errors;
+pub mod ffi;
pub mod protoset;
mod protover;
-pub mod ffi;
pub use protover::*;
diff --git a/src/rust/protover/protoset.rs b/src/rust/protover/protoset.rs
index 4afc50edf..5cea03983 100644
--- a/src/rust/protover/protoset.rs
+++ b/src/rust/protover/protoset.rs
@@ -53,7 +53,7 @@ impl Default for ProtoSet {
fn default() -> Self {
let pairs: Vec<(Version, Version)> = Vec::new();
- ProtoSet{ pairs }
+ ProtoSet { pairs }
}
}
@@ -73,7 +73,7 @@ impl<'a> ProtoSet {
pairs.sort_unstable();
pairs.dedup();
- ProtoSet{ pairs }.is_ok()
+ ProtoSet { pairs }.is_ok()
}
}
@@ -263,7 +263,8 @@ impl ProtoSet {
/// ```
// XXX we could probably do something more efficient here. —isis
pub fn retain<F>(&mut self, f: F)
- where F: FnMut(&Version) -> bool
+ where
+ F: FnMut(&Version) -> bool,
{
let mut expanded: Vec<Version> = self.clone().expand();
expanded.retain(f);
@@ -299,7 +300,7 @@ impl FromStr for ProtoSet {
/// * there are greater than 2^16 version numbers to expand.
///
/// # Examples
- ///
+ ///
/// ```
/// use std::str::FromStr;
///
@@ -350,10 +351,10 @@ impl FromStr for ProtoSet {
} else if p.contains('-') {
let mut pair = p.split('-');
- let low = pair.next().ok_or(ProtoverError::Unparseable)?;
+ let low = pair.next().ok_or(ProtoverError::Unparseable)?;
let high = pair.next().ok_or(ProtoverError::Unparseable)?;
- let lo: Version = low.parse().or(Err(ProtoverError::Unparseable))?;
+ let lo: Version = low.parse().or(Err(ProtoverError::Unparseable))?;
let hi: Version = high.parse().or(Err(ProtoverError::Unparseable))?;
if lo == u32::MAX || hi == u32::MAX {
@@ -457,11 +458,11 @@ impl From<Vec<Version>> for ProtoSet {
if has_range {
let first: Version = match v.first() {
Some(x) => *x,
- None => continue,
+ None => continue,
};
- let last: Version = match v.get(index) {
+ let last: Version = match v.get(index) {
Some(x) => *x,
- None => continue,
+ None => continue,
};
debug_assert!(last == end, format!("last = {}, end = {}", last, end));
@@ -474,7 +475,7 @@ impl From<Vec<Version>> for ProtoSet {
} else {
let last: Version = match v.get(index) {
Some(x) => *x,
- None => continue,
+ None => continue,
};
version_pairs.push((last, last));
v.remove(index);
@@ -498,22 +499,22 @@ mod test {
}
macro_rules! assert_contains_each {
- ($protoset:expr, $versions:expr) => (
+ ($protoset:expr, $versions:expr) => {
for version in $versions {
assert!($protoset.contains(version));
}
- )
+ };
}
macro_rules! test_protoset_contains_versions {
- ($list:expr, $str:expr) => (
+ ($list:expr, $str:expr) => {
let versions: &[Version] = $list;
let protoset: Result<ProtoSet, ProtoverError> = ProtoSet::from_str($str);
assert!(protoset.is_ok());
let p = protoset.unwrap();
assert_contains_each!(p, versions);
- )
+ };
}
#[test]
@@ -555,26 +556,41 @@ mod test {
#[test]
fn test_versions_from_slice_overlap() {
- assert_eq!(Err(ProtoverError::Overlap), ProtoSet::from_slice(&[(1, 3), (2, 4)]));
+ assert_eq!(
+ Err(ProtoverError::Overlap),
+ ProtoSet::from_slice(&[(1, 3), (2, 4)])
+ );
}
#[test]
fn test_versions_from_str_max() {
- assert_eq!(Err(ProtoverError::ExceedsMax), ProtoSet::from_str("4294967295"));
+ assert_eq!(
+ Err(ProtoverError::ExceedsMax),
+ ProtoSet::from_str("4294967295")
+ );
}
#[test]
fn test_versions_from_slice_max() {
- assert_eq!(Err(ProtoverError::ExceedsMax), ProtoSet::from_slice(&[(4294967295, 4294967295)]));
+ assert_eq!(
+ Err(ProtoverError::ExceedsMax),
+ ProtoSet::from_slice(&[(4294967295, 4294967295)])
+ );
}
#[test]
fn test_protoset_contains() {
let protoset: ProtoSet = ProtoSet::from_slice(&[(0, 5), (7, 9), (13, 14)]).unwrap();
- for x in 0..6 { assert!(protoset.contains(&x), format!("should contain {}", x)); }
- for x in 7..10 { assert!(protoset.contains(&x), format!("should contain {}", x)); }
- for x in 13..15 { assert!(protoset.contains(&x), format!("should contain {}", x)); }
+ for x in 0..6 {
+ assert!(protoset.contains(&x), format!("should contain {}", x));
+ }
+ for x in 7..10 {
+ assert!(protoset.contains(&x), format!("should contain {}", x));
+ }
+ for x in 13..15 {
+ assert!(protoset.contains(&x), format!("should contain {}", x));
+ }
for x in [6, 10, 11, 12, 15, 42, 43, 44, 45, 1234584].iter() {
assert!(!protoset.contains(&x), format!("should not contain {}", x));
@@ -585,7 +601,9 @@ mod test {
fn test_protoset_contains_0_3() {
let protoset: ProtoSet = ProtoSet::from_slice(&[(0, 3)]).unwrap();
- for x in 0..4 { assert!(protoset.contains(&x), format!("should contain {}", x)); }
+ for x in 0..4 {
+ assert!(protoset.contains(&x), format!("should contain {}", x));
+ }
}
macro_rules! assert_protoset_from_vec_contains_all {
@@ -611,7 +629,7 @@ mod test {
#[test]
fn test_protoset_from_vec_unordered() {
- let v: Vec<Version> = vec!(2, 3, 8, 4, 3, 9, 7, 2);
+ let v: Vec<Version> = vec![2, 3, 8, 4, 3, 9, 7, 2];
let ps: ProtoSet = v.into();
assert_eq!(ps.to_string(), "2-4,7-9");
diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs
index 299e43372..933defa70 100644
--- a/src/rust/protover/protover.rs
+++ b/src/rust/protover/protover.rs
@@ -1,8 +1,8 @@
// Copyright (c) 2016-2018, The Tor Project, Inc. */
// See LICENSE for licensing information */
-use std::collections::HashMap;
use std::collections::hash_map;
+use std::collections::HashMap;
use std::ffi::CStr;
use std::fmt;
use std::str;
@@ -12,8 +12,8 @@ use std::string::String;
use external::c_tor_version_as_new_as;
use errors::ProtoverError;
-use protoset::Version;
use protoset::ProtoSet;
+use protoset::Version;
/// The first version of Tor that included "proto" entries in its descriptors.
/// Authorities should use this to decide whether to guess proto lines.
@@ -26,7 +26,7 @@ const FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS: &'static str = "0.2.9.3-alpha";
/// before concluding that someone is trying to DoS us
///
/// C_RUST_COUPLED: protover.c `MAX_PROTOCOLS_TO_EXPAND`
-const MAX_PROTOCOLS_TO_EXPAND: usize = (1<<16);
+const MAX_PROTOCOLS_TO_EXPAND: usize = (1 << 16);
/// The maximum size an `UnknownProtocol`'s name may be.
pub(crate) const MAX_PROTOCOL_NAME_LENGTH: usize = 100;
@@ -132,16 +132,18 @@ impl From<Protocol> for UnknownProtocol {
///
// C_RUST_COUPLED: protover.c `protover_get_supported_protocols`
pub(crate) fn get_supported_protocols_cstr() -> &'static CStr {
- cstr!("Cons=1-2 \
- Desc=1-2 \
- DirCache=1-2 \
- HSDir=1-2 \
- HSIntro=3-4 \
- HSRend=1-2 \
- Link=1-5 \
- LinkAuth=1,3 \
- Microdesc=1-2 \
- Relay=1-2")
+ cstr!(
+ "Cons=1-2 \
+ Desc=1-2 \
+ DirCache=1-2 \
+ HSDir=1-2 \
+ HSIntro=3-4 \
+ HSRend=1-2 \
+ Link=1-5 \
+ LinkAuth=1,3 \
+ Microdesc=1-2 \
+ Relay=1-2"
+ )
}
/// A map of protocol names to the versions of them which are supported.
@@ -150,7 +152,7 @@ pub struct ProtoEntry(HashMap<Protocol, ProtoSet>);
impl Default for ProtoEntry {
fn default() -> ProtoEntry {
- ProtoEntry( HashMap::new() )
+ ProtoEntry(HashMap::new())
}
}
@@ -240,7 +242,7 @@ impl FromStr for ProtoEntry {
/// Generate an implementation of `ToString` for either a `ProtoEntry` or an
/// `UnvalidatedProtoEntry`.
macro_rules! impl_to_string_for_proto_entry {
- ($t:ty) => (
+ ($t:ty) => {
impl ToString for $t {
fn to_string(&self) -> String {
let mut parts: Vec<String> = Vec::new();
@@ -252,7 +254,7 @@ macro_rules! impl_to_string_for_proto_entry {
parts.join(" ")
}
}
- )
+ };
}
impl_to_string_for_proto_entry!(ProtoEntry);
@@ -266,7 +268,7 @@ pub struct UnvalidatedProtoEntry(HashMap<UnknownProtocol, ProtoSet>);
impl Default for UnvalidatedProtoEntry {
fn default() -> UnvalidatedProtoEntry {
- UnvalidatedProtoEntry( HashMap::new() )
+ UnvalidatedProtoEntry(HashMap::new())
}
}
@@ -324,7 +326,7 @@ impl UnvalidatedProtoEntry {
pub fn all_supported(&self) -> Option<UnvalidatedProtoEntry> {
let mut unsupported: UnvalidatedProtoEntry = UnvalidatedProtoEntry::default();
let supported: ProtoEntry = match ProtoEntry::supported() {
- Ok(x) => x,
+ Ok(x) => x,
Err(_) => return None,
};
@@ -454,9 +456,9 @@ impl UnvalidatedProtoEntry {
/// * If a protocol name is an empty string, e.g. `"Cons=1,3 =3-5"`.
/// * If a protocol name cannot be parsed as utf-8.
/// * If the version numbers are an empty string, e.g. `"Cons="`.
- fn parse_protocol_and_version_str<'a>(protocol_string: &'a str)
- -> Result<Vec<(&'a str, &'a str)>, ProtoverError>
- {
+ fn parse_protocol_and_version_str<'a>(
+ protocol_string: &'a str,
+ ) -> Result<Vec<(&'a str, &'a str)>, ProtoverError> {
let mut protovers: Vec<(&str, &str)> = Vec::new();
for subproto in protocol_string.split(' ') {
@@ -523,9 +525,9 @@ impl FromStr for UnvalidatedProtoEntry {
impl UnvalidatedProtoEntry {
/// Create an `UnknownProtocol`, ignoring whether or not it
/// exceeds MAX_PROTOCOL_NAME_LENGTH.
- pub(crate) fn from_str_any_len(protocol_string: &str)
- -> Result<UnvalidatedProtoEntry, ProtoverError>
- {
+ pub(crate) fn from_str_any_len(
+ protocol_string: &str,
+ ) -> Result<UnvalidatedProtoEntry, ProtoverError> {
let mut parsed: UnvalidatedProtoEntry = UnvalidatedProtoEntry::default();
let parts: Vec<(&str, &str)> =
UnvalidatedProtoEntry::parse_protocol_and_version_str(protocol_string)?;
@@ -560,11 +562,11 @@ impl From<ProtoEntry> for UnvalidatedProtoEntry {
/// The "protocols" are *not* guaranteed to be known/supported `Protocol`s, in
/// order to allow new subprotocols to be introduced even if Directory
/// Authorities don't yet know of them.
-pub struct ProtoverVote( HashMap<UnknownProtocol, HashMap<Version, usize>> );
+pub struct ProtoverVote(HashMap<UnknownProtocol, HashMap<Version, usize>>);
impl Default for ProtoverVote {
fn default() -> ProtoverVote {
- ProtoverVote( HashMap::new() )
+ ProtoverVote(HashMap::new())
}
}
@@ -578,9 +580,10 @@ impl IntoIterator for ProtoverVote {
}
impl ProtoverVote {
- pub fn entry(&mut self, key: UnknownProtocol)
- -> hash_map::Entry<UnknownProtocol, HashMap<Version, usize>>
- {
+ pub fn entry(
+ &mut self,
+ key: UnknownProtocol,
+ ) -> hash_map::Entry<UnknownProtocol, HashMap<Version, usize>> {
self.0.entry(key)
}
@@ -602,7 +605,10 @@ impl ProtoverVote {
/// assert_eq!("Link=3", vote.to_string());
/// ```
// C_RUST_COUPLED: protover.c protover_compute_vote
- pub fn compute(proto_entries: &[UnvalidatedProtoEntry], threshold: &usize) -> UnvalidatedProtoEntry {
+ pub fn compute(
+ proto_entries: &[UnvalidatedProtoEntry],
+ threshold: &usize,
+ ) -> UnvalidatedProtoEntry {
let mut all_count: ProtoverVote = ProtoverVote::default();
let mut final_output: UnvalidatedProtoEntry = UnvalidatedProtoEntry::default();
@@ -628,8 +634,7 @@ impl ProtoverVote {
all_count.entry(protocol.clone()).or_insert(HashMap::new());
for version in versions.clone().expand() {
- let counter: &mut usize =
- supported_vers.entry(version).or_insert(0);
+ let counter: &mut usize = supported_vers.entry(version).or_insert(0);
*counter += 1;
}
}
@@ -708,16 +713,22 @@ pub(crate) fn compute_for_old_tor_cstr(version: &str) -> &'static CStr {
return empty;
}
if c_tor_version_as_new_as(version, "0.2.9.1-alpha") {
- return cstr!("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 cstr!(
+ "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"
+ );
}
if c_tor_version_as_new_as(version, "0.2.7.5") {
- return cstr!("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 cstr!(
+ "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"
+ );
}
if c_tor_version_as_new_as(version, "0.2.4.19") {
- return cstr!("Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
- Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2");
+ return cstr!(
+ "Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
+ Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2"
+ );
}
empty
}
@@ -752,7 +763,9 @@ pub(crate) fn compute_for_old_tor_cstr(version: &str) -> &'static CStr {
pub fn compute_for_old_tor(version: &str) -> Result<&'static str, ProtoverError> {
// .to_str() fails with a Utf8Error if it couldn't validate the
// utf-8, so convert that here into an Unparseable ProtoverError.
- compute_for_old_tor_cstr(version).to_str().or(Err(ProtoverError::Unparseable))
+ compute_for_old_tor_cstr(version)
+ .to_str()
+ .or(Err(ProtoverError::Unparseable))
}
#[cfg(test)]
@@ -763,19 +776,19 @@ mod test {
use super::*;
macro_rules! assert_protoentry_is_parseable {
- ($e:expr) => (
+ ($e:expr) => {
let protoentry: Result<ProtoEntry, ProtoverError> = $e.parse();
assert!(protoentry.is_ok(), format!("{:?}", protoentry.err()));
- )
+ };
}
macro_rules! assert_protoentry_is_unparseable {
- ($e:expr) => (
+ ($e:expr) => {
let protoentry: Result<ProtoEntry, ProtoverError> = $e.parse();
assert!(protoentry.is_err());
- )
+ };
}
#[test]
@@ -861,24 +874,45 @@ mod test {
#[test]
fn test_contract_protocol_list() {
let mut versions = "";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
versions = "1";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
versions = "1-2";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
versions = "1,3";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
versions = "1-4";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
versions = "1,3,5-7";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
versions = "1-3,500";
- assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+ assert_eq!(
+ String::from(versions),
+ ProtoSet::from_str(&versions).unwrap().to_string()
+ );
}
}
diff --git a/src/rust/protover/tests/protover.rs b/src/rust/protover/tests/protover.rs
index ac78d34b7..a091e692d 100644
--- a/src/rust/protover/tests/protover.rs
+++ b/src/rust/protover/tests/protover.rs
@@ -3,10 +3,10 @@
extern crate protover;
+use protover::errors::ProtoverError;
use protover::ProtoEntry;
use protover::ProtoverVote;
use protover::UnvalidatedProtoEntry;
-use protover::errors::ProtoverError;
#[test]
fn parse_protocol_with_single_proto_and_single_version() {
@@ -179,14 +179,16 @@ fn protover_compute_vote_returns_two_protocols_for_two_matching() {
#[test]
fn protover_compute_vote_returns_one_protocol_when_one_out_of_two_matches() {
- let protocols: &[UnvalidatedProtoEntry] = &["Cons=1 Link=2".parse().unwrap(), "Cons=1".parse().unwrap()];
+ let protocols: &[UnvalidatedProtoEntry] =
+ &["Cons=1 Link=2".parse().unwrap(), "Cons=1".parse().unwrap()];
let listed = ProtoverVote::compute(protocols, &2);
assert_eq!("Cons=1", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_protocols_that_it_doesnt_currently_support() {
- let protocols: &[UnvalidatedProtoEntry] = &["Foo=1 Cons=2".parse().unwrap(), "Bar=1".parse().unwrap()];
+ let protocols: &[UnvalidatedProtoEntry] =
+ &["Foo=1 Cons=2".parse().unwrap(), "Bar=1".parse().unwrap()];
let listed = ProtoverVote::compute(protocols, &1);
assert_eq!("Bar=1 Cons=2 Foo=1", listed.to_string());
}
@@ -222,10 +224,12 @@ fn protover_compute_vote_returns_matching_for_longer_mix_with_threshold_two() {
#[test]
fn protover_compute_vote_handles_duplicated_versions() {
- let protocols: &[UnvalidatedProtoEntry] = &["Cons=1".parse().unwrap(), "Cons=1".parse().unwrap()];
+ let protocols: &[UnvalidatedProtoEntry] =
+ &["Cons=1".parse().unwrap(), "Cons=1".parse().unwrap()];
assert_eq!("Cons=1", ProtoverVote::compute(protocols, &2).to_string());
- let protocols: &[UnvalidatedProtoEntry] = &["Cons=1-2".parse().unwrap(), "Cons=1-2".parse().unwrap()];
+ let protocols: &[UnvalidatedProtoEntry] =
+ &["Cons=1-2".parse().unwrap(), "Cons=1-2".parse().unwrap()];
assert_eq!("Cons=1-2", ProtoverVote::compute(protocols, &2).to_string());
}
@@ -246,12 +250,18 @@ fn parse_protocol_with_single_protocol_and_two_nonsequential_versions() {
#[test]
fn protover_is_supported_here_returns_true_for_supported_protocol() {
- assert_eq!(true, protover::is_supported_here(&protover::Protocol::Cons, &1));
+ assert_eq!(
+ true,
+ protover::is_supported_here(&protover::Protocol::Cons, &1)
+ );
}
#[test]
fn protover_is_supported_here_returns_false_for_unsupported_protocol() {
- assert_eq!(false, protover::is_supported_here(&protover::Protocol::Cons, &5));
+ assert_eq!(
+ false,
+ protover::is_supported_here(&protover::Protocol::Cons, &5)
+ );
}
#[test]
diff --git a/src/rust/smartlist/smartlist.rs b/src/rust/smartlist/smartlist.rs
index 747d22f78..bce58c0ef 100644
--- a/src/rust/smartlist/smartlist.rs
+++ b/src/rust/smartlist/smartlist.rs
@@ -1,9 +1,9 @@
// Copyright (c) 2016-2018, The Tor Project, Inc. */
// See LICENSE for licensing information */
-use std::slice;
use libc::{c_char, c_int};
use std::ffi::CStr;
+use std::slice;
/// 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
@@ -65,8 +65,8 @@ mod test {
fn test_get_list_of_strings() {
extern crate libc;
- use std::ffi::CString;
use libc::c_char;
+ use std::ffi::CString;
use super::Smartlist;
use super::Stringlist;
@@ -89,13 +89,13 @@ mod test {
let args = vec![String::from("a"), String::from("b")];
// for each string, transform it into a CString
- let c_strings: Vec<_> = args.iter()
+ 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();
+ let p_args: Vec<_> = c_strings.iter().map(|arg| arg.as_ptr()).collect();
let p: *const *const c_char = p_args.as_ptr();
diff --git a/src/rust/tor_allocate/tor_allocate.rs b/src/rust/tor_allocate/tor_allocate.rs
index d0c0d7994..48351d848 100644
--- a/src/rust/tor_allocate/tor_allocate.rs
+++ b/src/rust/tor_allocate/tor_allocate.rs
@@ -3,9 +3,9 @@
// No-op defined purely for testing at the module level
use libc::c_char;
-#[cfg(not(feature = "testing"))]
-use std::{ptr, slice, mem};
use libc::c_void;
+#[cfg(not(feature = "testing"))]
+use std::{mem, ptr, slice};
// Define a no-op implementation for testing Rust modules without linking to C
#[cfg(feature = "testing")]
@@ -72,15 +72,14 @@ mod test {
#[test]
fn test_allocate_and_copy_string_with_empty() {
+ use libc::{c_void, free};
use std::ffi::CStr;
- use libc::{free, c_void};
use tor_allocate::allocate_and_copy_string;
let allocated_empty = allocate_and_copy_string("");
- let allocated_empty_rust =
- unsafe { CStr::from_ptr(allocated_empty).to_str().unwrap() };
+ let allocated_empty_rust = unsafe { CStr::from_ptr(allocated_empty).to_str().unwrap() };
assert_eq!("", allocated_empty_rust);
@@ -89,15 +88,14 @@ mod test {
#[test]
fn test_allocate_and_copy_string_with_not_empty_string() {
+ use libc::{c_void, free};
use std::ffi::CStr;
- use libc::{free, c_void};
use tor_allocate::allocate_and_copy_string;
let allocated_empty = allocate_and_copy_string("foo bar biz");
- let allocated_empty_rust =
- unsafe { CStr::from_ptr(allocated_empty).to_str().unwrap() };
+ let allocated_empty_rust = unsafe { CStr::from_ptr(allocated_empty).to_str().unwrap() };
assert_eq!("foo bar biz", allocated_empty_rust);
diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs
index 49a1e7b15..5231d0c63 100644
--- a/src/rust/tor_log/tor_log.rs
+++ b/src/rust/tor_log/tor_log.rs
@@ -48,12 +48,7 @@ macro_rules! tor_log_msg {
}
#[inline]
-pub fn tor_log_msg_impl(
- severity: LogSeverity,
- domain: LogDomain,
- function: &str,
- message: String,
-) {
+pub fn tor_log_msg_impl(severity: LogSeverity, domain: LogDomain, function: &str, message: String) {
use std::ffi::CString;
/// Default function name to log in case of errors when converting
@@ -63,7 +58,7 @@ pub fn tor_log_msg_impl(
/// Default message to log in case of errors when converting a log
/// message to a CString
const ERR_LOG_MSG: &str = "Unable to log message from Rust \
- module due to error when converting to CString";
+ module due to error when converting to CString";
let func = match CString::new(function) {
Ok(n) => n,
@@ -90,9 +85,9 @@ pub fn tor_log_msg_impl(
/// testing.
#[cfg(not(test))]
pub mod log {
- use libc::{c_char, c_int};
use super::LogDomain;
use super::LogSeverity;
+ use libc::{c_char, c_int};
/// Severity log types. These mirror definitions in /src/common/torlog.h
/// C_RUST_COUPLED: src/common/log.c, log domain types
@@ -144,9 +139,9 @@ pub mod log {
/// without linking to C.
#[cfg(test)]
pub mod log {
- use libc::{c_char, c_int};
use super::LogDomain;
use super::LogSeverity;
+ use libc::{c_char, c_int};
pub static mut LAST_LOGGED_FUNCTION: *mut String = 0 as *mut String;
pub static mut LAST_LOGGED_MESSAGE: *mut String = 0 as *mut String;
@@ -185,8 +180,8 @@ pub mod log {
#[cfg(test)]
mod test {
- use tor_log::*;
use tor_log::log::{LAST_LOGGED_FUNCTION, LAST_LOGGED_MESSAGE};
+ use tor_log::*;
#[test]
fn test_get_log_message() {
@@ -198,7 +193,7 @@ mod test {
"test_macro",
"test log message {}",
"a",
- );
+ );
}
test_macro();
@@ -244,21 +239,21 @@ mod test {
"test_macro",
"{}",
"All the world's a stage, and all the men and women \
- merely players: they have their exits and their \
- entrances; and one man in his time plays many parts, his \
- acts being seven ages."
+ merely players: they have their exits and their \
+ entrances; and one man in his time plays many parts, his \
+ acts being seven ages."
);
}
test_macro();
let expected_string = "All the world's a \
- stage, and all the men \
- and women merely players: \
- they have their exits and \
- their entrances; and one man \
- in his time plays many parts, \
- his acts being seven ages.";
+ stage, and all the men \
+ and women merely players: \
+ they have their exits and \
+ their entrances; and one man \
+ in his time plays many parts, \
+ his acts being seven ages.";
let function = unsafe { Box::from_raw(LAST_LOGGED_FUNCTION) };
assert_eq!("test_macro", *function);
diff --git a/src/rust/tor_rust/lib.rs b/src/rust/tor_rust/lib.rs
index c1585c048..18519f849 100644
--- a/src/rust/tor_rust/lib.rs
+++ b/src/rust/tor_rust/lib.rs
@@ -1,5 +1,5 @@
-extern crate tor_util;
extern crate protover;
+extern crate tor_util;
-pub use tor_util::*;
pub use protover::*;
+pub use tor_util::*;
diff --git a/src/rust/tor_util/ffi.rs b/src/rust/tor_util/ffi.rs
index 4be154ff1..f01559017 100644
--- a/src/rust/tor_util/ffi.rs
+++ b/src/rust/tor_util/ffi.rs
@@ -5,7 +5,7 @@
//! called from C.
//!
-use tor_log::{LogSeverity, LogDomain};
+use tor_log::{LogDomain, LogSeverity};
/// Returns a short string to announce Rust support during startup.
///
@@ -22,6 +22,6 @@ pub extern "C" fn rust_log_welcome_string() {
LogDomain::General,
"rust_log_welcome_string",
"Tor is running with Rust integration. Please report \
- any bugs you encounter."
+ any bugs you encounter."
);
}
diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs
index c365564e9..d64275e06 100644
--- a/src/rust/tor_util/strings.rs
+++ b/src/rust/tor_util/strings.rs
@@ -131,10 +131,10 @@ mod test {
#[test]
fn cstr_macro_bad_input() {
- let waving: &'static CStr = cstr!("waving not drowning o/");
+ let waving: &'static CStr = cstr!("waving not drowning o/");
let drowning: &'static CStr = cstr!("\0 drowning not waving");
- assert!(waving.to_str().unwrap() == "waving not drowning o/");
+ assert!(waving.to_str().unwrap() == "waving not drowning o/");
assert!(drowning.to_str().unwrap() == "")
}
}
