Merge pull request #87 from hug-dev/deny

Deny compilation for some rustc lints

Cargo.toml

@@ -26,9 +26,10 @@ log = { version = "0.4.8", features = ["serde"] }
 pkcs11 = { version = "0.4.0", optional = true }
 picky-asn1-der = { version = "0.2.0", optional = true }
 picky-asn1 = { version = "0.1.0", optional = true }
-tss-esapi = { git = "https://github.com/parallaxsecond/rust-tss-esapi", tag = "0.4.0", optional = true }
+tss-esapi = { git = "https://github.com/parallaxsecond/rust-tss-esapi", tag = "0.5.0", optional = true }
 bincode = "1.1.4"
 structopt = "0.3.5"
+derivative = "1.0.3"
 
 [dev-dependencies]
 parsec-client-test = { git = "https://github.com/parallaxsecond/parsec-client-test", tag = "0.1.8" }

README.md

@@ -29,7 +29,7 @@ Read the Parsec documentation [online](https://parallaxsecond.github.io/parsec-b
 
 ## Disclaimer
 
-PARSEC is a new open source project and is under development. This code repository is being made
+Parsec is a new open source project and is under development. This code repository is being made
 available so that the developer community can learn and give feedback about the new interfaces and the concepts of platform-agnostic security.
 The implementation that is provided is suitable for exploratory testing and experimentation only.
 This test implementation does not offer any tangible security benefits and therefore is not
@@ -102,6 +102,7 @@ This project uses the following third party crates:
 * picky-asn1 (MIT and Apache-2.0)
 * bincode (MIT)
 * structopt (MIT and Apache-2.0)
+* derivative (MIT and Apache-2.0)
 
 This project uses the following third party libraries:
 * [Mbed Crypto](https://github.com/ARMmbed/mbed-crypto) (Apache-2.0)

src/authenticators/simple_authenticator/mod.rs

@@ -24,6 +24,7 @@ use parsec_interface::requests::request::RequestAuth;
 use parsec_interface::requests::{ResponseStatus, Result};
 use std::str;
 
+#[derive(Copy, Clone, Debug)]
 pub struct SimpleAuthenticator;
 
 impl Authenticate for SimpleAuthenticator {
@@ -63,7 +64,7 @@ mod test {
     #[should_panic(expected = "Failed to authenticate")]
     fn failed_authentication() {
         let authenticator = SimpleAuthenticator {};
-        authenticator
+        let _ = authenticator
             .authenticate(&RequestAuth::from_bytes(vec![0xff; 5]))
             .expect("Failed to authenticate");
     }

src/back/backend_handler.rs

@@ -14,6 +14,7 @@
 // limitations under the License.
 use crate::authenticators::ApplicationName;
 use crate::providers::Provide;
+use derivative::Derivative;
 use parsec_interface::operations::Convert;
 use parsec_interface::operations::{NativeOperation, NativeResult};
 use parsec_interface::requests::{
@@ -26,9 +27,14 @@ use parsec_interface::requests::{BodyType, ProviderID};
 ///
 /// It also provides assessment capabilities, letting the dispatcher know if
 /// it can process a request.
+
+#[derive(Derivative)]
+#[derivative(Debug)]
 pub struct BackEndHandler {
     // Send and Sync are required for Arc<FrontEndHandler> to be Send.
+    #[derivative(Debug = "ignore")]
     provider: Box<dyn Provide + Send + Sync>,
+    #[derivative(Debug = "ignore")]
     converter: Box<dyn Convert + Send + Sync>,
     provider_id: ProviderID,
     content_type: BodyType,
@@ -158,9 +164,12 @@ impl BackEndHandler {
     }
 }
 
-#[derive(Default)]
+#[derive(Default, Derivative)]
+#[derivative(Debug)]
 pub struct BackEndHandlerBuilder {
+    #[derivative(Debug = "ignore")]
     provider: Option<Box<dyn Provide + Send + Sync>>,
+    #[derivative(Debug = "ignore")]
     converter: Option<Box<dyn Convert + Send + Sync>>,
     provider_id: Option<ProviderID>,
     content_type: Option<BodyType>,

src/back/dispatcher.rs

@@ -24,6 +24,7 @@ use std::collections::HashMap;
 ///
 /// As such, it owns all the backend handlers and attempts to match
 /// the fields in the request header to the properties of the handlers.
+#[derive(Debug)]
 pub struct Dispatcher {
     backends: HashMap<ProviderID, BackEndHandler>,
 }
@@ -52,7 +53,7 @@ impl Dispatcher {
     }
 }
 
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct DispatcherBuilder {
     backends: Option<HashMap<ProviderID, BackEndHandler>>,
 }
@@ -68,7 +69,7 @@ impl DispatcherBuilder {
         backend_handler: BackEndHandler,
     ) -> Self {
         let mut backends = self.backends.unwrap_or_default();
-        backends.insert(provider_id, backend_handler);
+        let _ = backends.insert(provider_id, backend_handler);
         self.backends = Some(backends);
 
         self

src/bin/main.rs

@@ -12,6 +12,38 @@
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+#![deny(
+    nonstandard_style,
+    const_err,
+    dead_code,
+    improper_ctypes,
+    legacy_directory_ownership,
+    non_shorthand_field_patterns,
+    no_mangle_generic_items,
+    overflowing_literals,
+    path_statements,
+    patterns_in_fns_without_body,
+    plugin_as_library,
+    private_in_public,
+    safe_extern_statics,
+    unconditional_recursion,
+    unused,
+    unused_allocation,
+    unused_comparisons,
+    unused_parens,
+    while_true,
+    missing_debug_implementations,
+    //TODO: activate this!
+    //missing_docs,
+    trivial_casts,
+    trivial_numeric_casts,
+    unused_extern_crates,
+    unused_import_braces,
+    unused_qualifications,
+    unused_results,
+    missing_copy_implementations
+)]
+
 use log::info;
 use parsec::utils::{ServiceBuilder, ServiceConfig};
 use signal_hook::{flag, SIGHUP, SIGTERM};
@@ -49,8 +81,8 @@ fn main() -> Result<(), Error> {
     let kill_signal = Arc::new(AtomicBool::new(false));
     // Register a boolean set to true when the SIGHUP signal is received.
     let reload_signal = Arc::new(AtomicBool::new(false));
-    flag::register(SIGTERM, kill_signal.clone())?;
-    flag::register(SIGHUP, reload_signal.clone())?;
+    let _ = flag::register(SIGTERM, kill_signal.clone())?;
+    let _ = flag::register(SIGHUP, reload_signal.clone())?;
 
     let mut config_file =
         ::std::fs::read_to_string(opts.config.clone()).expect("Failed to read configuration file");
@@ -67,7 +99,7 @@ fn main() -> Result<(), Error> {
     // outlive the run function. It is needed to give them all ownership of the front end handler
     // through an Arc.
     let mut front_end_handler = Arc::from(front_end_handler);
-    let mut listener = ServiceBuilder::start_listener(&config.listener);
+    let mut listener = ServiceBuilder::start_listener(config.listener);
     let mut threadpool = ServiceBuilder::build_threadpool(config.core_settings.thread_pool_size);
 
     // Notify systemd that the daemon is ready, the start command will block until this point.
@@ -96,7 +128,7 @@ fn main() -> Result<(), Error> {
                 Arc::from(ServiceBuilder::build_service(&config).ok_or_else(|| {
                     Error::new(ErrorKind::Other, "Parsec can not be configured.")
                 })?);
-            listener = ServiceBuilder::start_listener(&config.listener);
+            listener = ServiceBuilder::start_listener(config.listener);
             threadpool = ServiceBuilder::build_threadpool(config.core_settings.thread_pool_size);
 
             let _ = sd_notify::notify(false, &[sd_notify::NotifyState::Ready]);
@@ -130,12 +162,12 @@ fn log_setup(config: &ServiceConfig) {
     let mut env_log_builder = env_logger::builder();
 
     if let Some(level) = config.core_settings.log_level {
-        env_log_builder.filter_level(level);
+        let _ = env_log_builder.filter_level(level);
     }
     if let Some(true) = config.core_settings.log_timestamp {
-        env_log_builder.format_timestamp_millis();
+        let _ = env_log_builder.format_timestamp_millis();
     } else {
-        env_log_builder.format_timestamp(None);
+        let _ = env_log_builder.format_timestamp(None);
     }
     env_log_builder.init();
 }

src/front/domain_socket.rs

@@ -30,6 +30,7 @@ static SOCKET_PATH: &str = "/tmp/security-daemon-socket";
 /// Holds references to a `UnixListener`.
 ///
 /// Only works on Unix systems.
+#[derive(Debug)]
 pub struct DomainSocketListener {
     listener: UnixListener,
     timeout: Duration,
@@ -112,7 +113,7 @@ impl Listen for DomainSocketListener {
     }
 }
 
-#[derive(Default)]
+#[derive(Copy, Clone, Debug, Default)]
 pub struct DomainSocketListenerBuilder {
     timeout: Option<Duration>,
 }

src/front/front_end.rs

@@ -14,6 +14,7 @@
 // limitations under the License.
 use crate::authenticators::Authenticate;
 use crate::back::dispatcher::Dispatcher;
+use derivative::Derivative;
 use log::{error, info};
 use parsec_interface::requests::AuthType;
 use parsec_interface::requests::ResponseStatus;
@@ -25,9 +26,12 @@ use std::io::{Read, Write};
 /// from/to the stream provided by the listener.
 ///
 /// Requests are passed forward to the `Dispatcher`.
+#[derive(Derivative)]
+#[derivative(Debug)]
 pub struct FrontEndHandler {
     dispatcher: Dispatcher,
     // Send and Sync are required for Arc<FrontEndHandler> to be Send.
+    #[derivative(Debug = "ignore")]
     authenticators: HashMap<AuthType, Box<dyn Authenticate + Send + Sync>>,
 }
 
@@ -82,9 +86,11 @@ impl FrontEndHandler {
     }
 }
 
-#[derive(Default)]
+#[derive(Default, Derivative)]
+#[derivative(Debug)]
 pub struct FrontEndHandlerBuilder {
     dispatcher: Option<Dispatcher>,
+    #[derivative(Debug = "ignore")]
     authenticators: Option<HashMap<AuthType, Box<dyn Authenticate + Send + Sync>>>,
 }
 
@@ -108,11 +114,11 @@ impl FrontEndHandlerBuilder {
     ) -> Self {
         match &mut self.authenticators {
             Some(authenticators) => {
-                authenticators.insert(auth_type, authenticator);
+                let _ = authenticators.insert(auth_type, authenticator);
             }
             None => {
                 let mut map = HashMap::new();
-                map.insert(auth_type, authenticator);
+                let _ = map.insert(auth_type, authenticator);
                 self.authenticators = Some(map);
             }
         };

src/front/listener.rs

@@ -21,12 +21,12 @@ pub trait ReadWrite: std::io::Read + std::io::Write {}
 // Automatically implements ReadWrite for all types that implement Read and Write.
 impl<T: std::io::Read + std::io::Write> ReadWrite for T {}
 
-#[derive(Deserialize, Debug)]
+#[derive(Copy, Clone, Deserialize, Debug)]
 pub enum ListenerType {
     DomainSocket,
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Copy, Clone, Deserialize, Debug)]
 pub struct ListenerConfig {
     pub listener_type: ListenerType,
     pub timeout: u64,

src/key_id_managers/mod.rs

@@ -25,7 +25,7 @@ use std::fmt;
 
 pub mod on_disk_manager;
 
-#[derive(Deserialize, Debug)]
+#[derive(Copy, Clone, Deserialize, Debug)]
 pub enum KeyIdManagerType {
     OnDisk,
 }