DHCP: escalate failed enqueues

Program next-tick retry instead of arming the DHCP retry timer.

Author: danielinux

src/test/unit/unit.c

@@ -314,6 +314,8 @@ Suite *wolf_suite(void)
     tcase_add_test(tc_utils, test_dhcp_client_init_and_bound);
     tcase_add_test(tc_utils, test_dhcp_send_request_renewing_sets_ciaddr_and_rebind_deadline);
     tcase_add_test(tc_utils, test_dhcp_send_request_rebinding_broadcasts_to_lease_expiry);
+    tcase_add_test(tc_utils, test_dhcp_send_request_send_failure_retries_next_tick);
+    tcase_add_test(tc_utils, test_dhcp_send_discover_send_failure_retries_next_tick);
     tcase_add_test(tc_utils, test_dhcp_poll_offer_and_ack);
     tcase_add_test(tc_utils, test_dhcp_poll_renewing_ack_binds_client);
     tcase_add_test(tc_utils, test_dhcp_poll_rebinding_ack_binds_client);

src/test/unit/unit_tests_dns_dhcp.c

@@ -903,6 +903,60 @@ START_TEST(test_dhcp_send_request_rebinding_broadcasts_to_lease_expiry)
 }
 END_TEST
 
+START_TEST(test_dhcp_send_request_send_failure_retries_next_tick)
+{
+    struct wolfIP s;
+    struct tsocket *ts;
+    struct ipconf *primary;
+    uint8_t tiny[2];
+
+    wolfIP_init(&s);
+    mock_link_init(&s);
+    primary = wolfIP_primary_ipconf(&s);
+    ck_assert_ptr_nonnull(primary);
+    primary->ip = 0x0A000064U;
+    primary->mask = 0xFFFFFF00U;
+    s.dhcp_server_ip = 0x0A000001U;
+    s.dhcp_ip = primary->ip;
+    s.dhcp_xid = 1U;
+    s.dhcp_state = DHCP_REQUEST_SENT;
+    s.last_tick = 1000U;
+
+    s.dhcp_udp_sd = wolfIP_sock_socket(&s, AF_INET, IPSTACK_SOCK_DGRAM, WI_IPPROTO_UDP);
+    ck_assert_int_gt(s.dhcp_udp_sd, 0);
+    ts = &s.udpsockets[SOCKET_UNMARK(s.dhcp_udp_sd)];
+    fifo_init(&ts->sock.udp.txbuf, tiny, sizeof(tiny));
+
+    ck_assert_int_eq(dhcp_send_request(&s), -WOLFIP_EAGAIN);
+    ck_assert_ptr_eq(fifo_peek(&ts->sock.udp.txbuf), NULL);
+    ck_assert_uint_eq(ts->local_ip, 0U);
+    ck_assert_uint_eq(find_timer_expiry(&s, s.dhcp_timer), s.last_tick + 1U);
+}
+END_TEST
+
+START_TEST(test_dhcp_send_discover_send_failure_retries_next_tick)
+{
+    struct wolfIP s;
+    struct tsocket *ts;
+    uint8_t tiny[2];
+
+    wolfIP_init(&s);
+    mock_link_init(&s);
+    s.dhcp_xid = 1U;
+    s.last_tick = 1000U;
+
+    s.dhcp_udp_sd = wolfIP_sock_socket(&s, AF_INET, IPSTACK_SOCK_DGRAM, WI_IPPROTO_UDP);
+    ck_assert_int_gt(s.dhcp_udp_sd, 0);
+    ts = &s.udpsockets[SOCKET_UNMARK(s.dhcp_udp_sd)];
+    fifo_init(&ts->sock.udp.txbuf, tiny, sizeof(tiny));
+
+    ck_assert_int_eq(dhcp_send_discover(&s), -WOLFIP_EAGAIN);
+    ck_assert_ptr_eq(fifo_peek(&ts->sock.udp.txbuf), NULL);
+    ck_assert_int_eq(s.dhcp_state, DHCP_OFF);
+    ck_assert_uint_eq(find_timer_expiry(&s, s.dhcp_timer), s.last_tick + 1U);
+}
+END_TEST
+
 START_TEST(test_sock_connect_tcp_src_port_low)
 {
     struct wolfIP s;

src/wolfip.c

@@ -5599,8 +5599,10 @@ static int dhcp_send_request(struct wolfIP *s)
     struct dhcp_option *opt = (struct dhcp_option *)(req.options);
     struct wolfIP_sockaddr_in sin;
     struct ipconf *primary = wolfIP_primary_ipconf(s);
+    uint64_t retry_at = s ? (s->last_tick + 1U) : 0;
     int renewing = (s->dhcp_state == DHCP_RENEWING);
     int rebinding = (s->dhcp_state == DHCP_REBINDING);
+    int ret;
     uint32_t opt_sz = 0;
     /* Prepare DHCP request */
     memset(&req, 0, sizeof(struct dhcp_msg));
@@ -5655,13 +5657,21 @@ static int dhcp_send_request(struct wolfIP *s)
     else
         sin.sin_addr.s_addr = ee32(0xFFFFFFFF); /* Broadcast */
     sin.sin_family = AF_INET;
-    wolfIP_sock_sendto(s, s->dhcp_udp_sd, &req, DHCP_HEADER_LEN + opt_sz, 0,
+    ret = wolfIP_sock_sendto(s, s->dhcp_udp_sd, &req, DHCP_HEADER_LEN + opt_sz, 0,
             (struct wolfIP_sockaddr *)&sin, sizeof(struct wolfIP_sockaddr_in));
     if (!renewing && !rebinding) {
         /* Reset local_ip so DHCP ACK matches via DHCP_IS_RUNNING path in
          * udp_try_recv(). wolfIP_sock_sendto() sets local_ip from conf->ip
          * (the offered IP), but we haven't confirmed the lease yet. */
         s->udpsockets[SOCKET_UNMARK(s->dhcp_udp_sd)].local_ip = 0;
+    }
+    if (ret < 0) {
+        /* Retry on the next tick after local backpressure instead of
+         * waiting a full DHCP timeout for a request that never queued. */
+        dhcp_schedule_timer_at(s, retry_at);
+        return ret;
+    }
+    if (!renewing && !rebinding) {
         dhcp_schedule_retry_timer(s, 0);
     } else if (renewing) {
         dhcp_schedule_retry_timer(s, s->dhcp_rebind_at);
@@ -5685,8 +5695,9 @@ static int dhcp_send_discover(struct wolfIP *s)
 {
     struct dhcp_msg disc;
     struct dhcp_option *opt = (struct dhcp_option *)(disc.options);
-    struct wolfIP_timer tmr = { };
     struct wolfIP_sockaddr_in sin;
+    uint64_t retry_at = s ? (s->last_tick + 1U) : 0;
+    int ret;
     uint32_t opt_sz = 0;
     /* Prepare DHCP discover */
     memset(&disc, 0, sizeof(struct dhcp_msg));
@@ -5722,14 +5733,16 @@ static int dhcp_send_discover(struct wolfIP *s)
     sin.sin_port = ee16(DHCP_SERVER_PORT);
     sin.sin_addr.s_addr = ee32(0xFFFFFFFF); /* Broadcast */
     sin.sin_family = AF_INET;
-    wolfIP_sock_sendto(s, s->dhcp_udp_sd, &disc, DHCP_HEADER_LEN + opt_sz, 0,
+    ret = wolfIP_sock_sendto(s, s->dhcp_udp_sd, &disc, DHCP_HEADER_LEN + opt_sz, 0,
             (struct wolfIP_sockaddr *)&sin, sizeof(struct wolfIP_sockaddr_in));
-    tmr.expires = s->last_tick + DHCP_DISCOVER_TIMEOUT + (wolfIP_getrandom() % 200);
-    tmr.arg = s;
-    tmr.cb = dhcp_timer_cb;
+    if (ret < 0) {
+        /* Retry on the next tick after local backpressure instead of
+         * waiting a full discover timeout for a packet that never queued. */
+        dhcp_schedule_timer_at(s, retry_at);
+        return ret;
+    }
+    dhcp_schedule_timer_at(s, s->last_tick + DHCP_DISCOVER_TIMEOUT + (wolfIP_getrandom() % 200U));
     s->dhcp_state = DHCP_DISCOVER_SENT;
-
-    s->dhcp_timer = timers_binheap_insert(&s->timers, tmr);
     return 0;
 }