Merge pull request #937 from umi-eng/core-net

Dirbaio · web-flow · commit 57b1dd4b1583 · 2024-05-27T23:51:46.000Z
Use `core` instead of `std` for net types.
diff --git a/Cargo.toml b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "smoltcp"
 version = "0.11.0"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.77"
 authors = ["whitequark <whitequark@whitequark.org>"]
 description = "A TCP/IP stack designed for bare-metal, real-time systems without a heap."
 documentation = "https://docs.rs/smoltcp/"
diff --git a/README.md b/README.md
@@ -12,7 +12,7 @@ include complicated compile-time computations, such as macro or type tricks, eve
 at cost of performance degradation.
 
 _smoltcp_ does not need heap allocation *at all*, is [extensively documented][docs],
-and compiles on stable Rust 1.65 and later.
+and compiles on stable Rust 1.77 and later.
 
 _smoltcp_ achieves [~Gbps of throughput](#examplesbenchmarkrs) when tested against
 the Linux TCP stack in loopback mode.
diff --git a/ci.sh b/ci.sh
@@ -4,7 +4,7 @@ set -eox pipefail
 
 export DEFMT_LOG=trace
 
-MSRV="1.65.0"
+MSRV="1.77.0"
 
 RUSTC_VERSIONS=(
     $MSRV
diff --git a/src/iface/interface/mod.rs b/src/iface/interface/mod.rs
@@ -580,7 +580,7 @@ impl Interface {
 
         enum EgressError {
             Exhausted,
-            Dispatch(DispatchError),
+            Dispatch,
         }
 
         let mut emitted_any = false;
@@ -602,7 +602,7 @@ impl Interface {
 
                 inner
                     .dispatch_ip(t, meta, response, &mut self.fragmenter)
-                    .map_err(EgressError::Dispatch)?;
+                    .map_err(|_| EgressError::Dispatch)?;
 
                 emitted_any = true;
 
@@ -673,7 +673,7 @@ impl Interface {
 
             match result {
                 Err(EgressError::Exhausted) => break, // Device buffer full.
-                Err(EgressError::Dispatch(_)) => {
+                Err(EgressError::Dispatch) => {
                     // `NeighborCache` already takes care of rate limiting the neighbor discovery
                     // requests from the socket. However, without an additional rate limiting
                     // mechanism, we would spin on every socket that has yet to discover its
diff --git a/src/lib.rs b/src/lib.rs
@@ -65,7 +65,7 @@
 //!
 //! # Minimum Supported Rust Version (MSRV)
 //!
-//! This crate is guaranteed to compile on stable Rust 1.65 and up with any valid set of features.
+//! This crate is guaranteed to compile on stable Rust 1.77 and up with any valid set of features.
 //! It *might* compile on older versions but that may change in any new patch release.
 //!
 //! The exception is when using the `defmt` feature, in which case `defmt`'s MSRV applies, which
diff --git a/src/phy/loopback.rs b/src/phy/loopback.rs
@@ -1,4 +1,5 @@
 use alloc::collections::VecDeque;
+use alloc::vec;
 use alloc::vec::Vec;
 
 use crate::phy::{self, ChecksumCapabilities, Device, DeviceCapabilities, Medium};
@@ -80,8 +81,7 @@ impl<'a> phy::TxToken for TxToken<'a> {
     where
         F: FnOnce(&mut [u8]) -> R,
     {
-        let mut buffer = Vec::new();
-        buffer.resize(len, 0);
+        let mut buffer = vec![0; len];
         let result = f(&mut buffer);
         self.queue.push_back(buffer);
         result
diff --git a/src/phy/sys/bpf.rs b/src/phy/sys/bpf.rs
@@ -172,7 +172,7 @@ impl BpfDevice {
             );
 
             if len == -1 {
-                Err(io::Error::last_os_error()).unwrap()
+                panic!("{:?}", io::Error::last_os_error())
             }
 
             Ok(len as usize)
diff --git a/src/wire/dns.rs b/src/wire/dns.rs
@@ -417,9 +417,9 @@ impl<'a> Repr<'a> {
     }
 
     /// Emit a high-level representation into a DNS packet.
-    pub fn emit<T: ?Sized>(&self, packet: &mut Packet<&mut T>)
+    pub fn emit<T>(&self, packet: &mut Packet<&mut T>)
     where
-        T: AsRef<[u8]> + AsMut<[u8]>,
+        T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
     {
         packet.set_transaction_id(self.transaction_id);
         packet.set_flags(self.flags);
@@ -779,8 +779,7 @@ mod test {
             },
         };
 
-        let mut buf = Vec::new();
-        buf.resize(repr.buffer_len(), 0);
+        let mut buf = vec![0; repr.buffer_len()];
         repr.emit(&mut Packet::new_unchecked(&mut buf));
 
         let want = &[
diff --git a/src/wire/ip.rs b/src/wire/ip.rs
@@ -195,38 +195,37 @@ impl Address {
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]
-impl From<::std::net::IpAddr> for Address {
-    fn from(x: ::std::net::IpAddr) -> Address {
+#[cfg(all(feature = "proto-ipv4", feature = "proto-ipv6"))]
+impl From<::core::net::IpAddr> for Address {
+    fn from(x: ::core::net::IpAddr) -> Address {
         match x {
-            ::std::net::IpAddr::V4(ipv4) => Address::Ipv4(ipv4.into()),
-            ::std::net::IpAddr::V6(ipv6) => Address::Ipv6(ipv6.into()),
+            ::core::net::IpAddr::V4(ipv4) => Address::Ipv4(ipv4.into()),
+            ::core::net::IpAddr::V6(ipv6) => Address::Ipv6(ipv6.into()),
         }
     }
 }
 
-#[cfg(feature = "std")]
-impl From<Address> for ::std::net::IpAddr {
-    fn from(x: Address) -> ::std::net::IpAddr {
+impl From<Address> for ::core::net::IpAddr {
+    fn from(x: Address) -> ::core::net::IpAddr {
         match x {
             #[cfg(feature = "proto-ipv4")]
-            Address::Ipv4(ipv4) => ::std::net::IpAddr::V4(ipv4.into()),
+            Address::Ipv4(ipv4) => ::core::net::IpAddr::V4(ipv4.into()),
             #[cfg(feature = "proto-ipv6")]
-            Address::Ipv6(ipv6) => ::std::net::IpAddr::V6(ipv6.into()),
+            Address::Ipv6(ipv6) => ::core::net::IpAddr::V6(ipv6.into()),
         }
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv4"))]
-impl From<::std::net::Ipv4Addr> for Address {
-    fn from(ipv4: ::std::net::Ipv4Addr) -> Address {
+#[cfg(feature = "proto-ipv4")]
+impl From<::core::net::Ipv4Addr> for Address {
+    fn from(ipv4: ::core::net::Ipv4Addr) -> Address {
         Address::Ipv4(ipv4.into())
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv6"))]
-impl From<::std::net::Ipv6Addr> for Address {
-    fn from(ipv6: ::std::net::Ipv6Addr) -> Address {
+#[cfg(feature = "proto-ipv6")]
+impl From<::core::net::Ipv6Addr> for Address {
+    fn from(ipv6: ::core::net::Ipv6Addr) -> Address {
         Address::Ipv6(ipv6.into())
     }
 }
@@ -395,29 +394,29 @@ impl Endpoint {
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]
-impl From<::std::net::SocketAddr> for Endpoint {
-    fn from(x: ::std::net::SocketAddr) -> Endpoint {
+#[cfg(all(feature = "proto-ipv4", feature = "proto-ipv6"))]
+impl From<::core::net::SocketAddr> for Endpoint {
+    fn from(x: ::core::net::SocketAddr) -> Endpoint {
         Endpoint {
             addr: x.ip().into(),
             port: x.port(),
         }
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv4"))]
-impl From<::std::net::SocketAddrV4> for Endpoint {
-    fn from(x: ::std::net::SocketAddrV4) -> Endpoint {
+#[cfg(feature = "proto-ipv4")]
+impl From<::core::net::SocketAddrV4> for Endpoint {
+    fn from(x: ::core::net::SocketAddrV4) -> Endpoint {
         Endpoint {
             addr: (*x.ip()).into(),
             port: x.port(),
         }
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv6"))]
-impl From<::std::net::SocketAddrV6> for Endpoint {
-    fn from(x: ::std::net::SocketAddrV6) -> Endpoint {
+#[cfg(feature = "proto-ipv6")]
+impl From<::core::net::SocketAddrV6> for Endpoint {
+    fn from(x: ::core::net::SocketAddrV6) -> Endpoint {
         Endpoint {
             addr: (*x.ip()).into(),
             port: x.port(),
@@ -466,29 +465,29 @@ impl ListenEndpoint {
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]
-impl From<::std::net::SocketAddr> for ListenEndpoint {
-    fn from(x: ::std::net::SocketAddr) -> ListenEndpoint {
+#[cfg(all(feature = "proto-ipv4", feature = "proto-ipv6"))]
+impl From<::core::net::SocketAddr> for ListenEndpoint {
+    fn from(x: ::core::net::SocketAddr) -> ListenEndpoint {
         ListenEndpoint {
             addr: Some(x.ip().into()),
             port: x.port(),
         }
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv4"))]
-impl From<::std::net::SocketAddrV4> for ListenEndpoint {
-    fn from(x: ::std::net::SocketAddrV4) -> ListenEndpoint {
+#[cfg(feature = "proto-ipv4")]
+impl From<::core::net::SocketAddrV4> for ListenEndpoint {
+    fn from(x: ::core::net::SocketAddrV4) -> ListenEndpoint {
         ListenEndpoint {
             addr: Some((*x.ip()).into()),
             port: x.port(),
         }
     }
 }
 
-#[cfg(all(feature = "std", feature = "proto-ipv6"))]
-impl From<::std::net::SocketAddrV6> for ListenEndpoint {
-    fn from(x: ::std::net::SocketAddrV6) -> ListenEndpoint {
+#[cfg(feature = "proto-ipv6")]
+impl From<::core::net::SocketAddrV6> for ListenEndpoint {
+    fn from(x: ::core::net::SocketAddrV6) -> ListenEndpoint {
         ListenEndpoint {
             addr: Some((*x.ip()).into()),
             port: x.port(),
diff --git a/src/wire/ipv4.rs b/src/wire/ipv4.rs
@@ -110,16 +110,14 @@ impl Address {
     }
 }
 
-#[cfg(feature = "std")]
-impl From<::std::net::Ipv4Addr> for Address {
-    fn from(x: ::std::net::Ipv4Addr) -> Address {
+impl From<::core::net::Ipv4Addr> for Address {
+    fn from(x: ::core::net::Ipv4Addr) -> Address {
         Address(x.octets())
     }
 }
 
-#[cfg(feature = "std")]
-impl From<Address> for ::std::net::Ipv4Addr {
-    fn from(Address(x): Address) -> ::std::net::Ipv4Addr {
+impl From<Address> for ::core::net::Ipv4Addr {
+    fn from(Address(x): Address) -> ::core::net::Ipv4Addr {
         x.into()
     }
 }
diff --git a/src/wire/ipv6.rs b/src/wire/ipv6.rs
@@ -312,16 +312,14 @@ impl Address {
     }
 }
 
-#[cfg(feature = "std")]
-impl From<::std::net::Ipv6Addr> for Address {
-    fn from(x: ::std::net::Ipv6Addr) -> Address {
+impl From<::core::net::Ipv6Addr> for Address {
+    fn from(x: ::core::net::Ipv6Addr) -> Address {
         Address(x.octets())
     }
 }
 
-#[cfg(feature = "std")]
-impl From<Address> for ::std::net::Ipv6Addr {
-    fn from(Address(x): Address) -> ::std::net::Ipv6Addr {
+impl From<Address> for ::core::net::Ipv6Addr {
+    fn from(Address(x): Address) -> ::core::net::Ipv6Addr {
         x.into()
     }
 }
@@ -1427,7 +1425,7 @@ pub(crate) mod test {
 
     #[test]
     fn test_repr_parse_bad_version() {
-        let mut bytes = vec![0; 40];
+        let mut bytes = [0; 40];
         let mut packet = Packet::new_unchecked(&mut bytes[..]);
         packet.set_version(4);
         packet.set_payload_len(0);
@@ -1437,7 +1435,7 @@ pub(crate) mod test {
 
     #[test]
     fn test_repr_parse_smaller_than_header() {
-        let mut bytes = vec![0; 40];
+        let mut bytes = [0; 40];
         let mut packet = Packet::new_unchecked(&mut bytes[..]);
         packet.set_version(6);
         packet.set_payload_len(39);
@@ -1447,7 +1445,7 @@ pub(crate) mod test {
 
     #[test]
     fn test_repr_parse_smaller_than_payload() {
-        let mut bytes = vec![0; 40];
+        let mut bytes = [0; 40];
         let mut packet = Packet::new_unchecked(&mut bytes[..]);
         packet.set_version(6);
         packet.set_payload_len(1);
diff --git a/src/wire/mld.rs b/src/wire/mld.rs
@@ -526,7 +526,7 @@ mod test {
 
     #[test]
     fn test_query_construct() {
-        let mut bytes = vec![0xff; 44];
+        let mut bytes = [0xff; 44];
         let mut packet = Packet::new_unchecked(&mut bytes[..]);
         packet.set_msg_type(Message::MldQuery);
         packet.set_msg_code(0);
@@ -567,7 +567,7 @@ mod test {
 
     #[test]
     fn test_record_construct() {
-        let mut bytes = vec![0xff; 44];
+        let mut bytes = [0xff; 44];
         let mut packet = Packet::new_unchecked(&mut bytes[..]);
         packet.set_msg_type(Message::MldReport);
         packet.set_msg_code(0);
diff --git a/src/wire/ndisc.rs b/src/wire/ndisc.rs
@@ -534,7 +534,7 @@ mod test {
 
     #[test]
     fn test_router_advert_repr_emit() {
-        let mut bytes = vec![0x2a; 24];
+        let mut bytes = [0x2a; 24];
         let mut packet = Packet::new_unchecked(&mut bytes[..]);
         create_repr().emit(
             &MOCK_IP_ADDR_1,
diff --git a/src/wire/sixlowpan/iphc.rs b/src/wire/sixlowpan/iphc.rs
@@ -176,7 +176,7 @@ impl<T: AsRef<[u8]>> Packet<T> {
     /// Return the ECN field (when it is inlined).
     pub fn ecn_field(&self) -> Option<u8> {
         match self.tf_field() {
-            0b00 | 0b01 | 0b10 => {
+            0b00..=0b10 => {
                 let start = self.ip_fields_start() as usize;
                 Some(self.buffer.as_ref()[start..][0] & 0b1100_0000)
             }
@@ -341,7 +341,7 @@ impl<T: AsRef<[u8]>> Packet<T> {
                 0,
                 AddressMode::NotSupported,
             ))),
-            (1, 1, 0b01 | 0b10 | 0b11) => Ok(UnresolvedAddress::Reserved),
+            (1, 1, 0b01..=0b11) => Ok(UnresolvedAddress::Reserved),
             _ => Err(Error),
         }
     }
diff --git a/src/wire/udp.rs b/src/wire/udp.rs
@@ -255,9 +255,9 @@ impl Repr {
     /// This never calculates the checksum, and is intended for internal-use only,
     /// not for packets that are going to be actually sent over the network. For
     /// example, when decompressing 6lowpan.
-    pub(crate) fn emit_header<T: ?Sized>(&self, packet: &mut Packet<&mut T>, payload_len: usize)
+    pub(crate) fn emit_header<T>(&self, packet: &mut Packet<&mut T>, payload_len: usize)
     where
-        T: AsRef<[u8]> + AsMut<[u8]>,
+        T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
     {
         packet.set_src_port(self.src_port);
         packet.set_dst_port(self.dst_port);
@@ -266,7 +266,7 @@ impl Repr {
     }
 
     /// Emit a high-level representation into an User Datagram Protocol packet.
-    pub fn emit<T: ?Sized>(
+    pub fn emit<T>(
         &self,
         packet: &mut Packet<&mut T>,
         src_addr: &IpAddress,
@@ -275,7 +275,7 @@ impl Repr {
         emit_payload: impl FnOnce(&mut [u8]),
         checksum_caps: &ChecksumCapabilities,
     ) where
-        T: AsRef<[u8]> + AsMut<[u8]>,
+        T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
     {
         packet.set_src_port(self.src_port);
         packet.set_dst_port(self.dst_port);

Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ impl BpfDevice {`
`172`	`172`	`);`
`173`	`173`
`174`	`174`	`if len == -1 {`
`175`		`- Err(io::Error::last_os_error()).unwrap()`
	`175`	`+ panic!("{:?}", io::Error::last_os_error())`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`Ok(len as usize)`
Original file line number	Diff line number	Diff line change
`@@ -195,38 +195,37 @@ impl Address {`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`		`-#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]`
`199`		`-impl From<::std::net::IpAddr> for Address {`
`200`		`- fn from(x: ::std::net::IpAddr) -> Address {`
	`198`	`+#[cfg(all(feature = "proto-ipv4", feature = "proto-ipv6"))]`
	`199`	`+impl From<::core::net::IpAddr> for Address {`
	`200`	`+ fn from(x: ::core::net::IpAddr) -> Address {`
`201`	`201`	`match x {`
`202`		`- ::std::net::IpAddr::V4(ipv4) => Address::Ipv4(ipv4.into()),`
`203`		`- ::std::net::IpAddr::V6(ipv6) => Address::Ipv6(ipv6.into()),`
	`202`	`+ ::core::net::IpAddr::V4(ipv4) => Address::Ipv4(ipv4.into()),`
	`203`	`+ ::core::net::IpAddr::V6(ipv6) => Address::Ipv6(ipv6.into()),`
`204`	`204`	`}`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`
`208`		`-#[cfg(feature = "std")]`
`209`		`-impl From<Address> for ::std::net::IpAddr {`
`210`		`- fn from(x: Address) -> ::std::net::IpAddr {`
	`208`	`+impl From<Address> for ::core::net::IpAddr {`
	`209`	`+ fn from(x: Address) -> ::core::net::IpAddr {`
`211`	`210`	`match x {`
`212`	`211`	`#[cfg(feature = "proto-ipv4")]`
`213`		`- Address::Ipv4(ipv4) => ::std::net::IpAddr::V4(ipv4.into()),`
	`212`	`+ Address::Ipv4(ipv4) => ::core::net::IpAddr::V4(ipv4.into()),`
`214`	`213`	`#[cfg(feature = "proto-ipv6")]`
`215`		`- Address::Ipv6(ipv6) => ::std::net::IpAddr::V6(ipv6.into()),`
	`214`	`+ Address::Ipv6(ipv6) => ::core::net::IpAddr::V6(ipv6.into()),`
`216`	`215`	`}`
`217`	`216`	`}`
`218`	`217`	`}`
`219`	`218`
`220`		`-#[cfg(all(feature = "std", feature = "proto-ipv4"))]`
`221`		`-impl From<::std::net::Ipv4Addr> for Address {`
`222`		`- fn from(ipv4: ::std::net::Ipv4Addr) -> Address {`
	`219`	`+#[cfg(feature = "proto-ipv4")]`
	`220`	`+impl From<::core::net::Ipv4Addr> for Address {`
	`221`	`+ fn from(ipv4: ::core::net::Ipv4Addr) -> Address {`
`223`	`222`	`Address::Ipv4(ipv4.into())`
`224`	`223`	`}`
`225`	`224`	`}`
`226`	`225`
`227`		`-#[cfg(all(feature = "std", feature = "proto-ipv6"))]`
`228`		`-impl From<::std::net::Ipv6Addr> for Address {`
`229`		`- fn from(ipv6: ::std::net::Ipv6Addr) -> Address {`
	`226`	`+#[cfg(feature = "proto-ipv6")]`
	`227`	`+impl From<::core::net::Ipv6Addr> for Address {`
	`228`	`+ fn from(ipv6: ::core::net::Ipv6Addr) -> Address {`
`230`	`229`	`Address::Ipv6(ipv6.into())`
`231`	`230`	`}`
`232`	`231`	`}`
`@@ -395,29 +394,29 @@ impl Endpoint {`
`395`	`394`	`}`
`396`	`395`	`}`
`397`	`396`
`398`		`-#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]`
`399`		`-impl From<::std::net::SocketAddr> for Endpoint {`
`400`		`- fn from(x: ::std::net::SocketAddr) -> Endpoint {`
	`397`	`+#[cfg(all(feature = "proto-ipv4", feature = "proto-ipv6"))]`
	`398`	`+impl From<::core::net::SocketAddr> for Endpoint {`
	`399`	`+ fn from(x: ::core::net::SocketAddr) -> Endpoint {`
`401`	`400`	`Endpoint {`
`402`	`401`	`addr: x.ip().into(),`
`403`	`402`	`port: x.port(),`
`404`	`403`	`}`
`405`	`404`	`}`
`406`	`405`	`}`
`407`	`406`
`408`		`-#[cfg(all(feature = "std", feature = "proto-ipv4"))]`
`409`		`-impl From<::std::net::SocketAddrV4> for Endpoint {`
`410`		`- fn from(x: ::std::net::SocketAddrV4) -> Endpoint {`
	`407`	`+#[cfg(feature = "proto-ipv4")]`
	`408`	`+impl From<::core::net::SocketAddrV4> for Endpoint {`
	`409`	`+ fn from(x: ::core::net::SocketAddrV4) -> Endpoint {`
`411`	`410`	`Endpoint {`
`412`	`411`	`addr: (*x.ip()).into(),`
`413`	`412`	`port: x.port(),`
`414`	`413`	`}`
`415`	`414`	`}`
`416`	`415`	`}`
`417`	`416`
`418`		`-#[cfg(all(feature = "std", feature = "proto-ipv6"))]`
`419`		`-impl From<::std::net::SocketAddrV6> for Endpoint {`
`420`		`- fn from(x: ::std::net::SocketAddrV6) -> Endpoint {`
	`417`	`+#[cfg(feature = "proto-ipv6")]`
	`418`	`+impl From<::core::net::SocketAddrV6> for Endpoint {`
	`419`	`+ fn from(x: ::core::net::SocketAddrV6) -> Endpoint {`
`421`	`420`	`Endpoint {`
`422`	`421`	`addr: (*x.ip()).into(),`
`423`	`422`	`port: x.port(),`
`@@ -466,29 +465,29 @@ impl ListenEndpoint {`
`466`	`465`	`}`
`467`	`466`	`}`
`468`	`467`
`469`		`-#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]`
`470`		`-impl From<::std::net::SocketAddr> for ListenEndpoint {`
`471`		`- fn from(x: ::std::net::SocketAddr) -> ListenEndpoint {`
	`468`	`+#[cfg(all(feature = "proto-ipv4", feature = "proto-ipv6"))]`
	`469`	`+impl From<::core::net::SocketAddr> for ListenEndpoint {`
	`470`	`+ fn from(x: ::core::net::SocketAddr) -> ListenEndpoint {`
`472`	`471`	`ListenEndpoint {`
`473`	`472`	`addr: Some(x.ip().into()),`
`474`	`473`	`port: x.port(),`
`475`	`474`	`}`
`476`	`475`	`}`
`477`	`476`	`}`
`478`	`477`
`479`		`-#[cfg(all(feature = "std", feature = "proto-ipv4"))]`
`480`		`-impl From<::std::net::SocketAddrV4> for ListenEndpoint {`
`481`		`- fn from(x: ::std::net::SocketAddrV4) -> ListenEndpoint {`
	`478`	`+#[cfg(feature = "proto-ipv4")]`
	`479`	`+impl From<::core::net::SocketAddrV4> for ListenEndpoint {`
	`480`	`+ fn from(x: ::core::net::SocketAddrV4) -> ListenEndpoint {`
`482`	`481`	`ListenEndpoint {`
`483`	`482`	`addr: Some((*x.ip()).into()),`
`484`	`483`	`port: x.port(),`
`485`	`484`	`}`
`486`	`485`	`}`
`487`	`486`	`}`
`488`	`487`
`489`		`-#[cfg(all(feature = "std", feature = "proto-ipv6"))]`
`490`		`-impl From<::std::net::SocketAddrV6> for ListenEndpoint {`
`491`		`- fn from(x: ::std::net::SocketAddrV6) -> ListenEndpoint {`
	`488`	`+#[cfg(feature = "proto-ipv6")]`
	`489`	`+impl From<::core::net::SocketAddrV6> for ListenEndpoint {`
	`490`	`+ fn from(x: ::core::net::SocketAddrV6) -> ListenEndpoint {`
`492`	`491`	`ListenEndpoint {`
`493`	`492`	`addr: Some((*x.ip()).into()),`
`494`	`493`	`port: x.port(),`
Original file line number	Diff line number	Diff line change
`@@ -110,16 +110,14 @@ impl Address {`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`-#[cfg(feature = "std")]`
`114`		`-impl From<::std::net::Ipv4Addr> for Address {`
`115`		`- fn from(x: ::std::net::Ipv4Addr) -> Address {`
	`113`	`+impl From<::core::net::Ipv4Addr> for Address {`
	`114`	`+ fn from(x: ::core::net::Ipv4Addr) -> Address {`
`116`	`115`	`Address(x.octets())`
`117`	`116`	`}`
`118`	`117`	`}`
`119`	`118`
`120`		`-#[cfg(feature = "std")]`
`121`		`-impl From<Address> for ::std::net::Ipv4Addr {`
`122`		`- fn from(Address(x): Address) -> ::std::net::Ipv4Addr {`
	`119`	`+impl From<Address> for ::core::net::Ipv4Addr {`
	`120`	`+ fn from(Address(x): Address) -> ::core::net::Ipv4Addr {`
`123`	`121`	`x.into()`
`124`	`122`	`}`
`125`	`123`	`}`