Run cargo clippy and cargo fmt

cathay4t · cathay4t · commit 2790c8a5bab7 · 2023-01-28T21:19:17.000+08:00
Signed-off-by: Gris Ge &lt;fge@redhat.com&gt;
diff --git a/.rustfmt.toml b/.rustfmt.toml
@@ -0,0 +1,4 @@
+max_width = 80
+wrap_comments = true
+reorder_imports = true
+edition = "2021"
diff --git a/examples/audit_netlink_events.rs b/examples/audit_netlink_events.rs
@@ -23,7 +23,9 @@
 
 use futures::stream::StreamExt;
 use netlink_packet_audit::{AuditMessage, StatusMessage};
-use netlink_packet_core::{NetlinkMessage, NetlinkPayload, NLM_F_ACK, NLM_F_REQUEST};
+use netlink_packet_core::{
+    NetlinkMessage, NetlinkPayload, NLM_F_ACK, NLM_F_REQUEST,
+};
 use std::process;
 
 use netlink_proto::{
@@ -38,17 +40,19 @@ const AUDIT_STATUS_PID: u32 = 4;
 async fn main() -> Result<(), String> {
     // Create a netlink socket. Here:
     //
-    // - `conn` is a `Connection` that has the netlink socket. It's a `Future` that
-    //   keeps polling the socket and must be spawned an the event loop.
+    // - `conn` is a `Connection` that has the netlink socket. It's a `Future`
+    //   that keeps polling the socket and must be spawned an the event loop.
     //
     // - `handle` is a `Handle` to the `Connection`. We use it to send netlink
     //   messages and receive responses to these messages.
     //
-    // - `messages` is a channel receiver through which we receive messages that we
-    //   have not sollicated, ie that are not response to a request we made. In this
-    //   example, we'll receive the audit event through that channel.
+    // - `messages` is a channel receiver through which we receive messages that
+    //   we have not sollicated, ie that are not response to a request we made.
+    //   In this example, we'll receive the audit event through that channel.
     let (conn, mut handle, mut messages) = new_connection(NETLINK_AUDIT)
-        .map_err(|e| format!("Failed to create a new netlink connection: {}", e))?;
+        .map_err(|e| {
+            format!("Failed to create a new netlink connection: {e}")
+        })?;
 
     // Spawn the `Connection` so that it starts polling the netlink
     // socket in the background.
@@ -71,14 +75,14 @@ async fn main() -> Result<(), String> {
         let mut response = match handle.request(nl_msg, kernel_unicast) {
             Ok(response) => response,
             Err(e) => {
-                eprintln!("{}", e);
+                eprintln!("{e}");
                 return;
             }
         };
 
         while let Some(message) = response.next().await {
             if let NetlinkPayload::Error(err_message) = message.payload {
-                eprintln!("Received an error message: {:?}", err_message);
+                eprintln!("Received an error message: {err_message:?}");
                 return;
             }
         }
@@ -88,9 +92,9 @@ async fn main() -> Result<(), String> {
     println!("Starting to print audit events... press ^C to interrupt");
     while let Some((message, _addr)) = messages.next().await {
         if let NetlinkPayload::Error(err_message) = message.payload {
-            eprintln!("received an error message: {:?}", err_message);
+            eprintln!("received an error message: {err_message:?}");
         } else {
-            println!("{:?}", message);
+            println!("{message:?}");
         }
     }
 
diff --git a/examples/dump_links.rs b/examples/dump_links.rs
@@ -2,7 +2,8 @@
 
 use futures::StreamExt;
 use netlink_packet_route::{
-    LinkMessage, NetlinkHeader, NetlinkMessage, RtnlMessage, NLM_F_DUMP, NLM_F_REQUEST,
+    LinkMessage, NetlinkHeader, NetlinkMessage, RtnlMessage, NLM_F_DUMP,
+    NLM_F_REQUEST,
 };
 use netlink_proto::{
     new_connection,
@@ -13,25 +14,29 @@ use netlink_proto::{
 async fn main() -> Result<(), String> {
     // Create the netlink socket. Here, we won't use the channel that
     // receives unsolicited messages.
-    let (conn, mut handle, _) = new_connection(NETLINK_ROUTE)
-        .map_err(|e| format!("Failed to create a new netlink connection: {}", e))?;
+    let (conn, mut handle, _) = new_connection(NETLINK_ROUTE).map_err(|e| {
+        format!("Failed to create a new netlink connection: {e}")
+    })?;
 
     // Spawn the `Connection` in the background
     tokio::spawn(conn);
 
     // Create the netlink message that requests the links to be dumped
     let mut nl_hdr = NetlinkHeader::default();
     nl_hdr.flags = NLM_F_DUMP | NLM_F_REQUEST;
-    let request = NetlinkMessage::new(nl_hdr, RtnlMessage::GetLink(LinkMessage::default()).into());
+    let request = NetlinkMessage::new(
+        nl_hdr,
+        RtnlMessage::GetLink(LinkMessage::default()).into(),
+    );
 
     // Send the request
     let mut response = handle
         .request(request, SocketAddr::new(0, 0))
-        .map_err(|e| format!("Failed to send request: {}", e))?;
+        .map_err(|e| format!("Failed to send request: {e}"))?;
 
     // Print all the messages received in response
     while let Some(packet) = response.next().await {
-        println!("<<< {:?}", packet);
+        println!("<<< {packet:?}");
     }
 
     Ok(())
diff --git a/examples/dump_links_async.rs b/examples/dump_links_async.rs
@@ -2,7 +2,8 @@
 
 use futures::StreamExt;
 use netlink_packet_route::{
-    LinkMessage, NetlinkHeader, NetlinkMessage, RtnlMessage, NLM_F_DUMP, NLM_F_REQUEST,
+    LinkMessage, NetlinkHeader, NetlinkMessage, RtnlMessage, NLM_F_DUMP,
+    NLM_F_REQUEST,
 };
 use netlink_proto::{
     new_connection,
@@ -13,8 +14,9 @@ use netlink_proto::{
 async fn main() -> Result<(), String> {
     // Create the netlink socket. Here, we won't use the channel that
     // receives unsolicited messages.
-    let (conn, mut handle, _) = new_connection(NETLINK_ROUTE)
-        .map_err(|e| format!("Failed to create a new netlink connection: {}", e))?;
+    let (conn, mut handle, _) = new_connection(NETLINK_ROUTE).map_err(|e| {
+        format!("Failed to create a new netlink connection: {}", e)
+    })?;
 
     // Spawn the `Connection` so that it starts polling the netlink
     // socket in the background.
@@ -23,7 +25,10 @@ async fn main() -> Result<(), String> {
     // Create the netlink message that requests the links to be dumped
     let mut nl_hdr = NetlinkHeader::default();
     nl_hdr.flags = NLM_F_DUMP | NLM_F_REQUEST;
-    let request = NetlinkMessage::new(nl_hdr, RtnlMessage::GetLink(LinkMessage::default()).into());
+    let request = NetlinkMessage::new(
+        nl_hdr,
+        RtnlMessage::GetLink(LinkMessage::default()).into(),
+    );
 
     // Send the request
     let mut response = handle
diff --git a/src/connection.rs b/src/connection.rs
@@ -46,7 +46,8 @@ where
 
     /// Channel used to transmit to the ConnectionHandle the unsolicited
     /// messages received from the socket (multicast messages for instance).
-    unsolicited_messages_tx: Option<UnboundedSender<(NetlinkMessage<T>, SocketAddr)>>,
+    unsolicited_messages_tx:
+        Option<UnboundedSender<(NetlinkMessage<T>, SocketAddr)>>,
 
     socket_closed: bool,
 }
@@ -59,7 +60,10 @@ where
 {
     pub(crate) fn new(
         requests_rx: UnboundedReceiver<Request<T>>,
-        unsolicited_messages_tx: UnboundedSender<(NetlinkMessage<T>, SocketAddr)>,
+        unsolicited_messages_tx: UnboundedSender<(
+            NetlinkMessage<T>,
+            SocketAddr,
+        )>,
         protocol: isize,
     ) -> io::Result<Self> {
         let socket = S::new(protocol)?;
@@ -86,20 +90,25 @@ where
         let mut socket = Pin::new(socket);
 
         while !protocol.outgoing_messages.is_empty() {
-            trace!("found outgoing message to send checking if socket is ready");
-            if let Poll::Ready(Err(e)) = Pin::as_mut(&mut socket).poll_ready(cx) {
+            trace!(
+                "found outgoing message to send checking if socket is ready"
+            );
+            if let Poll::Ready(Err(e)) = Pin::as_mut(&mut socket).poll_ready(cx)
+            {
                 // Sink errors are usually not recoverable. The socket
                 // probably shut down.
                 warn!("netlink socket shut down: {:?}", e);
                 self.socket_closed = true;
                 return;
             }
 
-            let (mut message, addr) = protocol.outgoing_messages.pop_front().unwrap();
+            let (mut message, addr) =
+                protocol.outgoing_messages.pop_front().unwrap();
             message.finalize();
 
             trace!("sending outgoing message");
-            if let Err(e) = Pin::as_mut(&mut socket).start_send((message, addr)) {
+            if let Err(e) = Pin::as_mut(&mut socket).start_send((message, addr))
+            {
                 error!("failed to send message: {:?}", e);
                 self.socket_closed = true;
                 return;
@@ -147,7 +156,9 @@ where
         if let Some(mut stream) = self.requests_rx.as_mut() {
             loop {
                 match Pin::new(&mut stream).poll_next(cx) {
-                    Poll::Ready(Some(request)) => self.protocol.request(request),
+                    Poll::Ready(Some(request)) => {
+                        self.protocol.request(request)
+                    }
                     Poll::Ready(None) => break,
                     Poll::Pending => return,
                 }
@@ -159,7 +170,9 @@ where
 
     pub fn forward_unsolicited_messages(&mut self) {
         if self.unsolicited_messages_tx.is_none() {
-            while let Some((message, source)) = self.protocol.incoming_requests.pop_front() {
+            while let Some((message, source)) =
+                self.protocol.incoming_requests.pop_front()
+            {
                 warn!(
                     "ignoring unsolicited message {:?} from {:?}",
                     message, source
@@ -177,7 +190,9 @@ where
             ..
         } = self;
 
-        while let Some((message, source)) = protocol.incoming_requests.pop_front() {
+        while let Some((message, source)) =
+            protocol.incoming_requests.pop_front()
+        {
             if unsolicited_messages_tx
                 .as_mut()
                 .unwrap()
@@ -250,7 +265,9 @@ where
     }
 
     pub fn should_shut_down(&self) -> bool {
-        self.socket_closed || (self.unsolicited_messages_tx.is_none() && self.requests_rx.is_none())
+        self.socket_closed
+            || (self.unsolicited_messages_tx.is_none()
+                && self.requests_rx.is_none())
     }
 }
 
@@ -272,7 +289,9 @@ where
         debug!("forwarding unsolicited messages to the connection handle");
         pinned.forward_unsolicited_messages();
 
-        debug!("forwaring responses to previous requests to the connection handle");
+        debug!(
+            "forwaring responses to previous requests to the connection handle"
+        );
         pinned.forward_responses();
 
         debug!("handling requests");
diff --git a/src/framed.rs b/src/framed.rs
@@ -16,7 +16,9 @@ use crate::{
     codecs::NetlinkMessageCodec,
     sys::{AsyncSocket, SocketAddr},
 };
-use netlink_packet_core::{NetlinkDeserializable, NetlinkMessage, NetlinkSerializable};
+use netlink_packet_core::{
+    NetlinkDeserializable, NetlinkMessage, NetlinkSerializable,
+};
 
 pub struct NetlinkFramed<T, S, C> {
     socket: S,
@@ -40,7 +42,10 @@ where
 {
     type Item = (NetlinkMessage<T>, SocketAddr);
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
         let Self {
             ref mut socket,
             ref mut in_addr,
@@ -80,7 +85,10 @@ where
 {
     type Error = io::Error;
 
-    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
         if !self.flushed {
             match self.poll_flush(cx)? {
                 Poll::Ready(()) => {}
@@ -105,7 +113,10 @@ where
         Ok(())
     }
 
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
         if self.flushed {
             return Poll::Ready(Ok(()));
         }
@@ -137,7 +148,10 @@ where
         Poll::Ready(res)
     }
 
-    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_close(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
         ready!(self.poll_flush(cx))?;
         Poll::Ready(Ok(()))
     }
diff --git a/src/handle.rs b/src/handle.rs
@@ -42,17 +42,19 @@ where
         let (tx, rx) = unbounded::<NetlinkMessage<T>>();
         let request = Request::from((message, destination, tx));
         debug!("handle: forwarding new request to connection");
-        UnboundedSender::unbounded_send(&self.requests_tx, request).map_err(|e| {
-            // the channel is unbounded, so it can't be full. If this
-            // failed, it means the Connection shut down.
-            if e.is_full() {
-                panic!("internal error: unbounded channel full?!");
-            } else if e.is_disconnected() {
-                Error::ConnectionClosed
-            } else {
-                panic!("unknown error: {:?}", e);
-            }
-        })?;
+        UnboundedSender::unbounded_send(&self.requests_tx, request).map_err(
+            |e| {
+                // the channel is unbounded, so it can't be full. If this
+                // failed, it means the Connection shut down.
+                if e.is_full() {
+                    panic!("internal error: unbounded channel full?!");
+                } else if e.is_disconnected() {
+                    Error::ConnectionClosed
+                } else {
+                    panic!("unknown error: {:?}", e);
+                }
+            },
+        )?;
         Ok(rx)
     }
 
diff --git a/src/lib.rs b/src/lib.rs
diff --git a/src/protocol/protocol.rs b/src/protocol/protocol.rs
