diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 2700659d4e96..f0e4e95db146 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -253,6 +253,7 @@
 #![feature(exhaustive_patterns)]
 #![feature(if_let_guard)]
 #![feature(intra_doc_pointers)]
+#![feature(ipv6_hop_limit)]
 #![feature(lang_items)]
 #![feature(let_chains)]
 #![feature(linkage)]
diff --git a/library/std/src/net/tcp.rs b/library/std/src/net/tcp.rs
index 69b72a81c5b6..c1e5e494ed2f 100644
--- a/library/std/src/net/tcp.rs
+++ b/library/std/src/net/tcp.rs
@@ -541,6 +541,86 @@ impl TcpStream {
         self.0.ttl()
     }
 
+    /// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the unicast hop limit field that is used in every packet
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("127.0.0.1:54321")
+    ///                        .expect("Couldn't connect to the server...");
+    /// stream.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0.set_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`TcpStream::set_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("127.0.0.1:54321")
+    ///                        .expect("Couldn't connect to the server...");
+    /// stream.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// assert_eq!(stream.hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0.hop_limit_v6()
+    }
+
+    /// Sets the value for the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the hop limit field for outgoing multicast packets
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("127.0.0.1:54321")
+    ///                        .expect("Couldn't connect to the server...");
+    /// stream.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0.set_multicast_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`TcpStream::set_multicast_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("127.0.0.1:54321")
+    ///                        .expect("Couldn't connect to the server...");
+    /// stream.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// assert_eq!(stream.multicast_hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0.multicast_hop_limit_v6()
+    }
+
     /// Gets the value of the `SO_ERROR` option on this socket.
     ///
     /// This will retrieve the stored error in the underlying socket, clearing
@@ -915,6 +995,82 @@ impl TcpListener {
         self.0.ttl()
     }
 
+    /// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the unicast hop limit field that is used in every packet
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpListener;
+    ///
+    /// let listener = TcpListener::bind("127.0.0.1:54321").unwrap();
+    /// listener.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0.set_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`TcpListener::set_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpListener;
+    ///
+    /// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
+    /// listener.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// assert_eq!(listener.hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0.hop_limit_v6()
+    }
+
+    /// Sets the value for the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the hop limit field for outgoing multicast packets
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpListener;
+    ///
+    /// let listener = TcpListener::bind("127.0.0.1:54321").unwrap();
+    /// listener.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0.set_multicast_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`TcpListener::set_multicast_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpListener;
+    ///
+    /// let listener = TcpListener::bind("127.0.0.1:54321").unwrap();
+    /// listener.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// assert_eq!(listener.multicast_hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0.multicast_hop_limit_v6()
+    }
+
     #[stable(feature = "net2_mutators", since = "1.9.0")]
     #[deprecated(since = "1.16.0", note = "this option can only be set before the socket is bound")]
     #[allow(missing_docs)]
diff --git a/library/std/src/net/tcp/tests.rs b/library/std/src/net/tcp/tests.rs
index 8c0adcfb0ebb..d794e34a6638 100644
--- a/library/std/src/net/tcp/tests.rs
+++ b/library/std/src/net/tcp/tests.rs
@@ -813,6 +813,23 @@ fn ttl() {
     assert_eq!(ttl, t!(stream.ttl()));
 }
 
+#[test]
+#[cfg_attr(target_env = "sgx", ignore)]
+fn hop_limit() {
+    let hlim: u32 = 100;
+
+    let addr = next_test_ip6();
+    let listener = t!(TcpListener::bind(&addr));
+
+    t!(listener.set_hop_limit_v6(hlim));
+    assert_eq!(hlim, t!(listener.hop_limit_v6()));
+
+    let stream = t!(TcpStream::connect(&addr));
+
+    t!(stream.set_hop_limit_v6(hlim));
+    assert_eq!(hlim, t!(stream.hop_limit_v6()));
+}
+
 #[test]
 #[cfg_attr(target_env = "sgx", ignore)]
 fn set_nonblocking() {
diff --git a/library/std/src/net/udp.rs b/library/std/src/net/udp.rs
index 864e1b0f3450..e02d65bc05a8 100644
--- a/library/std/src/net/udp.rs
+++ b/library/std/src/net/udp.rs
@@ -554,6 +554,82 @@ impl UdpSocket {
         self.0.ttl()
     }
 
+    /// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the unicast hop limit field that is used in every packet
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("127.0.0.1:54321").expect("couldn't bind to address");
+    /// socket.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0.set_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`UdpSocket::set_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("127.0.0.1:54321").expect("couldn't bind to address");
+    /// socket.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// assert_eq!(socket.hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0.hop_limit_v6()
+    }
+
+    /// Sets the value for the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the hop limit field for outgoing multicast packets
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("127.0.0.1:54321").expect("couldn't bind to address");
+    /// socket.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0.set_multicast_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`UdpSocket::set_multicast_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("127.0.0.1:54321").expect("couldn't bind to address");
+    /// socket.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// assert_eq!(socket.multicast_hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "47727")]
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0.multicast_hop_limit_v6()
+    }
+
     /// Executes an operation of the `IP_ADD_MEMBERSHIP` type.
     ///
     /// This function specifies a new multicast group for this socket to join.
