userland: shared DNS resolver + shell stderr fd wiring

Kernel syscall_resolve now maps each DnsResolveError variant to a
distinct errno (EINVAL/ENETUNREACH/EAGAIN/EHOSTUNREACH) instead of
flattening everything to EHOSTUNREACH, and slibc's SyscallError
gains matching ENETUNREACH/EHOSTUNREACH constants.

A new userland::net module is the single canonical hostname path:
resolve_host returns Result<Ipv4Addr, ResolveError> with a Display
impl per variant.  The low-level syscall::net::resolve wrapper is
now pub(crate) so a new tool physically cannot bypass the shared
helper.  curl, ping, nc, and the shell's cmd_resolve builtin all
route through resolve_host — one place for IPv4 literal parsing,
one place for errno translation, one user-facing message format.

Shell stdio wiring: previously only fd 0 was dup'd onto the PTY
slave, so fd 1/2 in the shell (and every forked child) still
pointed at the default console TTY inherited from init — i.e. the
kernel serial port.  That made curl/ping stderr invisible in the
shell window.  Dup the slave onto fd 0/1/2 so children's output
flows through the ldisc to the PTY master and lands in the shell
display via forward_compositor_keyboard, plus drain the master one
more time after waitpid in both the capture and pipeline paths so
bytes written right before a child exits aren't stranded.

2352/2352 itests pass.

Author: nil0ft

core/src/syscall/net_handlers.rs

