net: lib: download_client: implement CoAP backoff mechanism

Use CoAP backoff mechanism to set CoAP timeouts for recv/send according
to CoAP specification.

Signed-off-by: Andreas Chmielewski <[email protected]>

Author: andreas-chmielewski-gcx

include/net/download_client.h

@@ -162,6 +162,9 @@ struct download_client {
 	struct {
 		/** CoAP block context. */
 		struct coap_block_context block_ctx;
+
+		/** CoAP pending object. */
+		struct coap_pending pending;
 	} coap;
 
 	/** Internal thread ID. */

subsys/net/lib/download_client/Kconfig

@@ -116,15 +116,14 @@ config DOWNLOAD_CLIENT_TCP_SOCK_TIMEO_MS
 	  when the server is not responding and client should give up.
 	  Set to -1 disable.
 
-config DOWNLOAD_CLIENT_UDP_SOCK_TIMEO_MS
-	int "Receive timeout on UDP sockets, in milliseconds"
-	default 4000
-	range -1 30000
+config DOWNLOAD_CLIENT_COAP_MAX_RETRANSMIT_REQUEST_COUNT
+	int "Number of CoAP request retransmissions"
+	default 4
+	range 1 10
 	help
-	  Socket timeout for recv() calls, in milliseconds.
-	  When using CoAP, set a timeout to be able to detect
-	  when a retrasmission is necessary.
-	  Set to -1 disable.
+	  As part of CoAP exponential backoff mechanism this is the number
+	  of retransmissions of a request. If the retransmissions exceeds,
+	  the download will be stopped.
 
 config DOWNLOAD_CLIENT_RANGE_REQUESTS
 	bool "Always use HTTP Range requests"

subsys/net/lib/download_client/src/coap.c

@@ -36,6 +36,11 @@ static int coap_get_current_from_response_pkt(const struct coap_packet *cpkt)
 	return GET_BLOCK_NUM(block) << (GET_BLOCK_SIZE(block) + 4);
 }
 
