std/sys/net/xous: read NetError code from byte 4 in recv/accept paths

`respond_with_error` in xous-core's `services/net/src/std_glue.rs`
writes the `NetError` code at byte 4 of the 8-byte response
buffer. The send path in `tcpstream.rs::write` correctly reads
`send_request.raw[4]`. The recv-side decoders, however, read
`result[1]` / `raw[1]`, which under the historical
`[1, 1, 1, 1, code, 0, 0, 0]` layout is always `1` — so
`ErrorKind::TimedOut` and `ErrorKind::WouldBlock` were
unreachable from the recv side.

Three files affected, identical pattern:

  - `tcpstream.rs::read_or_peek` (recv decode)
  - `udp.rs` (UDP recv decode)
  - `tcplistener.rs` (accept decode)

Each `result[1]` / `raw[1]` becomes `result[4]` / `raw[4]`,
matching the send path. Behavior is unchanged for any kernel
that respects the existing 8-byte error layout.

A complementary kernel-side change in betrusted-io/xous-core
(betrusted-io/xous-core#877) mirrors
the code at byte 1 too, so existing toolchain versions also
see the right value immediately. The two changes are non-
conflicting.

Co-authored-by: Nia <nia-e@haecceity.cc>

Author: tunnell

library/std/src/sys/net/connection/xous/tcplistener.rs

@@ -129,12 +129,13 @@ impl TcpListener {
             0,
         ) {
             if receive_request.raw[0] != 0 {
-                // error case
-                if receive_request.raw[1] == NetError::TimedOut as u8 {
+                // Error case — code lives at byte 4 (where the send path
+                // also reads it). Byte 1 is part of the marker header.
+                if receive_request.raw[4] == NetError::TimedOut as u8 {
                     return Err(io::const_error!(io::ErrorKind::TimedOut, "accept timed out"));
-                } else if receive_request.raw[1] == NetError::WouldBlock as u8 {
+                } else if receive_request.raw[4] == NetError::WouldBlock as u8 {
                     return Err(io::const_error!(io::ErrorKind::WouldBlock, "accept would block"));
-                } else if receive_request.raw[1] == NetError::LibraryError as u8 {
+                } else if receive_request.raw[4] == NetError::LibraryError as u8 {
                     return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 } else {
                     return Err(io::const_error!(io::ErrorKind::Other, "library error"));

library/std/src/sys/net/connection/xous/tcpstream.rs

@@ -213,11 +213,14 @@ impl TcpStream {
         } else {
             let result = receive_request.raw;
             if result[0] != 0 {
-                if result[1] == 8 {
+                // The error code lives at byte 4 of the kernel's response buffer
+                // (matches the byte the send path reads in `write` below). Byte 1
+                // is part of the marker header, not the code.
+                if result[4] == 8 {
                     // timed out
                     return Err(io::const_error!(io::ErrorKind::TimedOut, "timeout"));
                 }
-                if result[1] == 9 {
+                if result[4] == 9 {
                     // would block
                     return Err(io::const_error!(io::ErrorKind::WouldBlock, "would block"));
                 }

library/std/src/sys/net/connection/xous/udp.rs

@@ -145,12 +145,13 @@ impl UdpSocket {
             0,
         ) {
             if receive_request.raw[0] != 0 {
-                // error case
-                if receive_request.raw[1] == NetError::TimedOut as u8 {
+                // Error case — code lives at byte 4 (where `send_message`
+                // also reads it). Byte 1 is part of the marker header.
+                if receive_request.raw[4] == NetError::TimedOut as u8 {
                     return Err(io::const_error!(io::ErrorKind::TimedOut, "recv timed out"));
-                } else if receive_request.raw[1] == NetError::WouldBlock as u8 {
+                } else if receive_request.raw[4] == NetError::WouldBlock as u8 {
                     return Err(io::const_error!(io::ErrorKind::WouldBlock, "recv would block"));
-                } else if receive_request.raw[1] == NetError::LibraryError as u8 {
+                } else if receive_request.raw[4] == NetError::LibraryError as u8 {
                     return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 } else {
                     return Err(io::const_error!(io::ErrorKind::Other, "library error"));