diff --git a/library/std/src/net/udp/tests.rs b/library/std/src/net/udp/tests.rs
index f82904ffbbf7..c6727edc0646 100644
--- a/library/std/src/net/udp/tests.rs
+++ b/library/std/src/net/udp/tests.rs
@@ -342,6 +342,18 @@ fn ttl() {
     assert_eq!(ttl, t!(stream.ttl()));
 }
 
+#[test]
+fn hop_limit() {
+    let hlim = 100;
+
+    let addr = next_test_ip6();
+
+    let stream = t!(UdpSocket::bind(&addr));
+
+    t!(stream.set_hop_limit_v6(hlim));
+    assert_eq!(hlim, t!(stream.hop_limit_v6()));
+}
+
 #[test]
 fn set_nonblocking() {
     each_ip(&mut |addr, _| {
diff --git a/library/std/src/sys/hermit/net.rs b/library/std/src/sys/hermit/net.rs
index 8a13879d8cc8..f9e0afb2c4d7 100644
--- a/library/std/src/sys/hermit/net.rs
+++ b/library/std/src/sys/hermit/net.rs
@@ -208,6 +208,22 @@ impl TcpStream {
             .map_err(|_| io::const_io_error!(ErrorKind::Uncategorized, "unable to get TTL"))
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         unsupported()
     }
@@ -265,6 +281,22 @@ impl TcpListener {
         unsupported()
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
         unsupported()
     }
@@ -391,6 +423,22 @@ impl UdpSocket {
         unsupported()
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         unsupported()
     }
diff --git a/library/std/src/sys/sgx/net.rs b/library/std/src/sys/sgx/net.rs
index 4c4cd7d1d1d8..ed8497fcdf7d 100644
--- a/library/std/src/sys/sgx/net.rs
+++ b/library/std/src/sys/sgx/net.rs
@@ -10,6 +10,7 @@ use crate::time::Duration;
 use super::abi::usercalls;
 
 const DEFAULT_FAKE_TTL: u32 = 64;
+const DEFAULT_FAKE_HLIM: u32 = 64;
 
 #[derive(Debug, Clone)]
 pub struct Socket {
@@ -206,6 +207,22 @@ impl TcpStream {
         sgx_ineffective(DEFAULT_FAKE_TTL)
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        sgx_ineffective(())
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        sgx_ineffective(DEFAULT_FAKE_HLIM)
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        sgx_ineffective(())
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        sgx_ineffective(DEFAULT_FAKE_HLIM)
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         Ok(None)
     }
@@ -282,6 +299,22 @@ impl TcpListener {
         sgx_ineffective(DEFAULT_FAKE_TTL)
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        sgx_ineffective(())
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        sgx_ineffective(DEFAULT_FAKE_HLIM)
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        sgx_ineffective(())
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        sgx_ineffective(DEFAULT_FAKE_HLIM)
+    }
+
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
         sgx_ineffective(())
     }
@@ -420,6 +453,22 @@ impl UdpSocket {
         self.0
     }
 
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.0
     }
diff --git a/library/std/src/sys/unix/l4re.rs b/library/std/src/sys/unix/l4re.rs
index 9967588939ac..2683aaada51d 100644
--- a/library/std/src/sys/unix/l4re.rs
+++ b/library/std/src/sys/unix/l4re.rs
@@ -271,6 +271,22 @@ pub mod net {
             unimpl!();
         }
 
+        pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+            unimpl!()
+        }
+
+        pub fn hop_limit_v6(&self) -> io::Result<u32> {
+            unimpl!()
+        }
+
+        pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+            unimpl!()
+        }
+
+        pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+            unimpl!()
+        }
+
         pub fn ttl(&self) -> io::Result<u32> {
             unimpl!();
         }
