RustPython · youknowone · Jul 7, 2026 · May 20, 2026 · May 20, 2026 · May 20, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/host_env/Cargo.toml b/crates/host_env/Cargo.toml
@@ -27,6 +27,16 @@ rustix = { workspace = true }
 [target.'cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))'.dependencies]
 num_cpus = "1.17.0"
 
+[target.'cfg(not(any(target_os = "ios", target_os = "android", target_os = "windows", target_arch = "wasm32", target_os = "redox")))'.dependencies]
+mac_address = { workspace = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+dns-lookup = { workspace = true }
+gethostname = { workspace = true }
+rustyline = { workspace = true }
+socket2 = { workspace = true, features = ["all"] }
+which = { workspace = true }
+
 [target.'cfg(all(unix, not(target_os = "ios"), not(target_os = "redox")))'.dependencies]
 termios = { workspace = true }
 
@@ -37,6 +47,9 @@ libloading = "0.9"
 [target.'cfg(all(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "android"), not(any(target_env = "musl", target_env = "sgx"))))'.dependencies]
 libffi = { workspace = true, features = ["system"] }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+system-configuration = { workspace = true }
+
 [target.'cfg(windows)'.dependencies]
 junction = { workspace = true }
 schannel = { workspace = true }

diff --git a/crates/host_env/src/faulthandler.rs b/crates/host_env/src/faulthandler.rs
@@ -12,6 +12,10 @@
 use alloc::vec::Vec;
 #[cfg(unix)]
 use parking_lot::Mutex;
+
+#[cfg(unix)]
+pub use libc::{SA_NODEFER, c_int};
+pub use libc::{SIGFPE, SIGSEGV};
 #[cfg(windows)]
 use windows_sys::Win32::System::{
     Diagnostics::Debug::{

diff --git a/crates/host_env/src/fcntl.rs b/crates/host_env/src/fcntl.rs
@@ -5,6 +5,32 @@ use std::os::fd::BorrowedFd;
 
 use crate::os::CheckLibcResult;
 
+pub use libc::{F_GETFD, F_GETFL, F_SETFD, F_SETFL, FD_CLOEXEC};
+
+#[cfg(not(target_os = "wasi"))]
+pub use libc::{F_DUPFD, F_DUPFD_CLOEXEC, F_GETLK, F_SETLK, F_SETLKW};
+
+#[cfg(not(any(target_os = "wasi", target_os = "redox")))]
+pub use libc::{F_GETOWN, F_RDLCK, F_SETOWN, F_UNLCK, F_WRLCK, LOCK_EX, LOCK_NB, LOCK_SH, LOCK_UN};
+
+#[cfg(target_vendor = "apple")]
+pub use libc::{F_FULLFSYNC, F_NOCACHE};
+
+#[cfg(target_os = "freebsd")]
+pub use libc::{F_DUP2FD, F_DUP2FD_CLOEXEC};
+
+#[cfg(any(target_os = "android", target_os = "linux"))]
+pub use libc::{F_OFD_GETLK, F_OFD_SETLK, F_OFD_SETLKW};
+
+#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+pub use libc::{
+    F_ADD_SEALS, F_GET_SEALS, F_GETLEASE, F_GETPIPE_SZ, F_NOTIFY, F_SEAL_GROW, F_SEAL_SEAL,
+    F_SEAL_SHRINK, F_SEAL_WRITE, F_SETLEASE, F_SETPIPE_SZ,
+};
+
+#[cfg(any(target_os = "dragonfly", target_os = "netbsd", target_vendor = "apple"))]
+pub use libc::F_GETPATH;
+
 pub fn normalize_ioctl_request(request: i64) -> libc::c_ulong {
     (request as u32) as libc::c_ulong
 }

diff --git a/crates/host_env/src/fileutils.rs b/crates/host_env/src/fileutils.rs
@@ -442,10 +442,22 @@ pub mod windows {
     }
 }
 
+/// C `FILE *` handle as returned by [`fopen`] and consumed by [`fclose`].
+pub type CFile = libc::FILE;
+
+/// Close a file opened with [`fopen`].
+///
+/// # Safety
+/// `fp` must be a non-null pointer returned by [`fopen`] and must not have been
+/// closed already.
+pub unsafe fn fclose(fp: *mut CFile) -> core::ffi::c_int {
+    unsafe { libc::fclose(fp) }
+}
+
 // _Py_fopen_obj in cpython (Python/fileutils.c:1757-1835)
 // Open a file using std::fs::File and convert to FILE*
 // Automatically handles path encoding and EINTR retries
-pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut libc::FILE> {
+pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut CFile> {
     use alloc::ffi::CString;
     use std::fs::File;
 

diff --git a/crates/host_env/src/fs.rs b/crates/host_env/src/fs.rs
@@ -1,7 +1,7 @@
 use std::{
     fs::{self, File, Metadata, ReadDir},
     io,
-    path::Path,
+    path::{Path, PathBuf},
 };
 
 pub fn open(path: impl AsRef<Path>) -> io::Result<File> {
@@ -44,10 +44,16 @@ pub fn open_write(path: impl AsRef<Path>) -> io::Result<File> {
     fs::OpenOptions::new().write(true).open(path)
 }
 
-pub fn canonicalize(path: impl AsRef<Path>) -> io::Result<std::path::PathBuf> {
+pub fn canonicalize(path: impl AsRef<Path>) -> io::Result<PathBuf> {
     fs::canonicalize(path)
 }
 
+/// Resolve `binary_name` to an absolute path by searching `PATH` (and `PATHEXT` on Windows).
+#[cfg(not(target_arch = "wasm32"))]
+pub fn which<T: AsRef<std::ffi::OsStr>>(binary_name: T) -> Option<PathBuf> {
+    ::which::which(binary_name).ok()
+}
+
 #[cfg(windows)]
 pub fn open_write_with_custom_flags(path: impl AsRef<Path>, flags: u32) -> io::Result<File> {
     use std::os::windows::fs::OpenOptionsExt;

diff --git a/crates/host_env/src/grp.rs b/crates/host_env/src/grp.rs
@@ -1,5 +1,7 @@
 use std::io;
 
+pub use libc::gid_t;
+
 pub struct Group {
     pub name: String,
     pub passwd: String,

diff --git a/crates/host_env/src/lib.rs b/crates/host_env/src/lib.rs
@@ -30,6 +30,7 @@ pub mod fileutils;
 pub mod fs;
 #[cfg(any(unix, windows))]
 pub mod locale;
+pub mod readline;
-pub mod readline;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod readline;
-pub mod readline;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod readline;
 
 #[cfg(windows)]
 pub mod windows;
@@ -67,6 +68,10 @@ pub mod time;
 
 #[cfg(windows)]
 pub mod cert_store;
+#[cfg(target_os = "macos")]
+pub mod system_configuration {
+    pub use ::system_configuration::*;
+}
 #[cfg(any(unix, windows))]
 pub mod faulthandler;
 #[cfg(any(unix, windows))]

diff --git a/crates/host_env/src/locale.rs b/crates/host_env/src/locale.rs
@@ -1,6 +1,23 @@
 use alloc::vec::Vec;
 use core::{ffi::CStr, ptr};
 
+pub use libc::{LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME};
+
+#[cfg(all(unix, not(any(target_os = "ios", target_os = "redox"))))]
+pub use libc::LC_MESSAGES;
+
+#[cfg(all(
+    unix,
+    not(any(target_os = "ios", target_os = "android", target_os = "redox"))
+))]
+pub use libc::{
+    ABDAY_1, ABDAY_2, ABDAY_3, ABDAY_4, ABDAY_5, ABDAY_6, ABDAY_7, ABMON_1, ABMON_2, ABMON_3,
+    ABMON_4, ABMON_5, ABMON_6, ABMON_7, ABMON_8, ABMON_9, ABMON_10, ABMON_11, ABMON_12, ALT_DIGITS,
+    AM_STR, CODESET, CRNCYSTR, D_FMT, D_T_FMT, DAY_1, DAY_2, DAY_3, DAY_4, DAY_5, DAY_6, DAY_7,
+    ERA, ERA_D_FMT, ERA_D_T_FMT, ERA_T_FMT, MON_1, MON_2, MON_3, MON_4, MON_5, MON_6, MON_7, MON_8,
+    MON_9, MON_10, MON_11, MON_12, NOEXPR, PM_STR, RADIXCHAR, T_FMT, T_FMT_AMPM, THOUSEP, YESEXPR,
+};
+
 #[cfg(windows)]
 #[repr(C)]
 struct RawLconv {

diff --git a/crates/host_env/src/mmap.rs b/crates/host_env/src/mmap.rs
@@ -59,7 +59,6 @@ pub use libc::MAP_STACK;
 #[cfg(target_os = "freebsd")]
 pub use libc::{MADV_AUTOSYNC, MADV_CORE, MADV_NOCORE, MADV_NOSYNC, MADV_PROTECT};
 
-#[cfg(windows)]
 pub use libc::EOVERFLOW;
 
 #[cfg(windows)]

diff --git a/crates/host_env/src/multiprocessing.rs b/crates/host_env/src/multiprocessing.rs
@@ -13,7 +13,7 @@ use alloc::ffi::CString;
 use std::io;
 
 #[cfg(unix)]
-use libc::sem_t;
+pub use libc::{sem_t, timespec};
 #[cfg(unix)]
 use nix::errno::Errno;
 

diff --git a/crates/host_env/src/posix.rs b/crates/host_env/src/posix.rs
@@ -12,6 +12,8 @@ use std::path::Path;
 
 use crate::crt_fd;
 
+pub use libc::{c_char, pid_t};
+
 pub struct UnameInfo {
     pub sysname: String,
     pub nodename: String,

diff --git a/crates/vm/src/readline.rs → crates/host_env/src/readline.rs b/crates/vm/src/readline.rs → crates/host_env/src/readline.rs
@@ -106,34 +106,18 @@ pub mod rustyline_readline {
         }
 
         pub fn load_history(&mut self, path: &Path) -> OtherResult<()> {
-            #[cfg(not(feature = "host_env"))]
-            {
-                let _ = path;
-                Err(io::Error::other("history requires the `host_env` feature").into())
-            }
-            #[cfg(feature = "host_env")]
-            {
-                self.repl.load_history(path)?;
-                Ok(())
-            }
+            self.repl.load_history(path)?;
+            Ok(())
         }
 
         pub fn save_history(&mut self, path: &Path) -> OtherResult<()> {
-            #[cfg(not(feature = "host_env"))]
-            {
-                let _ = path;
-                Err(io::Error::other("history requires the `host_env` feature").into())
-            }
-            #[cfg(feature = "host_env")]
+            if !path.exists()
+                && let Some(parent) = path.parent()
             {
-                if !path.exists()
-                    && let Some(parent) = path.parent()
-                {
-                    crate::host_env::fs::create_dir_all(parent)?;
-                }
-                self.repl.save_history(path)?;
-                Ok(())
+                crate::fs::create_dir_all(parent)?;
             }
+            self.repl.save_history(path)?;
+            Ok(())
         }
 
         pub fn add_history_entry(&mut self, entry: &str) -> OtherResult<()> {

diff --git a/crates/host_env/src/resource.rs b/crates/host_env/src/resource.rs
@@ -2,6 +2,40 @@ use std::io;
 
 use crate::os::CheckLibcResult;
 
+pub use libc::{
+    RLIM_INFINITY, RLIMIT_AS, RLIMIT_CORE, RLIMIT_CPU, RLIMIT_DATA, RLIMIT_FSIZE, RLIMIT_MEMLOCK,
+    RLIMIT_NOFILE, RLIMIT_NPROC, RLIMIT_RSS, RLIMIT_STACK, c_long, rlim_t, rlimit, timeval,
+};
+
+#[cfg(target_os = "android")]
+pub use libc::RLIM_NLIMITS;
+
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "emscripten"))]
+pub use libc::{RLIMIT_MSGQUEUE, RLIMIT_NICE, RLIMIT_RTPRIO, RLIMIT_SIGPENDING};
+
+#[cfg(target_os = "linux")]
+pub use libc::RLIMIT_RTTIME;
+
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "solaris",
+    target_os = "illumos"
+))]
+pub use libc::RLIMIT_SBSIZE;
+
+#[cfg(any(target_os = "freebsd", target_os = "solaris", target_os = "illumos"))]
+pub use libc::{RLIMIT_NPTS, RLIMIT_SWAP};
+
+#[cfg(any(target_os = "solaris", target_os = "illumos"))]
+pub use libc::RLIMIT_VMEM;
+
+#[cfg(any(target_os = "linux", target_os = "emscripten", target_os = "freebsd"))]
+pub use libc::RUSAGE_THREAD;
+
+#[cfg(not(any(target_os = "windows", target_os = "redox")))]
+pub use libc::{RUSAGE_CHILDREN, RUSAGE_SELF};
+
 #[derive(Debug, Clone, Copy)]
 pub struct RUsage {
     pub ru_utime: libc::timeval,

diff --git a/crates/host_env/src/select.rs b/crates/host_env/src/select.rs
@@ -1,6 +1,16 @@
 use core::mem::MaybeUninit;
 use std::io;
 
+#[cfg(unix)]
+pub use libc::{EINTR, FD_SETSIZE, POLLERR, POLLHUP, POLLIN, POLLNVAL, POLLOUT, POLLPRI};
+
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "redox"))]
+pub use libc::{
+    EPOLL_CLOEXEC, EPOLLERR, EPOLLET, EPOLLEXCLUSIVE, EPOLLHUP, EPOLLIN, EPOLLMSG, EPOLLONESHOT,
+    EPOLLOUT, EPOLLPRI, EPOLLRDBAND, EPOLLRDHUP, EPOLLRDNORM, EPOLLWAKEUP, EPOLLWRBAND,
+    EPOLLWRNORM,
+};
+
 #[cfg(unix)]
 pub mod platform {
     pub use libc::pollfd;

diff --git a/crates/host_env/src/shm.rs b/crates/host_env/src/shm.rs
@@ -3,6 +3,8 @@ use std::io;
 
 use crate::os::CheckLibcResult;
 
+pub use libc::mode_t;
+
 pub fn shm_open(name: &CStr, flags: libc::c_int, mode: libc::c_uint) -> io::Result<libc::c_int> {
     #[cfg(target_os = "freebsd")]
     let mode = mode.try_into().unwrap();

diff --git a/crates/host_env/src/socket.rs b/crates/host_env/src/socket.rs
@@ -7,6 +7,43 @@ use std::os::fd::AsRawFd;
 #[cfg(unix)]
 use std::{io, os::fd::BorrowedFd};
 
+/// Returns the system's hostname.
+#[cfg(not(target_arch = "wasm32"))]
+pub fn hostname() -> std::ffi::OsString {
+    gethostname::gethostname()
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use ::dns_lookup as dns;
+#[cfg(not(target_arch = "wasm32"))]
+pub use ::socket2 as raw;
+
+/// Returns the first non-loopback MAC address as 6 bytes, or `None` when no
+/// MAC address is available or the lookup fails.
+#[cfg(not(any(
+    target_os = "ios",
+    target_os = "android",
+    target_os = "windows",
+    target_arch = "wasm32",
+    target_os = "redox"
+)))]
+pub fn mac_address() -> Option<[u8; 6]> {
+    mac_address::get_mac_address()
+        .ok()
+        .flatten()
+        .map(|m| m.bytes())
+}
+
+#[cfg(unix)]
+pub use libc::{AF_UNIX, SOCK_STREAM, sa_family_t, sockaddr_storage, socklen_t};
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub use libc::{AF_ALG, AF_CAN};
+
+// bionic (Android) does not define the CAN/ALG sockaddr structs.
+#[cfg(target_os = "linux")]
+pub use libc::{sockaddr_alg, sockaddr_can};
+
 #[cfg(all(unix, not(target_os = "redox")))]
 pub fn sethostname(hostname: &str) -> io::Result<()> {
     nix::unistd::sethostname(hostname).map_err(io::Error::from)

diff --git a/crates/host_env/src/syslog.rs b/crates/host_env/src/syslog.rs
@@ -3,6 +3,16 @@ use core::ffi::CStr;
 use parking_lot::RwLock;
 use std::{os::raw::c_char, sync::OnceLock};
 
+pub use libc::{
+    LOG_ALERT, LOG_AUTH, LOG_CONS, LOG_CRIT, LOG_DAEMON, LOG_DEBUG, LOG_EMERG, LOG_ERR, LOG_INFO,
+    LOG_KERN, LOG_LOCAL0, LOG_LOCAL1, LOG_LOCAL2, LOG_LOCAL3, LOG_LOCAL4, LOG_LOCAL5, LOG_LOCAL6,
+    LOG_LOCAL7, LOG_LPR, LOG_MAIL, LOG_NDELAY, LOG_NEWS, LOG_NOTICE, LOG_NOWAIT, LOG_ODELAY,
+    LOG_PID, LOG_SYSLOG, LOG_USER, LOG_UUCP, LOG_WARNING,
+};
+
+#[cfg(not(target_os = "redox"))]
+pub use libc::{LOG_AUTHPRIV, LOG_CRON, LOG_PERROR};
+
 #[derive(Debug)]
 enum GlobalIdent {
     Explicit(Box<CStr>),