report read readiness accurately for freshly bound UDP sockets (#740)

Previously, `wasip2_udp.c` would call
`wasi:sockets/udp#udp-socket.streams` lazily as needed in e.g. `sendto`
and `recvfrom`. However, it was not doing so when the socket was
`poll`ed, which meant `poll` would indicate read readiness and return
immediately even though there was nothing ready to read.

With this commit, we now create the stream when polling the socket,
which allows us to actually wait for real read readiness.

This also adds trivial `SO_ERROR` support to `udp_getsockopt`.

Author: dicej

libc-bottom-half/sources/wasip2_udp.c

@@ -627,6 +627,11 @@ static int udp_getsockopt(void *data, int level, int optname, void *optval,
       value = __wasi_sockets_utils__posix_family(socket->family);
       break;
     }
+
+    case SO_ERROR:
+      value = 0;
+      break;
+
     case SO_RCVBUF: {
       uint64_t result;
       if (!udp_method_udp_socket_receive_buffer_size(socket_borrow, &result,
@@ -825,10 +830,18 @@ static int udp_poll_register(void *data, poll_state_t *state, short events) {
   udp_socket_t *socket = (udp_socket_t *)data;
   switch (socket->state.tag) {
   case UDP_SOCKET_STATE_UNBOUND:
-  case UDP_SOCKET_STATE_BOUND_NOSTREAMS:
+    // In the unbound case, all we can do is assume immediate read and write
+    // readiness:
     __wasilibc_poll_ready(state, events);
     break;
 
+  case UDP_SOCKET_STATE_BOUND_NOSTREAMS:
+    // We can't know the true state of read and write readiness until we have
+    // stream handles, so let's add those now:
+    if (udp_create_streams(socket, NULL) < 0)
+      return -1;
+    // Deliberately fall through to next case:
+
   case UDP_SOCKET_STATE_BOUND_STREAMING:
   case UDP_SOCKET_STATE_CONNECTED: {
     udp_socket_streams_t *streams;

test/src/sockets-nonblocking-udp.c

@@ -71,22 +71,27 @@ void test_udp_client() {
   // Write to socket
   ssize_t bytes_sent = send(socket_fd, message, len + 1, 0);
 
+  // Wait for server to be read-ready.
+  while (1) {
+    if (t_status)
+      exit(t_status);
+
+    struct pollfd poll_fd = {
+        .fd = server_socket_fd, .events = POLLRDNORM, .revents = 0};
+    TEST(poll(&poll_fd, 1, 100) != -1);
+    if (poll_fd.revents) {
+      break;
+    }
+  }
+
   // Receive from client
   struct sockaddr_in sockaddr_client;
   socklen_t sockaddr_client_len = sizeof(sockaddr_in);
   ssize_t bytes_received =
       recvfrom(server_socket_fd, server_buffer, BUFSIZE, 0,
                (struct sockaddr *)&sockaddr_client, &sockaddr_client_len);
   if (bytes_received == -1)
-    if (errno != EWOULDBLOCK)
-      t_error("recvfrom failed (errno = %d)\n", errno);
-
-  while (bytes_received == -1) {
-    struct pollfd poll_fd = {
-        .fd = server_socket_fd, .events = POLLRDNORM, .revents = 0};
-    poll(&poll_fd, 1, 100);
-    bytes_received = recv(server_socket_fd, server_buffer, BUFSIZE, 0);
-  }
+    t_error("recvfrom failed (errno = %d)\n", errno);
 
   TEST(bytes_sent == len + 1);
   TEST(bytes_received == len + 1);
@@ -117,6 +122,14 @@ void test_udp_client() {
   if (bytes_sent == bytes_received)
     TEST(strcmp(message, client_buffer) == 0);
 
+  int value = -1;
+  socklen_t length = sizeof(value);
+  TEST(getsockopt(socket_fd, SOL_SOCKET, SO_ERROR, &value, &length) == 0 &&
+       value == 0);
+  TEST(getsockopt(server_socket_fd, SOL_SOCKET, SO_ERROR, &value, &length) ==
+           0 &&
+       value == 0);
+
   // Shut down client
   close(socket_fd);