net: lib: http_server: allow application to send headers/response code

Allow the application to send headers and response codes from a dynamic
resource callback by filling out a response context structure.

This also allows simple requests to be completed in a single execution
of the callback, by setting the final_chunk flag.

Signed-off-by: Matt Rodgers <[email protected]>

Author: mrodgers-witekio

include/zephyr/net/http/server.h

@@ -25,6 +25,7 @@
 #include <zephyr/kernel.h>
 #include <zephyr/net/http/parser.h>
 #include <zephyr/net/http/hpack.h>
+#include <zephyr/net/http/status.h>
 #include <zephyr/net/socket.h>
 #include <zephyr/sys/iterable_sections.h>
 
@@ -161,6 +162,22 @@ enum http_data_status {
 	HTTP_SERVER_DATA_FINAL = 1,
 };
 
+/** @brief HTTP header representation */
+struct http_header {
+	const char *name;  /**< Pointer to header name NULL-terminated string. */
+	const char *value; /**< Pointer to header value NULL-terminated string. */
+};
+
+/** @brief HTTP response context */
+struct http_response_ctx {
+	enum http_status status;           /** HTTP status code to include in response */
+	const struct http_header *headers; /** Array of HTTP headers */
+	size_t header_count;               /** Length of headers array */
+	const uint8_t *body;               /** Pointer to body data */
+	size_t body_len;                   /** Length of body data */
+	bool final_chunk; /** Flag set to true when the application has no more data to send */
+};
+
 /**
  * @typedef http_resource_dynamic_cb_t
  * @brief Callback used when data is received. Data to be sent to client
@@ -170,6 +187,7 @@ enum http_data_status {
  * @param status HTTP data status, indicate whether more data is expected or not.
  * @param data_buffer Data received.
  * @param data_len Amount of data received.
+ * @param response_ctx
  * @param user_data User specified data.
  *
  * @return >0 amount of data to be sent to client, let server to call this
@@ -181,6 +199,7 @@ typedef int (*http_resource_dynamic_cb_t)(struct http_client_ctx *client,
 					  enum http_data_status status,
 					  uint8_t *data_buffer,
 					  size_t data_len,
+					  struct http_response_ctx *response_ctx,
 					  void *user_data);
 
 /**
@@ -328,12 +347,6 @@ struct http2_frame {
 };
 
 #if defined(CONFIG_HTTP_SERVER_CAPTURE_HEADERS)
-/** @brief HTTP header representation */
-struct http_header {
-	const char *name;  /**< Pointer to header name NULL-terminated string. */
-	const char *value; /**< Pointer to header value NULL-terminated string. */
-};
-
 /** @brief Status of captured headers */
 enum http_header_status {
 	HTTP_HEADER_STATUS_OK,      /**< All available headers were successfully captured. */

samples/net/sockets/http_server/src/main.c

@@ -72,7 +72,8 @@ static struct http_resource_detail_static main_js_gz_resource_detail = {
 };
 
 static int echo_handler(struct http_client_ctx *client, enum http_data_status status,
-			uint8_t *buffer, size_t len, void *user_data)
+			uint8_t *buffer, size_t len, struct http_response_ctx *response_ctx,
+			void *user_data)
 {
 #define MAX_TEMP_PRINT_LEN 32
 	static char print_str[MAX_TEMP_PRINT_LEN];
@@ -98,10 +99,12 @@ static int echo_handler(struct http_client_ctx *client, enum http_data_status st
 		processed = 0;
 	}
 
-	/* This will echo data back to client as the buffer and recv_buffer
-	 * point to same area.
-	 */
-	return len;
+	/* Echo data back to client */
+	response_ctx->body = buffer;
+	response_ctx->body_len = len;
+	response_ctx->final_chunk = (status == HTTP_SERVER_DATA_FINAL);
+
+	return 0;
 }
 
 static struct http_resource_detail_dynamic echo_resource_detail = {
@@ -116,42 +119,30 @@ static struct http_resource_detail_dynamic echo_resource_detail = {
 };
 
 static int uptime_handler(struct http_client_ctx *client, enum http_data_status status,
-			  uint8_t *buffer, size_t len, void *user_data)
+			  uint8_t *buffer, size_t len, struct http_response_ctx *response_ctx,
+			  void *user_data)
 {
-	static bool response_sent;
-
-	LOG_DBG("Uptime handler status %d, response_sent %d", status, response_sent);
-
-	switch (status) {
-	case HTTP_SERVER_DATA_ABORTED: {
-		response_sent = false;
-		return 0;
-	}
+	int ret;
+	static uint8_t uptime_buf[sizeof(STRINGIFY(INT64_MAX))];
 
-	case HTTP_SERVER_DATA_MORE: {
-		/* A payload is not expected with the GET request. Ignore any data and wait until
-		 * final callback before sending response
-		 */
-		return 0;
-	}
+	LOG_DBG("Uptime handler status %d", status);
 
-	case HTTP_SERVER_DATA_FINAL: {
-		if (response_sent) {
-			/* Response already sent, return 0 to indicate to server that the callback
-			 * does not need to be called again.
-			 */
-			response_sent = false;
-			return 0;
+	/* A payload is not expected with the GET request. Ignore any data and wait until
+	 * final callback before sending response
+	 */
+	if (status == HTTP_SERVER_DATA_FINAL) {
+		ret = snprintf(uptime_buf, sizeof(uptime_buf), "%" PRId64, k_uptime_get());
+		if (ret < 0) {
+			LOG_ERR("Failed to snprintf uptime, err %d", ret);
+			return ret;
 		}
 
-		response_sent = true;
-		return snprintf(buffer, sizeof(uptime_buf), "%" PRId64, k_uptime_get());
-	}
-	default: {
-		LOG_WRN("Unexpected status %d", status);
-		return -1;
-	}
+		response_ctx->body = uptime_buf;
+		response_ctx->body_len = ret;
+		response_ctx->final_chunk = true;
 	}
+
+	return 0;
 }
 
 static struct http_resource_detail_dynamic uptime_resource_detail = {
@@ -189,7 +180,8 @@ static void parse_led_post(uint8_t *buf, size_t len)
 }
 
 static int led_handler(struct http_client_ctx *client, enum http_data_status status,
-		       uint8_t *buffer, size_t len, void *user_data)
+		       uint8_t *buffer, size_t len, struct http_response_ctx *response_ctx,
+		       void *user_data)
 {
 	static uint8_t post_payload_buf[32];
 	static size_t cursor;

subsys/net/lib/http/Kconfig

@@ -107,6 +107,17 @@ config HTTP_SERVER_MAX_HEADER_LEN
 	  internal header processing, and only needs to be increased if the
 	  application wishes to access headers of a greater length.
 
+config HTTP_SERVER_HTTP2_MAX_HEADER_FRAME_LEN
+	int "Maximum HTTP/2 response header frame length"
+	default 64
+	range 64 2048
+	help
+	  This setting determines the maximum length of an HTTP/2 header frame
+	  (applies to response headers only, not request headers). The default
+	  value is sufficient for the standard headers included with a response,
+	  and only needs to be increased if the application wishes to send
+	  additional response headers.
+
 config HTTP_SERVER_CAPTURE_HEADERS
 	bool "Allow capturing HTTP headers for application use"
 	help

subsys/net/lib/http/headers/server_internal.h

@@ -43,6 +43,8 @@ void http_server_get_content_type_from_extension(char *url, char *content_type,
 						 size_t content_type_size);
 int http_server_find_file(char *fname, size_t fname_size, size_t *file_size, bool *gzipped);
 void http_client_timer_restart(struct http_client_ctx *client);
+bool http_response_is_final(struct http_response_ctx *rsp, enum http_data_status status);
+bool http_response_is_provided(struct http_response_ctx *rsp);
 
 /* TODO Could be static, but currently used in tests. */
 int parse_http_frame_header(struct http_client_ctx *client, const uint8_t *buffer,

subsys/net/lib/http/http_server_core.c

@@ -290,6 +290,7 @@ static void client_release_resources(struct http_client_ctx *client)
 {
 	struct http_resource_detail *detail;
 	struct http_resource_detail_dynamic *dynamic_detail;
+	struct http_response_ctx response_ctx;
 
 	HTTP_SERVICE_FOREACH(service) {
 		HTTP_SERVICE_FOREACH_RESOURCE(service, resource) {
@@ -315,8 +316,8 @@ static void client_release_resources(struct http_client_ctx *client)
 				continue;
 			}
 
-			dynamic_detail->cb(client, HTTP_SERVER_DATA_ABORTED,
-					   NULL, 0, dynamic_detail->user_data);
+			dynamic_detail->cb(client, HTTP_SERVER_DATA_ABORTED, NULL, 0, &response_ctx,
+					   dynamic_detail->user_data);
 		}
 	}
 }
@@ -784,6 +785,29 @@ int http_server_sendall(struct http_client_ctx *client, const void *buf, size_t
 	return 0;
 }
 
+bool http_response_is_final(struct http_response_ctx *rsp, enum http_data_status status)
+{
+	if (status != HTTP_SERVER_DATA_FINAL) {
+		return false;
+	}
+
+	if (rsp->final_chunk ||
+	    (rsp->status == 0 && rsp->header_count == 0 && rsp->body_len == 0)) {
+		return true;
+	}
+
+	return false;
+}
+
+bool http_response_is_provided(struct http_response_ctx *rsp)
+{
+	if (rsp->status != 0 || rsp->header_count > 0 || rsp->body_len > 0) {
+		return true;
+	}
+
+	return false;
+}
+
 int http_server_start(void)
 {
 	if (server_running) {