std: net: Add function to get the system hostname

Author: orowith2os

library/std/src/net/hostname.rs

@@ -0,0 +1,45 @@
+#[cfg(not(target_family = "windows"))]
+use libc::gethostname;
+
+use crate::ffi::{CStr, OsString};
+use crate::os::raw::c_char;
+
+/// Returns the system hostname.
+///
+/// The returned result will, on success, return the same result [`libc::gethostname`] would return
+/// (as it is implemented using the very same function), and on error, what `errno` contains, also
+/// set by [`libc::gethostname`].
+#[unstable(feature = "gethostname", issue = "135142")]
+pub fn hostname() -> crate::io::Result<OsString> {
+    // 255 bytes is the maximum allowable length for a hostname (as per the DNS spec),
+    // so we shouldn't ever have problems with this. I (@orowith2os) considered using a constant
+    // and letting the platform set the length, but it was determined after some discussion that
+    // this could break things if the platform changes their length. Possible alternative is to
+    // read the sysconf setting for the max hostname length, but that might be a bit too much work.
+    // The 256 byte length is to allow for the NUL terminator.
+    let mut temp_buffer: [c_char; 256] = [0; 256];
+    // 0 = no problem, and there isn't any other relevant error code to check for. Only stuff for
+    // sethostname, and ENAMETOOLONG, which is only relevant for glibc 2.1 or newer. With the
+    // previous information given in mind, we shouldn't ever encounter any error other than the
+    // fact that the system *somehow* failed to get the hostname.
+    // SAFETY: should never be unsafe, as we're passing in a valid (0-initialized) buffer, and the
+    // length of said buffer.
+    #[cfg(not(target_family = "windows"))]
+    let gethostname_result = unsafe { gethostname(&mut temp_buffer as _, temp_buffer.len()) };
+    #[cfg(target_family = "windows")]
+    let gethostname_result = {
+        println!(
+            "gethostname impl for the Rust stdlib isn't done on Windows yet, so here's an error instead!"
+        );
+        -1
+    };
+
+    match gethostname_result {
+        0 => {
+            // SAFETY: we already know the pointer here is valid, we made it from safe Rust earlier.
+            let cstring = unsafe { CStr::from_ptr(&mut temp_buffer as _) };
+            return Ok(OsString::from(cstring.to_string_lossy().as_ref()));
+        }
+        _ => Err(crate::io::Error::last_os_error()),
+    }
+}

library/std/src/net/mod.rs

@@ -1,7 +1,8 @@
 //! Networking primitives for TCP/UDP communication.
 //!
 //! This module provides networking functionality for the Transmission Control and User
-//! Datagram Protocols, as well as types for IP and socket addresses.
+//! Datagram Protocols, as well as types for IP and socket addresses, and functions related
+//! to network properties.
 //!
 //! # Organization
 //!
@@ -24,6 +25,8 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::net::AddrParseError;
 
+#[unstable(feature = "gethostname", issue = "135142")]
+pub use self::hostname::hostname;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::ip_addr::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -36,6 +39,7 @@ pub use self::tcp::{Incoming, TcpListener, TcpStream};
 pub use self::udp::UdpSocket;
 use crate::io::{self, ErrorKind};
 
+mod hostname;
 mod ip_addr;
 mod socket_addr;
 mod tcp;