youknowone · Sep 22, 2026 · Sep 22, 2026 · Sep 22, 2026 · Sep 22, 2026 · Sep 22, 2026
diff --git a/crates/host_env/src/errno_wasm.rs b/crates/host_env/src/errno_wasm.rs
@@ -1,10 +1,86 @@
 //! Errno numbers for `wasm32-unknown-unknown`.
 //!
-//! There is no libc errno table. The values are the Linux ABI the stdlib
-//! and `OSError` subclasses match against.
+//! There is no libc errno table. The values are the Darwin/BSD numbers the
+//! guest `O_*` flags and `OSError` subclasses match against.
+
+#[must_use]
+pub fn strerror_string(errno: i32) -> Option<String> {
+    errors::strerror(errno).map(str::to_owned)
+}
 
 pub mod errors {
-    pub const EAGAIN: i32 = 11;
-    pub const ECONNABORTED: i32 = 103;
-    pub const ECONNRESET: i32 = 104;
+    pub const EPERM: i32 = 1;
+    pub const ENOENT: i32 = 2;
+    pub const ESRCH: i32 = 3;
+    pub const EINTR: i32 = 4;
+    pub const EIO: i32 = 5;
+    pub const EBADF: i32 = 9;
+    pub const ECHILD: i32 = 10;
+    pub const EAGAIN: i32 = 35;
+    pub const EWOULDBLOCK: i32 = 35;
+    pub const EINPROGRESS: i32 = 36;
+    pub const EALREADY: i32 = 37;
+    pub const EPIPE: i32 = 32;
+    pub const ENOTDIR: i32 = 20;
+    pub const EISDIR: i32 = 21;
+    pub const EINVAL: i32 = 22;
+    pub const EMFILE: i32 = 24;
+    pub const ESPIPE: i32 = 29;
+    pub const EROFS: i32 = 30;
+    pub const EACCES: i32 = 13;
+    pub const EEXIST: i32 = 17;
+    pub const ENOTSUP: i32 = 45;
+    pub const EAFNOSUPPORT: i32 = 47;
+    pub const ECONNABORTED: i32 = 53;
+    pub const ECONNRESET: i32 = 54;
+    pub const ESHUTDOWN: i32 = 58;
+    pub const ETIMEDOUT: i32 = 60;
+    pub const ECONNREFUSED: i32 = 61;
+
+    pub fn strerror(errno: i32) -> Option<&'static str> {
+        Some(match errno {
+            EPERM => "Operation not permitted",
+            ENOENT => "No such file or directory",
+            ESRCH => "No such process",
+            EIO => "Input/output error",
+            EINTR => "Interrupted system call",
+            ECHILD => "No child processes",
+            EACCES => "Permission denied",
+            EEXIST => "File exists",
+            ENOTDIR => "Not a directory",
+            EISDIR => "Is a directory",
+            EPIPE => "Broken pipe",
+            EAGAIN => "Resource temporarily unavailable",
+            EINPROGRESS => "Operation now in progress",
+            EALREADY => "Operation already in progress",
+            ENOTSUP => "Operation not supported",
+            EAFNOSUPPORT => "Address family not supported by protocol",
+            ECONNABORTED => "Software caused connection abort",
+            ECONNRESET => "Connection reset by peer",
+            ETIMEDOUT => "Operation timed out",
+            ECONNREFUSED => "Connection refused",
+            EBADF => "Bad file descriptor",
+            EINVAL => "Invalid argument",
+            EMFILE => "Too many open files",
+            ESPIPE => "Illegal seek",
+            EROFS => "Read-only file system",
+            ESHUTDOWN => "Can't send after socket shutdown",
+            _ => return None,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::errors;
+
+    #[test]
+    fn eagain_is_darwin() {
+        assert_eq!(errors::EAGAIN, 35);
+        assert_eq!(errors::EWOULDBLOCK, 35);
+        assert_eq!(
+            errors::strerror(errors::EAGAIN),
+            Some("Resource temporarily unavailable")
+        );
+    }
 }
diff --git a/crates/host_env/src/fcntl.rs b/crates/host_env/src/fcntl.rs
@@ -7,6 +7,17 @@ use crate::os::CheckLibcResult;
 
 pub use libc::{F_GETFD, F_GETFL, F_SETFD, F_SETFL, FD_CLOEXEC};
 
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "redox"
+))]
+pub use libc::{F_LOCK, F_TEST, F_TLOCK, F_ULOCK};
+
 #[cfg(not(target_os = "wasi"))]
 pub use libc::{F_DUPFD, F_DUPFD_CLOEXEC, F_GETLK, F_SETLK, F_SETLKW};
 

diff --git a/crates/host_env/src/fileutils.rs b/crates/host_env/src/fileutils.rs
@@ -466,7 +466,7 @@ pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut CFile>
 
         // Convert File handle to CRT file descriptor
         let handle = file.into_raw_handle();
