net: lwm2m: Prevent QUEUE_RX_OFF while waiting for CoAP Ack

The LwM2M RD client state machine have no knowledge of ongoing
observations or any other CoAP traffic and might trigger
QUEUE_RX_OFF state while engine is still waiting for Ack.

This can happen if CoAP Ack timeout is longer than
CONFIG_LWM2M_QUEUE_MODE_UPTIME and response is lost or taking
longer than QUEUE_MODE_UPTIME.

When observation is lost, CoAP Ack may be send, but socket is not
listening anymore if its closed or not polled while in RX_OFF and this
stops observation.

Signed-off-by: Seppo Takalo <[email protected]>

Author: SeppoTakalo

subsys/net/lib/lwm2m/lwm2m_engine.c

@@ -653,8 +653,9 @@ static void hint_socket_state(struct lwm2m_ctx *ctx, struct lwm2m_message *ongoi
 {
 	bool empty;
 	size_t pendings;
+	int next_state = -1;
 
-	if (!ctx || !ctx->set_socket_state) {
+	if (!ctx) {
 		return;
 	}
 
@@ -677,14 +678,23 @@ static void hint_socket_state(struct lwm2m_ctx *ctx, struct lwm2m_message *ongoi
 		bool ongoing_block_tx = coap_block_has_more(&ongoing_tx->cpkt);
 
 		if (!empty || ongoing_block_tx) {
-			ctx->set_socket_state(ctx->sock_fd, LWM2M_SOCKET_STATE_ONGOING);
+			next_state = LWM2M_SOCKET_STATE_ONGOING;
 		} else if (ongoing_tx->type == COAP_TYPE_CON) {
-			ctx->set_socket_state(ctx->sock_fd, LWM2M_SOCKET_STATE_ONE_RESPONSE);
+			next_state = LWM2M_SOCKET_STATE_ONE_RESPONSE;
 		} else {
-			ctx->set_socket_state(ctx->sock_fd, LWM2M_SOCKET_STATE_LAST);
+			next_state = LWM2M_SOCKET_STATE_LAST;
 		}
 	} else if (empty && pendings == 0) {
-		ctx->set_socket_state(ctx->sock_fd, LWM2M_SOCKET_STATE_NO_DATA);
+		next_state = LWM2M_SOCKET_STATE_NO_DATA;
+	}
+
+	if (next_state < 0) {
+		return;
+	}
+
+	lwm2m_rd_client_hint_socket_state(ctx, next_state);
+	if (ctx->set_socket_state) {
+		ctx->set_socket_state(ctx->sock_fd, next_state);
 	}
 }
 

subsys/net/lib/lwm2m/lwm2m_engine.h

@@ -399,4 +399,15 @@ void lwm2m_client_lock(struct lwm2m_ctx *ctx);
  */
 void lwm2m_client_unlock(struct lwm2m_ctx *ctx);
 
+/**
+ * @brief Hints the RD client about the current socket state.
+ *
+ * Prevents the RD client from going to QUEUE_RX_OFF state when the socket is
+ * in use.
+ *
+ * @param ctx LwM2M context
+ * @param state Current socket state
+ */
+void lwm2m_rd_client_hint_socket_state(struct lwm2m_ctx *ctx, enum lwm2m_socket_states state);
+
 #endif /* LWM2M_ENGINE_H */

subsys/net/lib/lwm2m/lwm2m_rd_client.c

@@ -120,6 +120,7 @@ struct lwm2m_rd_client_info {
 	uint8_t engine_state;
 	uint8_t retries;
 	uint8_t retry_delay;
+	enum lwm2m_socket_states socket_state;
 
 	int64_t last_update;
 	int64_t last_tx;
@@ -170,6 +171,24 @@ struct lwm2m_message *lwm2m_get_ongoing_rd_msg(void)
 	return &client.rd_message;
 }
 
+static bool ongoing_traffic(void)
+{
+	switch (client.socket_state) {
+	case LWM2M_SOCKET_STATE_NO_DATA:
+	case LWM2M_SOCKET_STATE_LAST:
+		return false;
+	default:
+		return true;
+	}
+}
+
+void lwm2m_rd_client_hint_socket_state(struct lwm2m_ctx *ctx, enum lwm2m_socket_states state)
+{
+	if (ctx && client.ctx == ctx) {
+		client.socket_state = state;
+	}
+}
+
 void engine_update_tx_time(void)
 {
 	client.last_tx = k_uptime_get();
@@ -1144,7 +1163,11 @@ static int64_t next_update(void)
 static int64_t next_rx_off(void)
 {
 	if (IS_ENABLED(CONFIG_LWM2M_QUEUE_MODE_ENABLED)) {
-		return client.last_tx + CONFIG_LWM2M_QUEUE_MODE_UPTIME * MSEC_PER_SEC;
+		if (!ongoing_traffic()) {
+			return client.last_tx + CONFIG_LWM2M_QUEUE_MODE_UPTIME * MSEC_PER_SEC;
+		} else {
+			return k_uptime_get() + CONFIG_LWM2M_QUEUE_MODE_UPTIME * MSEC_PER_SEC;
+		}
 	} else {
 		return next_update();
 	}

tests/net/lib/lwm2m/lwm2m_engine/src/stubs.c

@@ -44,6 +44,8 @@ DEFINE_FAKE_VALUE_FUNC(int, lwm2m_security_mode, struct lwm2m_ctx *);
 DEFINE_FAKE_VALUE_FUNC(int, z_impl_zsock_setsockopt, int, int, int, const void *, socklen_t);
 DEFINE_FAKE_VOID_FUNC(engine_update_tx_time);
 DEFINE_FAKE_VALUE_FUNC(bool, coap_block_has_more, struct coap_packet *);
+DEFINE_FAKE_VOID_FUNC(lwm2m_rd_client_hint_socket_state, struct lwm2m_ctx *,
+		      enum lwm2m_socket_states);
 
 static sys_slist_t obs_obj_path_list = SYS_SLIST_STATIC_INIT(&obs_obj_path_list);
 sys_slist_t *lwm2m_obs_obj_path_list(void)

tests/net/lib/lwm2m/lwm2m_engine/src/stubs.h

@@ -59,6 +59,8 @@ DECLARE_FAKE_VALUE_FUNC(int, lwm2m_security_mode, struct lwm2m_ctx *);
 DECLARE_FAKE_VALUE_FUNC(int, z_impl_zsock_setsockopt, int, int, int, const void *, socklen_t);
 DECLARE_FAKE_VOID_FUNC(engine_update_tx_time);
 DECLARE_FAKE_VALUE_FUNC(bool, coap_block_has_more, struct coap_packet *);
+DECLARE_FAKE_VOID_FUNC(lwm2m_rd_client_hint_socket_state, struct lwm2m_ctx *,
+		       enum lwm2m_socket_states);
 
 #define DO_FOREACH_FAKE(FUNC)                                                                      \
 	do {                                                                                       \
@@ -91,6 +93,7 @@ DECLARE_FAKE_VALUE_FUNC(bool, coap_block_has_more, struct coap_packet *);
 		FUNC(z_impl_zsock_setsockopt)                                                      \
 		FUNC(engine_update_tx_time)                                                        \
 		FUNC(coap_block_has_more)							   \
+		FUNC(lwm2m_rd_client_hint_socket_state)                                            \
 	} while (0)
 
 #endif /* STUBS_H */

tests/net/lib/lwm2m/lwm2m_rd_client/CMakeLists.txt

@@ -24,7 +24,7 @@ add_compile_definitions(CONFIG_LWM2M_COAP_BLOCK_SIZE=256)
 add_compile_definitions(CONFIG_LWM2M_COAP_MAX_MSG_SIZE=512)
 add_compile_definitions(CONFIG_LWM2M_ENGINE_DEFAULT_LIFETIME=20)
 add_compile_definitions(CONFIG_LWM2M_SECURITY_INSTANCE_COUNT=1)
-add_compile_definitions(CONFIG_LWM2M_SECONDS_TO_UPDATE_EARLY=10)
+add_compile_definitions(CONFIG_LWM2M_SECONDS_TO_UPDATE_EARLY=5)
 add_compile_definitions(CONFIG_LWM2M_QUEUE_MODE_UPTIME=10)
 add_compile_definitions(CONFIG_LWM2M_LOG_LEVEL=4)
 add_compile_definitions(CONFIG_LWM2M_QUEUE_MODE_ENABLED=1)

tests/net/lib/lwm2m/lwm2m_rd_client/src/main.c

@@ -339,8 +339,37 @@ ZTEST(lwm2m_rd_client, test_rx_off)
 	zassert_true(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_REGISTRATION_COMPLETE),
 		     NULL);
 
+	/* Should not go to RX_OFF while ongoing traffic */
+	lwm2m_rd_client_hint_socket_state(&ctx, LWM2M_SOCKET_STATE_ONGOING);
 	engine_update_tx_time();
 	k_sleep(K_SECONDS(15));
+	zassert_false(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_QUEUE_MODE_RX_OFF),
+		     NULL);
+
+	/* Should not go to RX_OFF while waiting for response */
+	lwm2m_rd_client_hint_socket_state(&ctx, LWM2M_SOCKET_STATE_ONE_RESPONSE);
+	engine_update_tx_time();
+	k_sleep(K_SECONDS(15));
+	zassert_true(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_REG_UPDATE_COMPLETE),
+		     NULL);
+	zassert_false(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_QUEUE_MODE_RX_OFF),
+		     NULL);
+
+	/* Should go to RX_OFF after response to a registration request */
+	lwm2m_rd_client_hint_socket_state(&ctx, LWM2M_SOCKET_STATE_LAST);
+	engine_update_tx_time();
+	k_sleep(K_SECONDS(15));
+	zassert_true(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_REG_UPDATE_COMPLETE),
+		     NULL);
+	zassert_true(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_QUEUE_MODE_RX_OFF),
+		     NULL);
+
+	/* Should go to RX_OFF normally */
+	lwm2m_rd_client_hint_socket_state(&ctx, LWM2M_SOCKET_STATE_NO_DATA);
+	engine_update_tx_time();
+	k_sleep(K_SECONDS(15));
+	zassert_true(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_REG_UPDATE_COMPLETE),
+		     NULL);
 	zassert_true(expect_lwm2m_rd_client_event(LWM2M_RD_CLIENT_EVENT_QUEUE_MODE_RX_OFF),
 		     NULL);
 }