@@ -333,6 +349,22 @@ pub mod net {
             unimpl!();
         }
 
+        pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+            unimpl!()
+        }
+
+        pub fn hop_limit_v6(&self) -> io::Result<u32> {
+            unimpl!()
+        }
+
+        pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+            unimpl!()
+        }
+
+        pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+            unimpl!()
+        }
+
         pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
             unimpl!();
         }
@@ -475,6 +507,22 @@ pub mod net {
             unimpl!();
         }
 
+        pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+            unimpl!()
+        }
+
+        pub fn hop_limit_v6(&self) -> io::Result<u32> {
+            unimpl!()
+        }
+
+        pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+            unimpl!()
+        }
+
+        pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+            unimpl!()
+        }
+
         pub fn take_error(&self) -> io::Result<Option<io::Error>> {
             unimpl!();
         }
diff --git a/library/std/src/sys/unsupported/net.rs b/library/std/src/sys/unsupported/net.rs
index a5204a084537..51668b0d51e1 100644
--- a/library/std/src/sys/unsupported/net.rs
+++ b/library/std/src/sys/unsupported/net.rs
@@ -99,6 +99,22 @@ impl TcpStream {
         self.0
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.0
     }
@@ -141,6 +157,22 @@ impl TcpListener {
         self.0
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
         self.0
     }
@@ -267,6 +299,22 @@ impl UdpSocket {
         self.0
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        self.0
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.0
     }
diff --git a/library/std/src/sys/wasi/net.rs b/library/std/src/sys/wasi/net.rs
index 590d268c3808..bcf1abd2b43d 100644
--- a/library/std/src/sys/wasi/net.rs
+++ b/library/std/src/sys/wasi/net.rs
@@ -151,6 +151,22 @@ impl TcpStream {
         unsupported()
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         unsupported()
     }
@@ -233,6 +249,22 @@ impl TcpListener {
         unsupported()
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
         unsupported()
     }
@@ -402,6 +434,22 @@ impl UdpSocket {
         unsupported()
     }
 
+    pub fn set_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u32) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        unsupported()
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         unsupported()
     }
diff --git a/library/std/src/sys/windows/c.rs b/library/std/src/sys/windows/c.rs
index c61a7e7d1e4a..b7d11be1f80f 100644
--- a/library/std/src/sys/windows/c.rs
+++ b/library/std/src/sys/windows/c.rs
@@ -217,6 +217,8 @@ pub const IPPROTO_TCP: c_int = 6;
 pub const IPPROTO_IPV6: c_int = 41;
 pub const TCP_NODELAY: c_int = 0x0001;
 pub const IP_TTL: c_int = 4;
+pub const IPV6_UNICAST_HOPS: c_int = 4;
+pub const IPV6_MULTICAST_HOPS: c_int = 10;
 pub const IPV6_V6ONLY: c_int = 27;
 pub const SO_ERROR: c_int = 0x1007;
 pub const SO_BROADCAST: c_int = 0x0020;
diff --git a/library/std/src/sys_common/net.rs b/library/std/src/sys_common/net.rs
index 3ad802afa8f7..79aa1c6f1000 100644
--- a/library/std/src/sys_common/net.rs
+++ b/library/std/src/sys_common/net.rs
@@ -336,6 +336,24 @@ impl TcpStream {
         Ok(raw as u32)
     }
 
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, limit as c_int)
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS)?;
+        Ok(raw as u32)
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS, limit as c_int)
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS)?;
+        Ok(raw as u32)
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.inner.take_error()
     }
@@ -454,6 +472,24 @@ impl TcpListener {
         Ok(raw as u32)
     }
 
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, limit as c_int)
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS)?;
+        Ok(raw as u32)
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS, limit as c_int)
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS)?;
+        Ok(raw as u32)
+    }
+
     pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
         setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY, only_v6 as c_int)
     }
@@ -658,6 +694,24 @@ impl UdpSocket {
         Ok(raw as u32)
     }
 
+    pub fn set_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, limit as c_int)
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS)?;
+        Ok(raw as u32)
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, limit: u32) -> io::Result<()> {
+        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS, limit as c_int)
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS)?;
+        Ok(raw as u32)
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.inner.take_error()
     }