net: coap_client: Add optional payload callback for uploads

Add an optional payload callback field to the coap_client_request
structure, allowing the application to provide blocks of payload
interactively during the resource upload, instead of having to provide
entire payload in a single contigunous memory space.

If registered, the CoAP client library will call the payload callback
whenever a new PUT/POST message is being generated (note this is also
true for retransmissions) instead of using the payload pointer/length.
If the payload callback is NULL, then the library operates as usual.

Signed-off-by: Robert Lubos <[email protected]>

Author: rlubos

include/zephyr/net/coap_client.h

@@ -68,6 +68,37 @@ struct coap_client_response_data {
 typedef void (*coap_client_response_cb_t)(const struct coap_client_response_data *data,
 					  void *user_data);
 
+/**
+ * @typedef coap_client_payload_cb_t
+ * @brief Callback for providing a payload for the CoAP request.
+ *
+ * An optional callback for providing a payload for CoAP client requests. If set in
+ * @ref coap_client_request, the CoAP client library will call this callback when
+ * preparing a PUT/POST request (note that this is also true for retransmissions).
+ *
+ * When called, the library provides the application with the current payload offset
+ * for the transfer and the payload block size. In return, the application sets the
+ * payload pointer, payload size and information whether more data blocks are expected.
+ * Setting the @p last_block parameter to false on the initial callback call triggers
+ * a block transfer upload. The library will keep calling the callback until the
+ * @p last_block parameter is set to false.
+ *
+ * @note If block transfer is used, the application is expected to provide full blocks of
+ * payload. Only the final block (i.e. when @p last_block is set to true) can be shorter
+ * than the requested block size.
+ *
+ * @param offset Payload offset from the beginning of a blockwise transfer.
+ * @param payload A pointer for the buffer containing the payload block.
+ * @param len Requested (maximum) block size on input. The actual payload length on output.
+ * @param last_block A pointer to the flag indicating whether more payload blocks are expected.
+ * @param user_data User provided context.
+ *
+ * @return Zero on success, a negative error code to abort upload.
+ */
+typedef int (*coap_client_payload_cb_t)(size_t offset, const uint8_t **payload,
+					size_t *len, bool *last_block,
+					void *user_data);
+
 /**
  * @brief Representation of a CoAP client request.
  */
@@ -78,6 +109,7 @@ struct coap_client_request {
 	enum coap_content_format fmt;             /**< Content format to be used */
 	const uint8_t *payload;                   /**< User allocated buffer for send request */
 	size_t len;                               /**< Length of the payload */
+	coap_client_payload_cb_t payload_cb;      /**< Optional payload callback */
 	coap_client_response_cb_t cb;             /**< Callback when response received */
 	const struct coap_client_option *options; /**< Extra options to be added to request */
 	uint8_t num_options;                      /**< Number of extra options */

subsys/net/lib/coap/coap_client.c

@@ -231,7 +231,7 @@ static int coap_client_init_request(struct coap_client *client,
 	}
 
 	/* Add content format option only if there is a payload */
-	if (req->payload) {
+	if (req->payload != NULL || req->payload_cb != NULL) {
 		ret = coap_append_option_int(&internal_req->request,
 					     COAP_OPTION_CONTENT_FORMAT, req->fmt);
 
@@ -272,14 +272,94 @@ static int coap_client_init_request(struct coap_client *client,
 		}
 	}
 
-	if (req->payload) {
+	if (req->payload != NULL || req->payload_cb != NULL) {
+		const uint8_t *payload = NULL;
+		bool block_transfer = false;
 		uint16_t payload_len;
-		uint16_t offset;
 
-		/* Blockwise send ongoing, add block1 */
-		if (internal_req->send_blk_ctx.total_size > 0 ||
-		   (req->len > CONFIG_COAP_CLIENT_MESSAGE_SIZE)) {
+		/* Block transfer already in progress */
+		if (internal_req->send_blk_ctx.total_size > 0) {
+			block_transfer = true;
+		}
+
+		if (req->payload_cb != NULL) {
+			size_t offset = 0;
+			size_t block_size = internal_req->send_blk_ctx.total_size > 0 ?
+				coap_block_size_to_bytes(internal_req->send_blk_ctx.block_size) :
+				CONFIG_COAP_CLIENT_BLOCK_SIZE;
+			size_t len = block_size;
+			bool last_block;
+
+			if (block_transfer) {
+				offset = internal_req->send_blk_ctx.current;
+			}
+
+			ret = req->payload_cb(offset, &payload, &len, &last_block,
+					      req->user_data);
+			if (ret < 0) {
+				LOG_ERR("Payload callback reported error, %d", ret);
+				goto out;
+			}
+
+			if (len > block_size || (len < block_size && !last_block)) {
+				LOG_ERR("Invalid payload size");
+				ret = -EINVAL;
+				goto out;
+			}
+
+			if (payload == NULL) {
+				LOG_ERR("No payload provided");
+				ret = -EINVAL;
+				goto out;
+			}
+
+			payload_len = len;
+
+			if (block_transfer && last_block) {
+				/* If block transfer was used and it's a final
+				 * block, adjust the total size value.
+				 */
+				internal_req->send_blk_ctx.total_size =
+					internal_req->send_blk_ctx.current + len;
+			}
 
+			if (!last_block) {
+				/* Expecting more blocks, enable block transfer.
+				 * Total length is yet unknown at this point,
+				 * so use SIZE_MAX for now.
+				 */
+				block_transfer = true;
+				req->len = SIZE_MAX;
+			}
+		} else {
+			payload = req->payload;
+			payload_len = req->len;
+
+			if (block_transfer) {
+				/* Block transfer already in progress, adjust
+				 * payload pointer and length.
+				 */
+				uint16_t block_in_bytes = coap_block_size_to_bytes(
+						internal_req->send_blk_ctx.block_size);
+
+				payload_len = internal_req->send_blk_ctx.total_size -
+					internal_req->send_blk_ctx.current;
+				if (payload_len > block_in_bytes) {
+					payload_len = block_in_bytes;
+				}
+
+				payload = req->payload + internal_req->send_blk_ctx.current;
+			} else if (req->len > CONFIG_COAP_CLIENT_MESSAGE_SIZE) {
+				/* Otherwise, if payload won't fit, initialize
+				 * block transfer.
+				 */
+				block_transfer = true;
+				payload_len = CONFIG_COAP_CLIENT_BLOCK_SIZE;
+			}
+		}
+
+		/* Blockwise send ongoing, add block1 */
+		if (block_transfer) {
 			if (internal_req->send_blk_ctx.total_size == 0) {
 				coap_block_transfer_init(&internal_req->send_blk_ctx,
 							 coap_client_default_block_size(),
@@ -289,6 +369,7 @@ static int coap_client_init_request(struct coap_client *client,
 
 				memcpy(internal_req->request_tag, tag, COAP_TOKEN_MAX_LEN);
 			}
+
 			ret = coap_append_block1_option(&internal_req->request,
 							&internal_req->send_blk_ctx);
 
@@ -314,22 +395,7 @@ static int coap_client_init_request(struct coap_client *client,
 			goto out;
 		}
 
-		if (internal_req->send_blk_ctx.total_size > 0) {
-			uint16_t block_in_bytes =
-				coap_block_size_to_bytes(internal_req->send_blk_ctx.block_size);
-
-			payload_len = internal_req->send_blk_ctx.total_size -
-				      internal_req->send_blk_ctx.current;
-			if (payload_len > block_in_bytes) {
-				payload_len = block_in_bytes;
-			}
-			offset = internal_req->send_blk_ctx.current;
-		} else {
-			payload_len = req->len;
-			offset = 0;
-		}
-
-		ret = coap_packet_append_payload(&internal_req->request, req->payload + offset,
+		ret = coap_packet_append_payload(&internal_req->request, payload,
 						 payload_len);
 
 		if (ret < 0) {