Add Bounded Ordinary HTTPS Idle Cleanup

tests/web_httpd_idle/fakes.h

@@ -0,0 +1,84 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <errno.h>
+
+typedef int esp_err_t;
+enum { ESP_OK, ESP_FAIL, ESP_ERR_INVALID_ARG, ESP_ERR_INVALID_STATE,
+       ESP_ERR_NO_MEM, ESP_ERR_TIMEOUT, ESP_ERR_NOT_SUPPORTED };
+typedef void *httpd_handle_t;
+typedef struct { int unused; } httpd_uri_t;
+struct httpd_req_aux;
+typedef struct { httpd_handle_t handle; struct httpd_req_aux *aux; } httpd_req_t;
+struct sock_db {
+    int fd; uint64_t lru_counter; bool for_async_req, ws_handshake_done, ws_close;
+    size_t pending_len; int (*pending_fn)(httpd_handle_t, int);
+};
+struct httpd_req_aux { struct sock_db *sd; size_t remaining_len; };
+struct httpd_data {
+    struct { unsigned max_open_sockets; } config;
+    struct { void *handle; } hd_td;
+    struct sock_db *hd_sd;
+    struct httpd_req_aux hd_req_aux;
+    httpd_req_t hd_req;
+    uint64_t lru_counter;
+};
+static bool owner;
+static unsigned lock_depth, shutdown_calls, select_calls;
+static int shutdown_error, select_error, tls_pending[FD_SETSIZE];
+static int64_t now_us;
+static void *httpd_os_thread_handle(void) { return owner ? (void *)1 : (void *)2; }
+typedef int portMUX_TYPE;
+#define portMUX_INITIALIZER_UNLOCKED 0
+#define taskENTER_CRITICAL(lock) do { (void)(lock); assert(!lock_depth); ++lock_depth; } while (0)
+#define taskEXIT_CRITICAL(lock) do { (void)(lock); assert(lock_depth == 1); --lock_depth; } while (0)
+static int64_t esp_timer_get_time(void) { assert(!lock_depth); return now_us; }
+static void (*delay_hook)(void);
+static void vTaskDelay(int ticks) { assert(!lock_depth && ticks == 1); now_us += 100000; if (delay_hook) delay_hook(); }
+typedef void *esp_timer_handle_t;
+typedef struct { void (*callback)(void *); const char *name; bool skip_unhandled_events; } esp_timer_create_args_t;
+static esp_err_t timer_create_error, timer_start_error, queue_error;
+static unsigned timer_creates, timer_starts, timer_deletes, queue_calls;
+static void (*timer_callback)(void *), (*queued_work)(void *);
+static void *queued_arg;
+static void (*queue_hook)(void);
+static bool inline_work;
+static esp_err_t esp_timer_create(const esp_timer_create_args_t *args, esp_timer_handle_t *timer) {
+    assert(!lock_depth && args->skip_unhandled_events); ++timer_creates;
+    if (timer_create_error) return timer_create_error;
+    timer_callback = args->callback; *timer = (void *)3; return ESP_OK;
+}
+static esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, int64_t period) {
+    assert(!lock_depth && timer && period == 1000000); ++timer_starts; return timer_start_error;
+}
+static esp_err_t esp_timer_delete(esp_timer_handle_t timer) { assert(!lock_depth && timer); ++timer_deletes; return ESP_OK; }
+static esp_err_t httpd_queue_work(httpd_handle_t, void (*)(void *), void *);
+typedef struct { int fd; bool get_error; } esp_tls_t;
+enum { HTTPD_SSL_USER_CB_SESS_CREATE, HTTPD_SSL_USER_CB_SESS_CLOSE };
+typedef struct { esp_tls_t *tls; unsigned user_cb_state; } esp_https_server_user_cb_arg_t;
+static esp_err_t esp_tls_get_conn_sockfd(esp_tls_t *tls, int *fd) {
+    assert(owner && !lock_depth); *fd = tls->fd; return tls->get_error ? ESP_FAIL : ESP_OK;
+}
+static int test_select(int n, fd_set *r, fd_set *w, fd_set *e, struct timeval *t) {
+    assert(owner && !lock_depth && !w && !e && t && !t->tv_sec && !t->tv_usec);
+    ++select_calls; return select_error ? -1 : select(n, r, w, e, t);
+}
+static int test_shutdown(int fd, int how) {
+    assert(owner && !lock_depth && how == SHUT_RDWR); ++shutdown_calls;
+    return shutdown_error ? -1 : shutdown(fd, how);
+}
+#define select test_select
+#define shutdown test_shutdown
+#define CONFIG_HTTPD_PURGE_BUF_LEN 32
+#define ESP_LOGD(...) ((void)0)
+#define ESP_LOG_BUFFER_HEX_LEVEL(...) ((void)0)
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+static esp_err_t httpd_req_new(struct httpd_data *, struct sock_db *);
+static int httpd_req_recv(httpd_req_t *, char *, size_t);
+static void httpd_req_cleanup(httpd_req_t *);