tcp reactor transition

Author: eldiablolives

src/zingcore/2.5/Makefile

@@ -69,7 +69,7 @@ OBJ := \
 	$(BUILD)/zi_hopabi25.o \
 	$(BUILD)/zi_telemetry.o
 
-TESTS := test_caps test_async_registry test_zingcore25_api test_problem test_telemetry_jsonl test_sysabi25_min_core test_sysabi25_ctl_caps_list test_sysabi25_file_cap test_sysabi25_tcp_cap test_sysabi25_http_cap test_sysabi25_http_loop_cap test_sysabi25_argv_cap test_sysabi25_env_cap test_sysabi25_hopper_cap test_sysabi25_event_bus_cap test_sysabi25_sys_info_cap test_sysabi25_sys_loop_cap test_bus_rpc_v1 test_hopabi25_basic
+TESTS := test_caps test_async_registry test_zingcore25_api test_problem test_telemetry_jsonl test_sysabi25_min_core test_sysabi25_ctl_caps_list test_sysabi25_file_cap test_sysabi25_tcp_cap test_sysabi25_tcp_loop_connect_cap test_sysabi25_http_cap test_sysabi25_http_loop_cap test_sysabi25_argv_cap test_sysabi25_env_cap test_sysabi25_hopper_cap test_sysabi25_event_bus_cap test_sysabi25_sys_info_cap test_sysabi25_sys_loop_cap test_bus_rpc_v1 test_hopabi25_basic
 
 EXAMPLES := stdio_caps_demo all_caps_demo hopabi_guest_demo
 

src/zingcore/2.5/README.md

@@ -226,6 +226,14 @@ Open semantics:
   - `u32 port` (1..65535)
   - `u32 flags` (reserved; must be 0)
 
+I/O semantics:
+
+- TCP handles use nonblocking sockets.
+- While the connection is still being established, `zi_read`/`zi_write` MAY return `ZI_E_AGAIN`.
+  Guests SHOULD wait via `sys/loop` watching the TCP handle for `writable` readiness, then retry.
+- For data transfer, `zi_read`/`zi_write` return `ZI_E_AGAIN` on would-block; guests SHOULD wait via
+  `sys/loop` watching `readable`/`writable` readiness, then retry.
+
 Sandboxing via `ZI_NET_ALLOW`:
 
 - If `ZI_NET_ALLOW` is unset/empty: only loopback hosts are allowed (`localhost`, `127.0.0.1`, `::1`).

src/zingcore/2.5/zingcore/include/zi_net_tcp25.h

