std: net: support for getting the system hostname, take 2

Author: orowith2os

library/std/src/net/hostname.rs

@@ -1,47 +1,7 @@
-#[cfg(not(any(target_family = "windows")))]
-use libc::gethostname;
-
-use crate::ffi::{CStr, OsString};
-use crate::os::raw::c_char;
+use crate::ffi::OsString;
 
 /// 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.
-    #[cfg(any(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
-    };
-
-    // SAFETY: should never be unsafe, as we're passing in a valid (0-initialized) buffer, and the
-    // length of said buffer.
-    #[cfg(not(any(target_family = "windows")))]
-    let gethostname_result = unsafe { gethostname(&mut temp_buffer as _, temp_buffer.len()) };
-
-    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()),
-    }
+    crate::os::net::hostname()
 }

library/std/src/os/mod.rs

@@ -183,3 +183,6 @@ pub mod fd;
 
 #[cfg(any(target_os = "linux", target_os = "android", doc))]
 mod net;
+
+#[cfg(not(target_platform = "windows"))]
+pub(crate) mod net;

library/std/src/os/net/mod.rs

@@ -11,3 +11,8 @@
 )))]
 #[cfg(any(target_os = "linux", target_os = "android", doc))]
 pub(super) mod linux_ext;
+
+#[cfg(not(target_family = "windows"))]
+pub(crate) use self::unix::hostname;
+
+mod unix;

library/std/src/os/net/unix/hostname.rs

@@ -0,0 +1,32 @@
+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`].
+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];
+    
+    // SAFETY: should never be unsafe, as we're passing in a valid (0-initialized) buffer, and the
+    // length of said buffer.
+    let gethostname_result = unsafe { gethostname(&mut temp_buffer as _, temp_buffer.len()) };
+
+    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/os/net/unix/mod.rs

@@ -0,0 +1,3 @@
+pub use self::hostname::hostname;
+
+mod hostname;