Run cargo clippy and cargo fmt

Signed-off-by: Gris Ge <[email protected]>

Author: cathay4t

.rustfmt.toml

@@ -0,0 +1,4 @@
+max_width = 80
+wrap_comments = true
+reorder_imports = true
+edition = "2021"

examples/add_rules.rs

@@ -9,17 +9,18 @@
 use audit::{
     new_connection,
     packet::{
-        constants::AUDIT_ARCH_X86_64, RuleAction, RuleField, RuleFieldFlags, RuleFlags,
-        RuleMessage, RuleSyscalls,
+        constants::AUDIT_ARCH_X86_64, RuleAction, RuleField, RuleFieldFlags,
+        RuleFlags, RuleMessage, RuleSyscalls,
     },
     Error, Handle,
 };
 
 #[tokio::main]
 async fn main() -> Result<(), String> {
-    let (connection, handle, _) = new_connection().map_err(|e| format!("{}", e))?;
+    let (connection, handle, _) =
+        new_connection().map_err(|e| format!("{e}"))?;
     tokio::spawn(connection);
-    add_rules(handle).await.map_err(|e| format!("{}", e))
+    add_rules(handle).await.map_err(|e| format!("{e}"))
 }
 
 async fn add_rules(mut handle: Handle) -> Result<(), Error> {

examples/dump_audit_rules.rs

@@ -8,15 +8,16 @@ use futures::stream::TryStreamExt;
 
 #[tokio::main]
 async fn main() -> Result<(), String> {
-    let (connection, handle, _) = new_connection().map_err(|e| format!("{}", e))?;
+    let (connection, handle, _) =
+        new_connection().map_err(|e| format!("{e}"))?;
     tokio::spawn(connection);
-    list_rules(handle).await.map_err(|e| format!("{}", e))
+    list_rules(handle).await.map_err(|e| format!("{e}"))
 }
 
 async fn list_rules(mut handle: Handle) -> Result<(), Error> {
     let mut rules = handle.list_rules();
     while let Some(rule) = rules.try_next().await? {
-        println!("{:?}", rule);
+        println!("{rule:?}");
     }
     Ok(())
 }

examples/events.rs

@@ -8,14 +8,15 @@ use futures::stream::StreamExt;
 
 #[tokio::main]
 async fn main() -> Result<(), String> {
-    let (connection, mut handle, mut messages) = new_connection().map_err(|e| format!("{}", e))?;
+    let (connection, mut handle, mut messages) =
+        new_connection().map_err(|e| format!("{e}"))?;
 
     tokio::spawn(connection);
-    handle.enable_events().await.map_err(|e| format!("{}", e))?;
+    handle.enable_events().await.map_err(|e| format!("{e}"))?;
 
     env_logger::init();
     while let Some((msg, _)) = messages.next().await {
-        println!("{:?}", msg);
+        println!("{msg:?}");
     }
     Ok(())
 }

examples/events_async.rs

@@ -8,7 +8,8 @@ use futures::stream::StreamExt;
 
 #[async_std::main]
 async fn main() -> Result<(), String> {
-    let (connection, mut handle, mut messages) = new_connection().map_err(|e| format!("{}", e))?;
+    let (connection, mut handle, mut messages) =
+        new_connection().map_err(|e| format!("{}", e))?;
 
     async_std::task::spawn(connection);
 

src/handle.rs

@@ -8,8 +8,8 @@ use futures::{
     FutureExt,
 };
 use netlink_packet_core::{
-    NetlinkMessage, NetlinkPayload, NLM_F_ACK, NLM_F_CREATE, NLM_F_DUMP, NLM_F_EXCL, NLM_F_NONREC,
-    NLM_F_REQUEST,
+    NetlinkMessage, NetlinkPayload, NLM_F_ACK, NLM_F_CREATE, NLM_F_DUMP,
+    NLM_F_EXCL, NLM_F_NONREC, NLM_F_REQUEST,
 };
 use netlink_proto::{sys::SocketAddr, ConnectionHandle};
 
@@ -62,7 +62,10 @@ impl Handle {
     /// Send a netlink message that expects an acknowledgement. The returned
     /// future resolved when that ACK is received. If anything else is
     /// received, the future resolves into an error.
-    async fn acked_request(&mut self, message: NetlinkMessage<AuditMessage>) -> Result<(), Error> {
+    async fn acked_request(
+        &mut self,
+        message: NetlinkMessage<AuditMessage>,
+    ) -> Result<(), Error> {
         let mut response = self.request(message)?;
         if let Some(message) = response.next().await {
             let (header, payload) = message.into_parts();
@@ -83,7 +86,8 @@ impl Handle {
     /// Add the given rule
     pub async fn add_rule(&mut self, rule: RuleMessage) -> Result<(), Error> {
         let mut req = NetlinkMessage::from(AuditMessage::AddRule(rule));
-        req.header.flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
+        req.header.flags =
+            NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
         self.acked_request(req).await
     }
 
@@ -95,24 +99,30 @@ impl Handle {
     }
 
     /// List the current rules
-    pub fn list_rules(&mut self) -> impl TryStream<Ok = RuleMessage, Error = Error> {
+    pub fn list_rules(
+        &mut self,
+    ) -> impl TryStream<Ok = RuleMessage, Error = Error> {
         let mut req = NetlinkMessage::from(AuditMessage::ListRules(None));
         req.header.flags = NLM_F_REQUEST | NLM_F_DUMP;
 
         match self.request(req) {
             Ok(response) => Either::Left(response.map(move |msg| {
                 let (header, payload) = msg.into_parts();
                 match payload {
-                    NetlinkPayload::InnerMessage(AuditMessage::ListRules(Some(rule_msg))) => {
-                        Ok(rule_msg)
+                    NetlinkPayload::InnerMessage(AuditMessage::ListRules(
+                        Some(rule_msg),
+                    )) => Ok(rule_msg),
+                    NetlinkPayload::Error(err_msg) => {
+                        Err(Error::NetlinkError(err_msg))
                     }
-                    NetlinkPayload::Error(err_msg) => Err(Error::NetlinkError(err_msg)),
                     _ => Err(Error::UnexpectedMessage(NetlinkMessage::new(
                         header, payload,
                     ))),
                 }
             })),
-            Err(e) => Either::Right(future::err::<RuleMessage, Error>(e).into_stream()),
+            Err(e) => Either::Right(
+                future::err::<RuleMessage, Error>(e).into_stream(),
+            ),
         }
     }
 
@@ -136,10 +146,15 @@ impl Handle {
         let response = request.next().await.ok_or(Error::RequestFailed)?;
 
         match response.into_parts() {
-            (_, NetlinkPayload::InnerMessage(AuditMessage::GetStatus(Some(status)))) => Ok(status),
-            (header, payload) => Err(Error::UnexpectedMessage(NetlinkMessage::new(
-                header, payload,
-            ))),
+            (
+                _,
+                NetlinkPayload::InnerMessage(AuditMessage::GetStatus(Some(
+                    status,
+                ))),
+            ) => Ok(status),
+            (header, payload) => Err(Error::UnexpectedMessage(
+                NetlinkMessage::new(header, payload),
+            )),
         }
     }
 }

src/lib.rs

@@ -20,7 +20,11 @@ use futures::channel::mpsc::UnboundedReceiver;
 #[allow(clippy::type_complexity)]
 #[cfg(feature = "tokio_socket")]
 pub fn new_connection() -> io::Result<(
-    proto::Connection<packet::AuditMessage, sys::TokioSocket, packet::NetlinkAuditCodec>,
+    proto::Connection<
+        packet::AuditMessage,
+        sys::TokioSocket,
+        packet::NetlinkAuditCodec,
+    >,
     Handle,
     UnboundedReceiver<(NetlinkMessage<packet::AuditMessage>, sys::SocketAddr)>,
 )> {
@@ -36,7 +40,8 @@ pub fn new_connection_with_socket<S>() -> io::Result<(
 where
     S: sys::AsyncSocket,
 {
-    let (conn, handle, messages) =
-        netlink_proto::new_connection_with_codec(sys::protocols::NETLINK_AUDIT)?;
+    let (conn, handle, messages) = netlink_proto::new_connection_with_codec(
+        sys::protocols::NETLINK_AUDIT,
+    )?;
     Ok((conn, Handle::new(handle), messages))
 }