Preserve socket events raised during poll callbacks

F/1161

Author: danielinux

src/test/unit/unit.c

@@ -117,6 +117,7 @@ Suite *wolf_suite(void)
 #endif
     tcase_add_test(tc_utils, test_wolfip_ipconfig_ex_per_interface);
     tcase_add_test(tc_utils, test_wolfip_poll_executes_timers_and_callbacks);
+    tcase_add_test(tc_utils, test_wolfip_poll_preserves_tcp_events_raised_during_callback);
     tcase_add_test(tc_utils, test_filter_notify_tcp_metadata);
     tcase_add_test(tc_utils, test_filter_dispatch_no_callback);
     tcase_add_test(tc_utils, test_filter_dispatch_mask_not_set);

src/test/unit/unit_tests_api.c

@@ -1,3 +1,19 @@
+static struct wolfIP *poll_rearm_stack;
+static int poll_rearm_cb_calls;
+static int poll_rearm_recv_len;
+
+static void test_poll_rearm_tcp_cb(int sock_fd, uint16_t events, void *arg)
+{
+    uint8_t buf[8];
+
+    (void)arg;
+    poll_rearm_cb_calls++;
+    ck_assert_ptr_nonnull(poll_rearm_stack);
+    ck_assert_uint_eq(events & CB_EVENT_READABLE, CB_EVENT_READABLE);
+    ck_assert_int_eq(wolfIP_sock_recvfrom(poll_rearm_stack, sock_fd, buf,
+            (size_t)poll_rearm_recv_len, 0, NULL, NULL), poll_rearm_recv_len);
+}
+
 START_TEST(test_wolfip_poll_executes_timers_and_callbacks)
 {
     struct wolfIP s;
@@ -31,6 +47,39 @@ START_TEST(test_wolfip_poll_executes_timers_and_callbacks)
 }
 END_TEST
 
+START_TEST(test_wolfip_poll_preserves_tcp_events_raised_during_callback)
+{
+    struct wolfIP s;
+    int tcp_sd;
+    struct tsocket *ts;
+    uint8_t payload[8] = {0};
+
+    wolfIP_init(&s);
+    mock_link_init(&s);
+
+    tcp_sd = wolfIP_sock_socket(&s, AF_INET, IPSTACK_SOCK_STREAM, WI_IPPROTO_TCP);
+    ck_assert_int_gt(tcp_sd, 0);
+    ts = &s.tcpsockets[SOCKET_UNMARK(tcp_sd)];
+    ts->sock.tcp.state = TCP_ESTABLISHED;
+    queue_init(&ts->sock.tcp.rxbuf, ts->rxmem, RXBUF_SIZE, 0);
+    ck_assert_int_eq(queue_insert(&ts->sock.tcp.rxbuf, payload, 0, sizeof(payload)), 0);
+
+    poll_rearm_stack = &s;
+    poll_rearm_cb_calls = 0;
+    poll_rearm_recv_len = 4;
+    wolfIP_register_callback(&s, tcp_sd, test_poll_rearm_tcp_cb, NULL);
+    ts->events = CB_EVENT_READABLE;
+
+    (void)wolfIP_poll(&s, 100);
+    ck_assert_int_eq(poll_rearm_cb_calls, 1);
+    ck_assert_uint_eq(ts->events & CB_EVENT_READABLE, CB_EVENT_READABLE);
+
+    (void)wolfIP_poll(&s, 101);
+    ck_assert_int_eq(poll_rearm_cb_calls, 2);
+    ck_assert_uint_eq(ts->events & CB_EVENT_READABLE, 0U);
+}
+END_TEST
+
 START_TEST(test_filter_notify_tcp_metadata)
 {
     struct wolfIP s;

src/wolfip.c

@@ -6541,22 +6541,25 @@ int wolfIP_poll(struct wolfIP *s, uint64_t now)
     for (i = 0; i < MAX_TCPSOCKETS; i++) {
         struct tsocket *ts = &s->tcpsockets[i];
         if ((ts->sock.tcp.state != TCP_CLOSED) && (ts->callback) && (ts->events)) {
-            ts->callback(i | MARK_TCP_SOCKET, ts->events, ts->callback_arg);
+            uint16_t events = ts->events;
             ts->events = 0;
+            ts->callback(i | MARK_TCP_SOCKET, events, ts->callback_arg);
         }
     }
     for (i = 0; i < MAX_UDPSOCKETS; i++) {
         struct tsocket *ts = &s->udpsockets[i];
         if ((ts->callback) && (ts->events)) {
-            ts->callback(i | MARK_UDP_SOCKET, ts->events, ts->callback_arg);
+            uint16_t events = ts->events;
             ts->events = 0;
+            ts->callback(i | MARK_UDP_SOCKET, events, ts->callback_arg);
         }
     }
     for (i = 0; i < MAX_ICMPSOCKETS; i++) {
         struct tsocket *ts = &s->icmpsockets[i];
         if ((ts->callback) && (ts->events)) {
-            ts->callback(i | MARK_ICMP_SOCKET, ts->events, ts->callback_arg);
+            uint16_t events = ts->events;
             ts->events = 0;
+            ts->callback(i | MARK_ICMP_SOCKET, events, ts->callback_arg);
         }
     }