-        let fd = unsafe { libc::open_osfhandle(handle as isize, libc::O_RDONLY) };
+        let fd = unsafe { libc::open_osfhandle(handle as isize, crate::os::O_RDONLY) };
         if fd == -1 {
             return Err(std::io::Error::last_os_error());
         }

diff --git a/crates/host_env/src/io.rs b/crates/host_env/src/io.rs
@@ -82,7 +82,7 @@ pub fn parse_fileio_mode(mode_str: &str) -> Result<ParsedFileMode, FileModeError
                 }
                 rwa = true;
                 mode.insert(FileMode::WRITABLE | FileMode::CREATED);
-                flags |= libc::O_EXCL | libc::O_CREAT;
+                flags |= os::O_EXCL | os::O_CREAT;
             }
             b'r' => {
                 if rwa {
@@ -97,15 +97,15 @@ pub fn parse_fileio_mode(mode_str: &str) -> Result<ParsedFileMode, FileModeError
                 }
                 rwa = true;
                 mode.insert(FileMode::WRITABLE);
-                flags |= libc::O_CREAT | libc::O_TRUNC;
+                flags |= os::O_CREAT | os::O_TRUNC;
             }
             b'a' => {
                 if rwa {
                     return Err(FileModeError::BadRwa);
                 }
                 rwa = true;
                 mode.insert(FileMode::WRITABLE | FileMode::APPENDING);
-                flags |= libc::O_APPEND | libc::O_CREAT;
+                flags |= os::O_APPEND | os::O_CREAT;
             }
             b'+' => {
                 if plus {
@@ -124,20 +124,20 @@ pub fn parse_fileio_mode(mode_str: &str) -> Result<ParsedFileMode, FileModeError
     }
 
     if mode.contains(FileMode::READABLE | FileMode::WRITABLE) {
-        flags |= libc::O_RDWR;
+        flags |= os::O_RDWR;
     } else if mode.contains(FileMode::READABLE) {
-        flags |= libc::O_RDONLY;
+        flags |= os::O_RDONLY;
     } else {
-        flags |= libc::O_WRONLY;
+        flags |= os::O_WRONLY;
     }
 
     #[cfg(windows)]
     {
-        flags |= libc::O_BINARY | libc::O_NOINHERIT;
+        flags |= os::O_BINARY | os::O_NOINHERIT;
     }
     #[cfg(unix)]
     {
-        flags |= libc::O_CLOEXEC;
+        flags |= os::O_CLOEXEC;
     }
 
     Ok(ParsedFileMode { mode, flags })

diff --git a/crates/host_env/src/io_unsupported.rs b/crates/host_env/src/io_unsupported.rs
@@ -2,19 +2,8 @@ use core::ffi::CStr;
 use std::io;
 
 use crate::crt_fd;
-
-const EBADF: i32 = 9;
-const EAGAIN: i32 = 11;
-const EINTR: i32 = 4;
-const EISDIR: i32 = 21;
-
-const O_RDONLY: i32 = 0;
-const O_WRONLY: i32 = 1;
-const O_RDWR: i32 = 2;
-const O_APPEND: i32 = 0x0008;
-const O_CREAT: i32 = 0x0200;
-const O_TRUNC: i32 = 0x0400;
-const O_EXCL: i32 = 0x0800;
+use crate::errno::errors::{EAGAIN, EBADF, EINTR, EISDIR};
+use crate::os::{O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY};
 
 bitflags::bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]

diff --git a/crates/host_env/src/msvcrt.rs b/crates/host_env/src/msvcrt.rs
@@ -46,7 +46,7 @@ unsafe extern "C" {
 }
 
 pub fn setmode_binary(fd: crt_fd::Borrowed<'_>) {
-    unsafe { suppress_iph!(_setmode(fd, libc::O_BINARY)) };
+    unsafe { suppress_iph!(_setmode(fd, crate::os::O_BINARY)) };
 }
 
 #[must_use]