@@ -557,7 +557,6 @@ define_syscall!(syscall_resolve(ctx, args) requires(let process_id) {
         return ctx.err_with(ERRNO_EINVAL);
     }
 
-    // Copy hostname from user memory
     let mut hostname_buf = [0u8; 253];
     let user_hostname = try_or_err!(ctx, slopos_mm::user_ptr::UserBytes::try_new(args.arg0, hostname_len));
     let copied = try_or_err!(ctx, slopos_mm::user_copy::copy_bytes_from_user(user_hostname, &mut hostname_buf[..hostname_len]));
@@ -567,10 +566,14 @@ define_syscall!(syscall_resolve(ctx, args) requires(let process_id) {
 
     let result_addr = match dns::dns_resolve(&hostname_buf[..hostname_len]) {
         Ok(addr) => addr,
-        Err(_) => return ctx.err_with(ERRNO_EHOSTUNREACH),
+        Err(dns::DnsResolveError::InvalidHostname) => return ctx.err_with(ERRNO_EINVAL),
+        Err(dns::DnsResolveError::NoDnsServer) => return ctx.err_with(ERRNO_ENETUNREACH),
+        Err(dns::DnsResolveError::Timeout | dns::DnsResolveError::TransmitFailed) => {
+            return ctx.err_with(ERRNO_EAGAIN);
+        }
+        Err(dns::DnsResolveError::ParseFailed) => return ctx.err_with(ERRNO_EHOSTUNREACH),
     };
 
-    // Copy result to user memory
     let user_result = try_or_err!(ctx, slopos_mm::user_ptr::UserBytes::try_new(args.arg2, 4));
     try_or_err!(ctx, slopos_mm::user_copy::copy_bytes_to_user(user_result, &result_addr));
 

scripts/patch_std.sh

@@ -18,21 +18,11 @@ if [ ! -d "$STD_SYS" ]; then
     exit 1
 fi
 
-# Note: no outer idempotency marker.
-#
-# An earlier version of this script used a `.slopos_patched` marker file
-# to short-circuit re-runs.  That was unsafe by design — when new patch
-# sections were added to the script, the outer gate prevented them from
-# ever running against sysroots that had been marked by an older script
-# version, leaving the std library silently half-patched (the `net`
-# section's 2026-04-05 addition is an example that went unnoticed for
-# weeks because nothing exercises `std::net::ToSocketAddrs` at build
-# time).
-#
-# Every patch section below is individually idempotent via its own
-# `grep -q 'target_os = "slopos"'` guard, so re-running the script on
-# an already-patched sysroot is a no-op (~50 fast sed passes).  We
-# remove the stale marker if we see one so old installations recover.
+# Don't add an outer idempotency marker — a stale marker would prevent
+# new patch sections from applying to already-patched sysroots.  Every
+# section below is individually idempotent via its own `grep -q` guard,
+# and the post-patch verification at the bottom catches drift.  Strip
+# any legacy marker so old installations recover.
 MARKER="$STD_SYS/.slopos_patched"
 if [ -f "$MARKER" ]; then
     rm -f "$MARKER"
@@ -397,14 +387,9 @@ if ! grep -q 'target_os = "slopos"' "$STD_OS/mod.rs" 2>/dev/null; then
     patch_os_fd
 fi
 
-# 4. Post-patch verification
-#
-# Catches the "script updated, sysroot stale" drift that used to produce
-# a silently half-patched std library (see comment at the top of this
-# file).  Each entry below is a (label, file, anchor) triple: after all
-# patches run, every anchor MUST be present in its file or we bail out.
-# Adding a new patch section means adding a matching verification row.
-
+# Post-patch verification.  Each new patch section above needs a
+# matching check_patched row so drift fails the build loudly instead
+# of leaving the sysroot half-patched.
 failed=0
 check_patched() {
     local label="$1"
@@ -440,7 +425,6 @@ check_patched "sync/rwlock/mod.rs"             "$STD_SYS/sync/rwlock/mod.rs"
 check_patched "sync/once/mod.rs"               "$STD_SYS/sync/once/mod.rs"                  'target_os = "slopos"'
 check_patched "sync/thread_parking/mod.rs"     "$STD_SYS/sync/thread_parking/mod.rs"        'target_os = "slopos"'
 
-# Net routing — this is the one that silently broke for weeks.
 check_patched "net/connection/mod.rs"          "$STD_SYS/net/connection/mod.rs"             'target_os = "slopos"'
 check_patched "net/connection/socket/mod.rs"   "$STD_SYS/net/connection/socket/mod.rs"      'target_os = "slopos"'
 check_patched "net/connection/socket/slopos.rs" "$STD_SYS/net/connection/socket/slopos.rs"  'SlopOS platform implementation for `std::net`'

slibc/src/error.rs

@@ -34,8 +34,10 @@ impl SyscallError {
     pub const EROFS: Self = Self(30);
     pub const EPIPE: Self = Self(32);
     pub const ENOSYS: Self = Self(38);
+    pub const ENETUNREACH: Self = Self(101);
     pub const ETIMEDOUT: Self = Self(110);
     pub const ECONNREFUSED: Self = Self(111);
+    pub const EHOSTUNREACH: Self = Self(113);
 
     #[inline]
     pub const fn from_errno(errno: i32) -> Self {
@@ -77,8 +79,10 @@ impl SyscallError {
             30 => "Read-only file system",
             32 => "Broken pipe",
             38 => "Function not implemented",
+            101 => "Network is unreachable",
             110 => "Connection timed out",
             111 => "Connection refused",
+            113 => "No route to host",
             _ => "Unknown error",
         }
     }

userland/src/apps/curl.rs

@@ -1,7 +1,8 @@
 use std::io::{self, Read, Write};
-use std::net::{Ipv4Addr, Shutdown, SocketAddrV4, TcpStream, ToSocketAddrs};
+use std::net::{Ipv4Addr, Shutdown, SocketAddrV4, TcpStream};
 use std::time::Duration;
 
+use crate::net::ResolveError;
 use crate::syscall::process;
 
 const MAX_HEADERS: usize = 8;
@@ -68,7 +69,7 @@ enum CurlError {
     InvalidHost,
     InvalidPort,
     InvalidPath,
-    ResolveFailed,
+    Resolve(ResolveError),
     SocketFailed,
     ConnectFailed,
     SendFailed,
@@ -86,6 +87,10 @@ fn print_usage() {
 }
 
 fn print_error(err: CurlError) {
+    if let CurlError::Resolve(reason) = err {
+        eprintln!("curl: {}", reason);
+        return;
+    }
     let msg = match err {
         CurlError::Usage => "curl: invalid usage",
         CurlError::InvalidFlag => "curl: invalid flag",
@@ -97,7 +102,7 @@ fn print_error(err: CurlError) {
         CurlError::InvalidHost => "curl: invalid host",
         CurlError::InvalidPort => "curl: invalid port",
         CurlError::InvalidPath => "curl: invalid path",
-        CurlError::ResolveFailed => "curl: hostname resolution failed",
+        CurlError::Resolve(_) => unreachable!("handled above"),
         CurlError::SocketFailed => "curl: socket creation failed",
         CurlError::ConnectFailed => "curl: connect failed",
         CurlError::SendFailed => "curl: send failed",
@@ -303,31 +308,13 @@ fn parse_url(url: &[u8]) -> Result<ParsedUrl, CurlError> {
     })
 }
 
-fn parse_ipv4(host: &[u8]) -> Option<[u8; 4]> {
-    let host_str = core::str::from_utf8(host).ok()?;
-    Some(host_str.parse::<Ipv4Addr>().ok()?.octets())
-}
-
 fn resolve_host(parsed: &mut ParsedUrl) -> Result<(), CurlError> {
     let host = &parsed.host[..parsed.host_len];
-    if let Some(ip) = parse_ipv4(host) {
-        parsed.ip = ip;
-        return Ok(());
-    }
-
-    let host_str = core::str::from_utf8(host).map_err(|_| CurlError::ResolveFailed)?;
-    let addr = (host_str, 0u16)
-        .to_socket_addrs()
-        .ok()
-        .and_then(|mut addrs| addrs.find(|a| a.is_ipv4()))
-        .ok_or(CurlError::ResolveFailed)?;
-    match addr {
-        std::net::SocketAddr::V4(v4) => {
-            parsed.ip = v4.ip().octets();
-            Ok(())
-        }
-        _ => Err(CurlError::ResolveFailed),
-    }
+    let host_str = core::str::from_utf8(host)
+        .map_err(|_| CurlError::Resolve(ResolveError::InvalidHostname))?;
+    let addr = crate::net::resolve_host(host_str).map_err(CurlError::Resolve)?;
+    parsed.ip = addr.octets();
+    Ok(())
 }
 
 fn choose_method(config: &CurlConfig) -> &str {

userland/src/apps/nc/mod.rs

@@ -46,7 +46,7 @@ enum NcError {
     MissingHost,
     MissingPort,
     InvalidPort,
-    ResolveFailed,
+    Resolve(crate::net::ResolveError),
     UnknownFlag,
 }
 
@@ -178,11 +178,15 @@ fn print_usage() {
 }
 
 fn print_error(err: NcError) {
+    if let NcError::Resolve(reason) = err {
+        eprintln!("nc: {}", reason);
+        return;
+    }
     let msg = match err {
         NcError::MissingHost => "nc: missing host",
         NcError::MissingPort => "nc: missing port",
         NcError::InvalidPort => "nc: invalid port number",
-        NcError::ResolveFailed => "nc: cannot resolve hostname",
+        NcError::Resolve(_) => unreachable!("handled above"),
         NcError::UnknownFlag => "nc: unknown flag",
     };
     eprintln!("{msg}");
@@ -196,23 +200,10 @@ fn parse_port(s: &str) -> Option<u16> {
     Some(parsed)
 }
 
-/// Parse a dotted-quad IPv4 address (e.g. "10.0.2.2").
-fn parse_ipv4(s: &str) -> Option<[u8; 4]> {
-    Some(s.parse::<Ipv4Addr>().ok()?.octets())
-}
-
-/// Resolve a host argument: try dotted-quad first, then kernel DNS.
 fn resolve_host(host: &[u8]) -> Result<[u8; 4], NcError> {
-    if let Ok(host_str) = core::str::from_utf8(host)
-        && let Some(ip) = parse_ipv4(host_str)
-    {
-        return Ok(ip);
-    }
-    // Try kernel DNS resolution
-    match crate::syscall::net::resolve(host) {
-        Some(ip) => Ok(ip),
-        _ => Err(NcError::ResolveFailed),
-    }
+    let host_str = core::str::from_utf8(host)
+        .map_err(|_| NcError::Resolve(crate::net::ResolveError::InvalidHostname))?;
+    crate::net::resolve_host_raw(host_str).map_err(NcError::Resolve)
 }
 
 /// Core argument parsing logic operating on clean Rust slices.
@@ -437,27 +428,6 @@ mod tests {
         assert_eq!(parse_port("99999"), None);
     }
 
-    #[test]
-    fn test_parse_ipv4_valid() {
-        assert_eq!(parse_ipv4("10.0.2.2"), Some([10, 0, 2, 2]));
-        assert_eq!(parse_ipv4("192.168.1.1"), Some([192, 168, 1, 1]));
-        assert_eq!(parse_ipv4("0.0.0.0"), Some([0, 0, 0, 0]));
-        assert_eq!(parse_ipv4("255.255.255.255"), Some([255, 255, 255, 255]));
-        assert_eq!(parse_ipv4("127.0.0.1"), Some([127, 0, 0, 1]));
-    }
-
-    #[test]
-    fn test_parse_ipv4_invalid() {
-        assert_eq!(parse_ipv4(""), None);
-        assert_eq!(parse_ipv4("10.0.2"), None);
-        assert_eq!(parse_ipv4("10.0.2.2.1"), None);
-        assert_eq!(parse_ipv4("256.0.0.1"), None);
-        assert_eq!(parse_ipv4("10.0.2.abc"), None);
-        assert_eq!(parse_ipv4("..."), None);
-        assert_eq!(parse_ipv4("1.2.3."), None);
-        assert_eq!(parse_ipv4(".1.2.3"), None);
-    }
-
     // -----------------------------------------------------------------------
     // Argument parsing tests
     // -----------------------------------------------------------------------

userland/src/apps/ping.rs

@@ -36,17 +36,6 @@ fn print_usage() {
     println!("usage: ping [-c count] [-i interval] [-s size] [-W timeout] [-v] <host>");
 }
 
-fn parse_ipv4(host: &str) -> Option<[u8; 4]> {
-    Some(host.parse::<Ipv4Addr>().ok()?.octets())
-}
-
-fn resolve_host(host: &str) -> Option<[u8; 4]> {
-    if let Some(ip) = parse_ipv4(host) {
-        return Some(ip);
-    }
-    net::resolve(host.as_bytes())
-}
-
 fn parse_u32_arg(value: &str) -> Option<u32> {
     value.parse::<u32>().ok()
 }
@@ -271,11 +260,12 @@ pub fn ping_main(args: Vec<String>) -> ! {
         }
     };
 
-    let target_ip = if let Some(ip) = resolve_host(&config.host) {
-        ip
-    } else {
-        eprintln!("ping: cannot resolve {}", config.host);
-        std::process::exit(2);
+    let target_ip = match crate::net::resolve_host_raw(&config.host) {
+        Ok(ip) => ip,
+        Err(err) => {
+            eprintln!("ping: {}: {}", config.host, err);
+            std::process::exit(2);
+        }
     };
 
     let fd = match net::socket(

userland/src/apps/shell/builtins/system.rs

@@ -338,48 +338,21 @@ pub fn cmd_resolve(argc: i32, argv: &[&[u8]]) -> i32 {
         return 1;
     }
 
-    let hostname = argv[1];
-
-    let host_str = match core::str::from_utf8(hostname) {
+    let host_str = match core::str::from_utf8(argv[1]) {
         Ok(s) => s,
         Err(_) => {
             shell_write(b"resolve: invalid hostname\n");
             return 1;
         }
     };
 
-    // Surface the real `io::Error` from `to_socket_addrs` — the
-    // previous implementation discarded it with `.ok()`, which
-    // meant a "operation not supported" PAL error from a
-    // half-patched std sysroot looked identical to a real "name not
-    // found" DNS failure, and the user had no way to tell from
-    // the shell alone.
-    use std::net::ToSocketAddrs;
-    let iter = match (host_str, 0u16).to_socket_addrs() {
-        Ok(it) => it,
-        Err(err) => {
-            shell_write(format!("resolve: {}: {}\n", host_str, err).as_bytes());
-            return 1;
-        }
-    };
-
-    let v4 = iter
-        .filter_map(|a| match a {
-            std::net::SocketAddr::V4(v4) => Some(v4),
-            _ => None,
-        })
-        .next();
-
-    match v4 {
-        Some(v4) => {
-            let o = v4.ip().octets();
-            shell_write(
-                format!("{}: -> {}.{}.{}.{}\n", host_str, o[0], o[1], o[2], o[3]).as_bytes(),
-            );
+    match crate::net::resolve_host(host_str) {
+        Ok(addr) => {
+            shell_write(format!("{}: -> {}\n", host_str, addr).as_bytes());
             0
         }
-        None => {
-            shell_write(format!("resolve: {}: no IPv4 address returned\n", host_str).as_bytes());
+        Err(err) => {
+            shell_write(format!("resolve: {}: {}\n", host_str, err).as_bytes());
             1
         }
     }

userland/src/apps/shell/exec.rs

@@ -570,6 +570,7 @@ fn execute_registry_spawn(
                         Err(_) => break,
                     }
                 }
+                forward_compositor_keyboard();
                 exit_status = st;
                 break;
             }
@@ -1012,7 +1013,6 @@ fn execute_pipeline(pipeline: &ParsedPipeline, tokens: &ParsedTokens) -> i32 {
                 break;
             }
         }
-        // Final drain after children have exited.
         loop {
             match fs::read_slice(capture_fd, &mut buf) {
                 Ok(0) => break,
@@ -1022,6 +1022,7 @@ fn execute_pipeline(pipeline: &ParsedPipeline, tokens: &ParsedTokens) -> i32 {
                 Err(_) => break,
             }
         }
+        forward_compositor_keyboard();
         let _ = fs::close_fd_raw(capture_fd);
         leave_foreground();
         return status;

userland/src/apps/shell/mod.rs

@@ -297,7 +297,8 @@ fn shell_interactive_main() {
             if let Ok(slave_fd) = fs::ioctl_tiocgptpeer(master_fd.raw()) {
                 set_shell_pty_master_fd(master_fd.into_raw());
                 let _ = fs::dup2(slave_fd.raw(), 0);
-                // slave_fd dropped here, auto-closed
+                let _ = fs::dup2(slave_fd.raw(), 1);
+                let _ = fs::dup2(slave_fd.raw(), 2);
             }
         }
     }

userland/src/lib.rs

@@ -2,6 +2,7 @@
 
 pub mod apps;
 pub mod gfx;
+pub mod net;
 pub mod program_registry;
 pub mod readiness;
 pub mod runtime;