+static bool has_pending(struct download_client *client)
+{
+	return client->coap.pending.timeout > 0;
+}
+
 int coap_block_init(struct download_client *client, size_t from)
 {
 	coap_block_transfer_init(&client->coap.block_ctx,
@@ -44,8 +49,47 @@ int coap_block_init(struct download_client *client, size_t from)
 	return 0;
 }
 
-int coap_block_update(struct download_client *client, struct coap_packet *pkt,
-		      size_t *blk_off)
+int coap_get_recv_timeout(struct download_client *dl)
+{
+	int timeout;
+
+	if (!has_pending(dl)) {
+		LOG_ERR("Must have coap pending");
+		return -1;
+	}
+
+	/* Retransmission is cycled in case recv() times out. In case sending request
+	 * blocks, the time that is used for sending request must be substracted next time
+	 * recv() is called.
+	 */
+	timeout = dl->coap.pending.t0 + dl->coap.pending.timeout - k_uptime_get_32();
+	if (timeout < 0) {
+		/* All time is spent when sending request and time this
+		 * method is called, there is no time left for receiving;
+		 * skip over recv() and initiate retransmission on next
+		 * cycle
+		 */
+		return 0;
+	}
+
+	return timeout;
+}
+
+int coap_initiate_retransmission(struct download_client *dl)
+{
+	if (dl->coap.pending.timeout == 0) {
+		return -EINVAL;
+	}
+
+	if (!coap_pending_cycle(&dl->coap.pending)) {
+		LOG_ERR("CoAP max-retransmissions exceeded");
+		return -1;
+	}
+
+	return 0;
+}
+
+int coap_block_update(struct download_client *client, struct coap_packet *pkt, size_t *blk_off)
 {
 	int err, new_current;
 	bool more;
@@ -100,17 +144,33 @@ int coap_parse(struct download_client *client, size_t len)
 	const uint8_t *payload;
 	struct coap_packet response;
 
+	/* TODO: currently we stop download on every error, but this is mostly not necessary
+	 * and we can just request the same block again using retry mechanism
+	 */
+
 	err = coap_packet_parse(&response, client->buf, len, NULL, 0);
 	if (err) {
 		LOG_ERR("Failed to parse CoAP packet, err %d", err);
 		return -1;
 	}
 
+	coap_pending_clear(&client->coap.pending);
+
 	err = coap_block_update(client, &response, &blk_off);
 	if (err) {
 		return err;
 	}
 
+	if (coap_header_get_id(&response) != client->coap.pending.id) {
+		LOG_ERR("Response is not pending");
+		return -1;
+	}
+
+	if (coap_header_get_type(&response) != COAP_TYPE_ACK) {
+		LOG_ERR("Response must be of coap type ACK");
+		return -1;
+	}
+
 	response_code = coap_header_get_code(&response);
 	if (response_code != COAP_RESPONSE_CODE_OK &&
 	    response_code != COAP_RESPONSE_CODE_CONTENT) {
@@ -143,23 +203,28 @@ int coap_parse(struct download_client *client, size_t len)
 int coap_request_send(struct download_client *client)
 {
 	int err;
+	uint16_t id;
 	char file[FILENAME_SIZE];
 	char *path_elem;
 	char *path_elem_saveptr;
 	struct coap_packet request;
 
-	err = coap_packet_init(
-		&request, client->buf, CONFIG_DOWNLOAD_CLIENT_BUF_SIZE,
-		COAP_VER, COAP_TYPE_CON, 8, coap_next_token(),
-		COAP_METHOD_GET, coap_next_id()
-	);
+	if (has_pending(client)) {
+		id = client->coap.pending.id;
+	} else {
+		id = coap_next_id();
+	}
+
+	err = coap_packet_init(&request, client->buf, CONFIG_DOWNLOAD_CLIENT_BUF_SIZE, COAP_VER,
+			       COAP_TYPE_CON, 8, coap_next_token(), COAP_METHOD_GET, id);
 	if (err) {
 		LOG_ERR("Failed to init CoAP message, err %d", err);
 		return err;
 	}
 
 	err = url_parse_file(client->file, file, sizeof(file));
 	if (err) {
+		LOG_ERR("Unable to parse url");
 		return err;
 	}
 
@@ -185,9 +250,19 @@ int coap_request_send(struct download_client *client)
 		return err;
 	}
 
+	if (!has_pending(client)) {
+		err = coap_pending_init(&client->coap.pending, &request, &client->remote_addr,
+					CONFIG_DOWNLOAD_CLIENT_COAP_MAX_RETRANSMIT_REQUEST_COUNT);
+		if (err < 0) {
+			return -EINVAL;
+		}
+
+		coap_pending_cycle(&client->coap.pending);
+	}
+
 	LOG_DBG("CoAP next block: %d", client->coap.block_ctx.current);
 
-	err = socket_send(client, request.offset, 0);
+	err = socket_send(client, request.offset, client->coap.pending.timeout);
 	if (err) {
 		LOG_ERR("Failed to send CoAP request, errno %d", errno);
 		return err;

subsys/net/lib/download_client/src/download_client.c

@@ -36,6 +36,8 @@ int http_parse(struct download_client *client, size_t len);
 int http_get_request_send(struct download_client *client);
 
 int coap_block_init(struct download_client *client, size_t from);
+int coap_get_recv_timeout(struct download_client *dl);
+int coap_initiate_retransmission(struct download_client *dl);
 int coap_parse(struct download_client *client, size_t len);
 int coap_request_send(struct download_client *client);
 
@@ -425,7 +427,11 @@ static size_t socket_recv(struct download_client *dl)
 	case IPPROTO_UDP:
 	case IPPROTO_DTLS_1_2:
 		if (IS_ENABLED(CONFIG_COAP)) {
-			timeout = CONFIG_DOWNLOAD_CLIENT_UDP_SOCK_TIMEO_MS;
+			timeout = coap_get_recv_timeout(dl);
+			if (timeout <= 0) {
+				errno = ETIMEDOUT;
+				return -1;
+			}
 			break;
 		}
 	default:
@@ -441,6 +447,27 @@ static size_t socket_recv(struct download_client *dl)
 	return recv(dl->fd, dl->buf + dl->offset, sizeof(dl->buf) - dl->offset, 0);
 }
 
+static int request_resend(struct download_client *dl)
+{
+	int rc;
+
+	if (dl->proto == IPPROTO_UDP || dl->proto == IPPROTO_DTLS_1_2) {
+		LOG_DBG("Socket timeout, resending");
+
+		if (IS_ENABLED(CONFIG_COAP)) {
+			rc = coap_initiate_retransmission(dl);
+			if (rc) {
+				error_evt_send(dl, errno);
+				return -1;
+			}
+		}
+
+		return 1;
+	}
+
+	return 0;
+}
+
 void download_thread(void *client, void *a, void *b)
 {
 	int rc = 0;
@@ -487,9 +514,10 @@ void download_thread(void *client, void *a, void *b)
 			if (len == -1) {
 				if ((errno == ETIMEDOUT) || (errno == EWOULDBLOCK) ||
 				    (errno == EAGAIN)) {
-					if (dl->proto == IPPROTO_UDP ||
-					    dl->proto == IPPROTO_DTLS_1_2) {
-						LOG_DBG("Socket timeout, resending");
+					rc = request_resend(dl);
+					if (rc == -1) {
+						break;
+					} else if (rc == 1) {
 						goto send_again;
 					}
 					error_cause = ETIMEDOUT;