@@ -17,6 +17,11 @@ extern "C" {
 // This cap is opened via zi_cap_open() and yields a stream handle usable with:
 //   zi_read / zi_write / zi_end
 //
+// Sockets are nonblocking:
+// - zi_read/zi_write return ZI_E_AGAIN on would-block.
+// - While connect is still in progress, zi_read/zi_write MAY return ZI_E_AGAIN;
+//   guests should wait for writability via sys/loop and retry.
+//
 // Open params are a packed little-endian struct (20 bytes):
 //   u64 host_ptr  (UTF-8 host bytes, not NUL-terminated)
 //   u32 host_len

src/zingcore/2.5/zingcore/src/zi_net_tcp25.c

@@ -19,6 +19,7 @@
 
 typedef struct {
   int fd;
+  int connecting;
 } zi_tcp_stream;
 
 static void set_nonblocking_best_effort(int fd) {
@@ -36,6 +37,43 @@ static int tcp_get_fd(void *ctx, int *out_fd) {
   return 1;
 }
 
+static int32_t map_errno_to_zi(int e);
+
+static int32_t tcp_ensure_connected(zi_tcp_stream *s) {
+  if (!s) return ZI_E_INTERNAL;
+  if (!s->connecting) return 0;
+  if (s->fd < 0) return ZI_E_CLOSED;
+
+  int so_err = 0;
+  socklen_t len = (socklen_t)sizeof(so_err);
+  if (getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &so_err, &len) != 0) {
+    return map_errno_to_zi(errno);
+  }
+  if (so_err == 0) {
+    // Some platforms may report SO_ERROR=0 before the connection is fully established.
+    // Confirm connectivity via getpeername.
+    struct sockaddr_storage ss;
+    socklen_t slen = (socklen_t)sizeof(ss);
+    if (getpeername(s->fd, (struct sockaddr *)&ss, &slen) == 0) {
+      s->connecting = 0;
+      return 0;
+    }
+    if (errno == ENOTCONN) return ZI_E_AGAIN;
+    return map_errno_to_zi(errno);
+  }
+
+  // Still in progress.
+  if (so_err == EINPROGRESS
+#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EINPROGRESS)
+      || so_err == EWOULDBLOCK
+#endif
+  ) {
+    return ZI_E_AGAIN;
+  }
+
+  return map_errno_to_zi(so_err);
+}
+
 static int32_t map_errno_to_zi(int e) {
   switch (e) {
     case EAGAIN:
@@ -64,6 +102,9 @@ static int32_t tcp_read(void *ctx, zi_ptr_t dst_ptr, zi_size32_t cap) {
   if (!s) return ZI_E_INTERNAL;
   if (cap == 0) return 0;
 
+  int32_t cr = tcp_ensure_connected(s);
+  if (cr != 0) return cr;
+
   const zi_mem_v1 *mem = zi_runtime25_mem();
   if (!mem || !mem->map_rw) return ZI_E_NOSYS;
   if (dst_ptr == 0) return ZI_E_BOUNDS;
@@ -81,6 +122,9 @@ static int32_t tcp_write(void *ctx, zi_ptr_t src_ptr, zi_size32_t len) {
   if (!s) return ZI_E_INTERNAL;
   if (len == 0) return 0;
 
+  int32_t cr = tcp_ensure_connected(s);
+  if (cr != 0) return cr;
+
   const zi_mem_v1 *mem = zi_runtime25_mem();
   if (!mem || !mem->map_ro) return ZI_E_NOSYS;
   if (src_ptr == 0) return ZI_E_BOUNDS;
@@ -331,38 +375,52 @@ zi_handle_t zi_net_tcp25_open_from_params(zi_ptr_t params_ptr, zi_size32_t param
       continue;
     }
 
+    // Make connect + subsequent I/O nonblocking so callers can rely on ZI_E_AGAIN.
+    set_nonblocking_best_effort(fd);
+
 #if defined(__APPLE__) && defined(SO_NOSIGPIPE)
     {
       int one = 1;
       (void)setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &one, (socklen_t)sizeof(one));
     }
 #endif
 
-    if (connect(fd, cur->ai_addr, cur->ai_addrlen) == 0) {
-      last_zi = 0;
+    for (;;) {
+      if (connect(fd, cur->ai_addr, cur->ai_addrlen) == 0) {
+        last_zi = 0;
+        break;
+      }
+
+      if (errno == EINTR) continue;
+      if (errno == EINPROGRESS
+#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EINPROGRESS)
+          || errno == EWOULDBLOCK
+#endif
+      ) {
+        last_zi = ZI_E_AGAIN;
+        break;
+      }
+
+      last_zi = map_errno_to_zi(errno);
+      (void)close(fd);
+      fd = -1;
       break;
     }
 
-    last_zi = map_errno_to_zi(errno);
-    (void)close(fd);
-    fd = -1;
+    if (fd >= 0) break;
   }
 
   freeaddrinfo(ai);
 
-  if (fd < 0) {
-    return (zi_handle_t)last_zi;
-  }
-
-  // Make subsequent I/O nonblocking so callers can rely on ZI_E_AGAIN.
-  set_nonblocking_best_effort(fd);
+  if (fd < 0) return (zi_handle_t)last_zi;
 
   zi_tcp_stream *s = (zi_tcp_stream *)calloc(1, sizeof(*s));
   if (!s) {
     (void)close(fd);
     return (zi_handle_t)ZI_E_OOM;
   }
   s->fd = fd;
+  s->connecting = (last_zi == ZI_E_AGAIN) ? 1 : 0;
 
   zi_handle_t h = zi_handle25_alloc_with_poll(&tcp_ops, &tcp_poll_ops, s, ZI_H_READABLE | ZI_H_WRITABLE | ZI_H_ENDABLE);
   if (h == 0) {