unistd/gethostname: internally allocate buffer for result

This changes `gethostname` signature to be more idiomatic, by
internally allocating the buffer for result.

Ref: nix-rust#816 (comment)

Author: lucab

CHANGELOG.md

@@ -49,6 +49,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
   ([#892](https://github.com/nix-rust/nix/pull/892))
 - Remove `IFF_NOTRAILERS` on OpenBSD, as it has been removed in OpenBSD 6.3
   ([#893](https://github.com/nix-rust/nix/pull/893))
+- Changed `nix::unistd::gethostname` to internally allocate its buffer.
+  ([#816](https://github.com/nix-rust/nix/pull/816))
 
 ### Fixed
 - Fixed possible panics when using `SigAction::flags` on Linux

src/unistd.rs

@@ -739,34 +739,38 @@ pub fn sethostname<S: AsRef<OsStr>>(name: S) -> Result<()> {
     Errno::result(res).map(drop)
 }
 
-/// Get the host name and store it in the provided buffer, returning a pointer
-/// the `CStr` in that buffer on success (see
+/// Get the host name, returning a `OsString` on success (see
 /// [gethostname(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/gethostname.html)).
 ///
-/// This function call attempts to get the host name for the running system and
-/// store it in a provided buffer.  The buffer will be populated with bytes up
-/// to the length of the provided slice including a NUL terminating byte.  If
-/// the hostname is longer than the length provided, no error will be provided.
-/// The posix specification does not specify whether implementations will
-/// null-terminate in this case, but the nix implementation will ensure that the
-/// buffer is null terminated in this case.
+/// This function call attempts to get the host name for the
+/// running system.
 ///
-/// ```no_run
+/// # Examples
+///
+/// ```
 /// use nix::unistd;
 ///
-/// let mut buf = [0u8; 64];
-/// let hostname_cstr = unistd::gethostname(&mut buf).expect("Failed getting hostname");
-/// let hostname = hostname_cstr.to_str().expect("Hostname wasn't valid UTF-8");
+/// let hostname_os = unistd::gethostname().expect("Failed getting hostname");
+/// let hostname = hostname_os.into_string().expect("Hostname wasn't valid UTF-8");
 /// println!("Hostname: {}", hostname);
 /// ```
-pub fn gethostname(buffer: &mut [u8]) -> Result<&CStr> {
-    let ptr = buffer.as_mut_ptr() as *mut c_char;
-    let len = buffer.len() as size_t;
-
-    let res = unsafe { libc::gethostname(ptr, len) };
+pub fn gethostname() -> Result<OsString> {
+    // Minimum hostname maximum length as defined by POSIX,
+    // http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html
+    const _POSIX_HOST_NAME_MAX: i64 = 255;
+    let buf_len = sysconf(SysconfVar::HOST_NAME_MAX)
+        .unwrap_or(None).unwrap_or(_POSIX_HOST_NAME_MAX + 1);
+    let buf = vec![0; buf_len as usize];
+    let ptr = unsafe { CString::from_vec_unchecked(buf).into_raw() };
+
+    let res = unsafe { libc::gethostname(ptr, buf_len as usize) };
     Errno::result(res).map(|_| {
-        buffer[len - 1] = 0; // ensure always null-terminated
-        unsafe { CStr::from_ptr(buffer.as_ptr() as *const c_char) }
+        let cstr = unsafe {
+            // Ensure CString is null-terminated
+            *ptr.offset((buf_len - 1) as isize) = 0;
+            CString::from_raw(ptr)
+        };
+        OsString::from_vec(cstr.into_bytes())
     })
 }
 

test/test_unistd.rs

@@ -460,7 +460,6 @@ fn test_canceling_alarm() {
 
 #[test]
 fn test_gethostname() {
-    let mut buf = [0u8; 255];
-    let hn = gethostname(&mut buf).expect("gethostname failed");
-    hn.to_str().expect("hostname contains invalid data");
+    let hn = gethostname().expect("gethostname failed");
+    hn.into_string().expect("hostname contains invalid data");
 }