fixups

Author: dignifiedquire

netwatch/src/interfaces/linux.rs

@@ -2,11 +2,20 @@
 
 #[cfg(not(target_os = "android"))]
 use n0_future::{Either, TryStream, TryStreamExt};
+#[cfg(not(target_os = "android"))]
+use netlink_packet_core::{NetlinkMessage, NLM_F_DUMP, NLM_F_REQUEST};
+#[cfg(not(target_os = "android"))]
+use netlink_packet_route::{link::LinkMessage, route::RouteMessage, RouteNetlinkMessage};
 use tokio::{
     fs::File,
     io::{AsyncBufReadExt, BufReader},
 };
 
+#[cfg(not(target_os = "android"))]
+type Handle = netlink_proto::ConnectionHandle<RouteNetlinkMessage>;
+#[cfg(not(target_os = "android"))]
+type NetlinkError = netlink_proto::Error<RouteNetlinkMessage>;
+
 use super::DefaultRouteDetails;
 
 #[derive(Debug, thiserror::Error)]
@@ -89,13 +98,13 @@ async fn default_route_proc() -> Result<Option<DefaultRouteDetails>, Error> {
 
 macro_rules! try_rtnl {
     ($msg: expr, $message_type:path) => {{
-        use netlink_packet_core::{NetlinkMessage, NetlinkPayload};
+        use netlink_packet_core::NetlinkPayload;
         use netlink_packet_route::RouteNetlinkMessage;
 
         let (header, payload) = $msg.into_parts();
         match payload {
             NetlinkPayload::InnerMessage($message_type(msg)) => msg,
-            NetlinkPayload::Error(err) => return Err(err),
+            NetlinkPayload::Error(err) => return Err(Error::from(err)),
             _ => return Err(Error::UnexpectedNetlinkMessage),
         }
     }};
@@ -145,8 +154,8 @@ async fn default_route_netlink() -> Result<Option<DefaultRouteDetails>, Error> {
     use netlink_sys::protocols::NETLINK_ROUTE;
     use tracing::{info_span, Instrument};
 
-    let (conn, handle, _receiver) =
-        netlink_proto::new_connection::<netlink_packet_route::RouteNetlinkMessage>(NETLINK_ROUTE)?;
+    let (connection, handle, _receiver) =
+        netlink_proto::new_connection::<RouteNetlinkMessage>(NETLINK_ROUTE)?;
 
     let task = tokio::spawn(connection.instrument(info_span!("netlink.conn")));
 
@@ -165,25 +174,19 @@ async fn default_route_netlink() -> Result<Option<DefaultRouteDetails>, Error> {
     }))
 }
 
-type Handle = netlink_proto::ConnectionHandle<netlink_packet_core::RouteNetlinkMessage>;
-type NetlinkError = netlink_proto::Error<netlink_packet_core::RouteNetlinkMessage>;
-
-use netlink_packet_core::{NetlinkMessage, NLM_F_DUMP, NLM_F_REQUEST};
-use netlink_packet_route::{link::LinkMessage, route::RouteMessage, RouteNetlinkMessage};
-
 #[cfg(not(target_os = "android"))]
 fn get_route(
     mut handle: Handle,
     message: RouteMessage,
-) -> impl TryStream<Ok = RouteMessage, Error = Error> {
+) -> impl TryStream<Ok = RouteMessage, Err = Error> {
     let mut req = NetlinkMessage::from(RouteNetlinkMessage::GetRoute(message));
     req.header.flags = NLM_F_REQUEST | NLM_F_DUMP;
 
     match handle.request(req, netlink_proto::sys::SocketAddr::new(0, 0)) {
         Ok(response) => {
             Either::Left(response.map(move |msg| Ok(try_rtnl!(msg, RouteNetlinkMessage::NewRoute))))
         }
-        Err(e) => Either::Right(future::err::<RouteMessage, Error>(e).into_stream()),
+        Err(e) => Either::Right(n0_future::stream::once::<Result<RouteMessage, Error>>(e)),
     }
 }
 
@@ -195,7 +198,7 @@ fn create_route_message(family: netlink_packet_route::AddressFamily) -> RouteMes
     message.header.protocol = RouteProtocol::Static;
     message.header.scope = RouteScope::Universe;
     message.header.kind = RouteType::Unicast;
-    message.header.kind = family;
+    message.header.address_family = family;
     message
 }
 
@@ -205,7 +208,7 @@ async fn default_route_netlink_family(
     handle: &Handle,
     family: netlink_packet_route::AddressFamily,
 ) -> Result<Option<(String, u32)>, Error> {
-    use netlink_packet_route::{route::RouteAttribute, AddressFamily};
+    use netlink_packet_route::route::RouteAttribute;
 
     let msg = create_route_message(family);
     let mut routes = get_route(handle.clone(), msg);
@@ -247,15 +250,15 @@ async fn default_route_netlink_family(
 fn get_link(
     mut handle: Handle,
     message: LinkMessage,
-) -> impl TryStream<Ok = LinkMessage, Error = Error> {
+) -> impl TryStream<Ok = LinkMessage, Err = Error> {
     let mut req = NetlinkMessage::from(RouteNetlinkMessage::GetLink(message));
     req.header.flags = NLM_F_REQUEST;
 
     match handle.request(req, netlink_proto::sys::SocketAddr::new(0, 0)) {
         Ok(response) => {
             Either::Left(response.map(move |msg| Ok(try_rtnl!(msg, RouteNetlinkMessage::NewLink))))
         }
-        Err(e) => Either::Right(future::err::<RouteMessage, Error>(e).into_stream()),
+        Err(e) => Either::Right(n0_future::stream::once::<Result<RouteMessage, Error>>(e)),
     }
 }