diff --git a/crates/host_env/src/multiprocessing.rs b/crates/host_env/src/multiprocessing.rs
@@ -136,8 +136,14 @@ impl SemHandle {
         unlink: bool,
     ) -> Result<(Self, Option<String>), SemError> {
         let cname = semaphore_name(name)?;
-        let raw =
-            unsafe { libc::sem_open(cname.as_ptr(), libc::O_CREAT | libc::O_EXCL, 0o600, value) };
+        let raw = unsafe {
+            libc::sem_open(
+                cname.as_ptr(),
+                crate::os::O_CREAT | crate::os::O_EXCL,
+                0o600,
+                value,
+            )
+        };
         if raw == libc::SEM_FAILED {
             return Err(SemError::from_errno(Errno::last()));
         }

diff --git a/crates/host_env/src/nt.rs b/crates/host_env/src/nt.rs
@@ -1369,7 +1369,7 @@ pub fn pipe() -> io::Result<(i32, i32)> {
 
     let write_fd = match crate::msvcrt::open_osfhandle(
         write_handle.as_raw_handle() as isize,
-        libc::O_WRONLY | O_NOINHERIT,
+        crate::os::O_WRONLY | O_NOINHERIT,
     ) {
         Ok(fd) => {
             let _ = write_handle.into_raw_handle();
@@ -2370,9 +2370,9 @@ pub fn open_console_path_fd(path: &widestring::WideCStr, writable: bool) -> io::
     }
 
     let osf_flags = if writable {
-        libc::O_WRONLY | libc::O_BINARY | 0x80
+        crate::os::O_WRONLY | crate::os::O_BINARY | 0x80
     } else {
-        libc::O_RDONLY | libc::O_BINARY | 0x80
+        crate::os::O_RDONLY | crate::os::O_BINARY | 0x80
     };
     match crate::msvcrt::open_osfhandle(handle as isize, osf_flags) {
         Ok(fd) => Ok(fd),

diff --git a/crates/host_env/src/os.rs b/crates/host_env/src/os.rs
@@ -40,6 +40,124 @@ pub use libc::AT_FDCWD;
 #[cfg(not(any(unix, target_os = "wasi")))]
 pub const AT_FDCWD: i32 = -100;
 
+#[cfg(unix)]
+pub use libc::{AT_REMOVEDIR, AT_SYMLINK_FOLLOW, AT_SYMLINK_NOFOLLOW};
+
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "netbsd",
+    target_vendor = "apple"
+))]
+pub use libc::AT_EACCESS;
+
+/// bionic does not export `AT_EACCESS`; the value is the Linux `fcntl.h` one.
+#[cfg(target_os = "android")]
+pub const AT_EACCESS: i32 = 0x200;
+
+#[cfg(all(unix, not(target_os = "redox")))]
+pub use libc::{ST_NOSUID, ST_RDONLY};
+
+/// `open(2)` flags. libc on hosts that bind them; Darwin/BSD numbers on
+/// `wasm32-unknown-unknown`, matching the guest errno table.
+#[cfg(any(unix, windows, target_os = "wasi"))]
+pub use libc::{O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY};
+
+#[cfg(unix)]
+pub use libc::{O_ACCMODE, O_CLOEXEC, O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK};
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "redox"
+))]
+pub use libc::{O_ASYNC, O_NDELAY, O_NOCTTY};
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd"
+))]
+pub use libc::O_DSYNC;
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd"
+))]
+pub use libc::O_SYNC;
+
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "redox"
+))]
+pub use libc::O_FSYNC;
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub use libc::{O_DIRECT, O_LARGEFILE, O_NOATIME, O_PATH, O_RSYNC, O_TMPFILE};
+
+#[cfg(target_os = "freebsd")]
+pub use libc::{O_DIRECT, O_PATH};
+
+#[cfg(target_os = "redox")]
+pub use libc::O_PATH;
+
+#[cfg(target_os = "netbsd")]
+pub use libc::{O_DIRECT, O_RSYNC};
+
+#[cfg(target_os = "dragonfly")]
+pub use libc::O_DIRECT;
+
+#[cfg(any(target_os = "macos", target_os = "ios"))]
+pub use libc::{O_EVTONLY, O_EXEC, O_EXLOCK, O_NOFOLLOW_ANY, O_SEARCH, O_SHLOCK, O_SYMLINK};
+
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "redox"
+))]
+pub use libc::{O_EXLOCK, O_SHLOCK};
+
+#[cfg(target_os = "redox")]
+pub use libc::O_SYMLINK;
+
+#[cfg(windows)]
+pub use libc::{O_BINARY, O_NOINHERIT, O_RANDOM, O_SEQUENTIAL, O_TEMPORARY, O_TEXT};
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+mod wasm_oflag {
+    pub const O_RDONLY: i32 = 0x0000;
+    pub const O_WRONLY: i32 = 0x0001;
+    pub const O_RDWR: i32 = 0x0002;
+    pub const O_ACCMODE: i32 = 0x0003;
+    pub const O_NONBLOCK: i32 = 0x0004;
+    pub const O_APPEND: i32 = 0x0008;
+    pub const O_SYNC: i32 = 0x0080;
+    pub const O_NOFOLLOW: i32 = 0x0100;
+    pub const O_CREAT: i32 = 0x0200;
+    pub const O_TRUNC: i32 = 0x0400;
+    pub const O_EXCL: i32 = 0x0800;
+    pub const O_DIRECTORY: i32 = 0x0010_0000;
+    pub const O_CLOEXEC: i32 = 0x0100_0000;
+    pub const O_NDELAY: i32 = O_NONBLOCK;
+}
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+pub use wasm_oflag::*;
+
 /// BSD `chflags` bits the `libc` crate does not bind. Published by `_stat`
 /// on every platform.
 pub const UF_SETTABLE: u32 = 0x0000ffff;
@@ -837,3 +955,16 @@ pub fn winerror_to_errno(winerror: i32) -> i32 {
         _ => EINVAL,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn o_rdonly_is_zero() {
+        assert_eq!(super::O_RDONLY, 0);
+    }
+
+    #[test]
+    fn o_wronly_is_one() {
+        assert_eq!(super::O_WRONLY, 1);
+    }
+}