From 6b609ce4356423a28e7b421a9f09849d831a0c6f Mon Sep 17 00:00:00 2001 From: cypherpunks Date: Fri, 3 Aug 2018 19:48:10 +0000 Subject: [PATCH] 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 2ac24b334b..bf389cf7df 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 -); +struct Config(HashMap); /// 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 { 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 d0246eeb94..55d0027665 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 3b58935fda..4eceb4cbd1 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 07a0a7bdc7..64ceb22424 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 3e8801f203..ebcf2e88a9 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::(), 64usize, - concat!("Size of: ", stringify!(common_digests_t))); - assert_eq!(::std::mem::align_of::(), 1usize, - concat!("Alignment of ", stringify!(common_digests_t))); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(common_digests_t)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(common_digests_t)) + ); } #[test] fn test_layout_crypto_digest_t() { - assert_eq!(::std::mem::size_of::(), 0usize, - concat!("Size of: ", stringify!(crypto_digest_t))); - assert_eq!(::std::mem::align_of::(), 1usize, - concat!("Alignment of ", stringify!(crypto_digest_t))); + assert_eq!( + ::std::mem::size_of::(), + 0usize, + concat!("Size of: ", stringify!(crypto_digest_t)) + ); + assert_eq!( + ::std::mem::align_of::(), + 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 af1ade0161..b68f98b358 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 059fdd0df7..874c7c3153 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 56473d12e6..71fbc53e17 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 91bd83addf..0c28d032c6 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 4ea20665c8..9625cb58ad 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 4afc50edf8..5cea03983a 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(&mut self, f: F) - where F: FnMut(&Version) -> bool + where + F: FnMut(&Version) -> bool, { let mut expanded: Vec = 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> 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> 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::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 = vec!(2, 3, 8, 4, 3, 9, 7, 2); + let v: Vec = 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 299e433722..933defa705 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 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); 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 = 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); 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 { 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, ProtoverError> - { + fn parse_protocol_and_version_str<'a>( + protocol_string: &'a str, + ) -> Result, 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 - { + pub(crate) fn from_str_any_len( + protocol_string: &str, + ) -> Result { 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 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> ); +pub struct ProtoverVote(HashMap>); 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> - { + pub fn entry( + &mut self, + key: UnknownProtocol, + ) -> hash_map::Entry> { 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 = $e.parse(); assert!(protoentry.is_ok(), format!("{:?}", protoentry.err())); - ) + }; } macro_rules! assert_protoentry_is_unparseable { - ($e:expr) => ( + ($e:expr) => { let protoentry: Result = $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 ac78d34b7a..a091e692d6 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 747d22f78c..bce58c0ef9 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 d0c0d79943..48351d8482 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 49a1e7b158..5231d0c631 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 c1585c0480..18519f8497 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 4be154ff1e..f015590178 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 c365564e97..d64275e06b 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() == "") } }