[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [tor/master] rust: run rustfmt



commit 6b609ce4356423a28e7b421a9f09849d831a0c6f
Author: cypherpunks <cypherpunks@xxxxxxxxxxxxxx>
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() == "")
     }
 }



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits