Rewrite

2025-07-20 16:46:08 +02:00
parent 939b20abf0
commit 51cae898f8
37 changed files with 7837 additions and 2187 deletions
@@ -0,0 +1,373 @@
+#include "client.h"
+#include "socket.h"
+#include "engine.h"
+#include <stdint.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <stdlib.h>
+
+// TODO
+#include <stdio.h>
+#define ERROR printf("error at %s:%d\n", __FILE__, __LINE__);
+
+#define CLIENT_MAX_CONNS 256
+
+typedef enum {
+    CLIENT_CONNECTION_FREE,
+    CLIENT_CONNECTION_INIT,
+    CLIENT_CONNECTION_WAIT,
+    CLIENT_CONNECTION_DONE,
+} ClientConnectionState;
+
+typedef struct {
+    ClientConnectionState state;
+    uint16_t        gen;
+    Socket          socket;
+    HTTP_Engine     engine;
+    bool            trace;
+} ClientConnection;
+
+struct HTTP_Client {
+    SocketGroup group;
+    int num_conns;
+    ClientConnection conns[CLIENT_MAX_CONNS];
+
+    int ready_head;
+    int ready_count;
+    int ready[CLIENT_MAX_CONNS];
+};
+
+// Rename the memory function
+static void* client_memfunc(HTTP_MemoryFuncTag tag, void *ptr, int len, void *data) {
+    (void)data;
+    switch (tag) {
+        case HTTP_MEMFUNC_MALLOC:
+            return malloc(len);
+        case HTTP_MEMFUNC_FREE:
+            free(ptr);
+            return NULL;
+    }
+    return NULL;
+}
+
+void http_global_init(void)
+{
+    socket_global_init();
+}
+
+void http_global_free(void)
+{
+    socket_global_free();
+}
+
+HTTP_Client *http_client_init(void)
+{
+    HTTP_Client *client = malloc(sizeof(HTTP_Client));
+    if (client == NULL)
+        return NULL;
+
+    if (socket_group_init(&client->group) < 0) {
+        free(client);
+        return NULL;
+    }
+
+    for (int i = 0; i < CLIENT_MAX_CONNS; i++) {
+        client->conns[i].state = CLIENT_CONNECTION_FREE;
+        client->conns[i].gen  = 1;
+    }
+
+    client->num_conns = 0;
+    client->ready_head = 0;
+    client->ready_count = 0;
+
+    return client;
+}
+
+void http_client_free(HTTP_Client *client)
+{
+    for (int i = 0, j = 0; j < client->num_conns; i++) {
+
+        if (client->conns[i].state == CLIENT_CONNECTION_FREE)
+            continue;
+        j++;
+
+        // TODO
+    }
+
+    socket_group_free(&client->group);
+    free(client);
+}
+
+int http_client_request(HTTP_Client *client, HTTP_RequestHandle *handle)
+{
+    if (client->num_conns == CLIENT_MAX_CONNS)
+        return -1;
+
+    int i = 0;
+    while (client->conns[i].state != CLIENT_CONNECTION_FREE)
+        i++;
+
+    client->conns[i].trace = false;
+    client->conns[i].state = CLIENT_CONNECTION_INIT;
+    http_engine_init(&client->conns[i].engine, 1, client_memfunc, NULL);
+
+    client->num_conns++;
+
+    *handle = (HTTP_RequestHandle) { client, i, client->conns[i].gen };
+    return 0;
+}
+
+static void client_connection_update(ClientConnection *conn)
+{
+    HTTP_ASSERT(conn->state == CLIENT_CONNECTION_WAIT);
+
+    socket_update(&conn->socket);
+
+    while (socket_state(&conn->socket) == SOCKET_STATE_ESTABLISHED_READY) {
+
+        HTTP_EngineState engine_state;
+        
+        engine_state = http_engine_state(&conn->engine);
+
+        if (engine_state == HTTP_ENGINE_STATE_CLIENT_RECV_BUF) {
+            int len;
+            char *buf;
+            buf = http_engine_recvbuf(&conn->engine, &len);
+            if (buf) {
+                int ret = socket_read(&conn->socket, buf, len);
+                if (conn->trace)
+                    print_bytes(HTTP_STR(">> "), (HTTP_String) { buf, ret });
+                http_engine_recvack(&conn->engine, ret);
+            }
+        } else if (engine_state == HTTP_ENGINE_STATE_CLIENT_SEND_BUF) {
+            int len;
+            char *buf;
+            buf = http_engine_sendbuf(&conn->engine, &len);
+            if (buf) {
+                int ret = socket_write(&conn->socket, buf, len);
+                if (conn->trace)
+                    print_bytes(HTTP_STR("<< "), (HTTP_String) { buf, ret });
+                http_engine_sendack(&conn->engine, ret);
+            }
+        }
+
+        engine_state = http_engine_state(&conn->engine);
+
+        if (engine_state == HTTP_ENGINE_STATE_CLIENT_CLOSED ||
+            engine_state == HTTP_ENGINE_STATE_CLIENT_READY)
+            socket_close(&conn->socket);
+    }
+
+    if (socket_state(&conn->socket) == SOCKET_STATE_DIED)
+        conn->state = CLIENT_CONNECTION_DONE;
+}
+
+int http_client_wait(HTTP_Client *client, HTTP_RequestHandle *handle)
+{
+    while (client->ready_count == 0) {
+
+        int num_polled = 0;
+        int indices[CLIENT_MAX_CONNS];
+        struct pollfd polled[CLIENT_MAX_CONNS];
+
+        for (int i = 0, j = 0; j < client->num_conns; i++) {
+
+            HTTP_ASSERT(i < CLIENT_MAX_CONNS);
+            ClientConnection *conn = &client->conns[i];
+
+            if (conn->state == CLIENT_CONNECTION_FREE)
+                continue;
+            j++;
+
+            int events = 0;
+            if (conn->state == CLIENT_CONNECTION_WAIT) {
+                switch (conn->socket.event) {
+                    case SOCKET_WANT_READ : events = POLLIN;  break;
+                    case SOCKET_WANT_WRITE: events = POLLOUT; break;
+                    case SOCKET_WANT_NONE : events = 0;       break;
+                }
+            }
+
+            if (events) {
+                indices[num_polled] = i;
+                polled[num_polled].fd = conn->socket.fd;
+                polled[num_polled].events = events;
+                polled[num_polled].revents = 0;
+                num_polled++;
+            }
+        }
+
+        if (num_polled == 0)
+            return -1;
+
+        poll(polled, num_polled, -1);
+
+        for (int i = 0; i < num_polled; i++) {
+
+            int connidx = indices[i];
+            ClientConnection *conn = &client->conns[connidx];
+
+            if (conn->state != CLIENT_CONNECTION_WAIT)
+                continue;
+
+            if (polled[i].revents == 0)
+                continue;
+
+            // TODO: handle error revents
+
+            client_connection_update(conn);
+
+            if (conn->state == CLIENT_CONNECTION_DONE) {
+                int tail = (client->ready_head + client->ready_count) % CLIENT_MAX_CONNS;
+                client->ready[tail] = connidx;
+                client->ready_count++;
+            }
+        }
+    }
+
+    int index = client->ready[client->ready_head];
+    client->ready_head = (client->ready_head + 1) % CLIENT_MAX_CONNS;
+    client->ready_count--;
+    *handle = (HTTP_RequestHandle) { client, index, client->conns[index].gen };
+    return 0;
+}
+
+static ClientConnection *handle2clientconn(HTTP_RequestHandle handle)
+{
+    if (handle.data0 == NULL)
+        return NULL;
+
+    HTTP_Client *client = handle.data0;
+
+    if (handle.data1 >= CLIENT_MAX_CONNS)
+        return NULL;
+
+    ClientConnection *conn = &client->conns[handle.data1];
+
+    if (handle.data2 != conn->gen)
+        return NULL;
+
+    return conn;
+}
+
+void http_request_trace(HTTP_RequestHandle handle, bool trace)
+{
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return;
+    if (conn->state != CLIENT_CONNECTION_INIT)
+        return;
+
+    conn->trace = trace;
+}
+
+void http_request_line(HTTP_RequestHandle handle, HTTP_Method method, HTTP_String url)
+{
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return;
+    if (conn->state != CLIENT_CONNECTION_INIT)
+        return;
+
+    HTTP_Client *client = handle.data0;
+
+    HTTP_URL parsed_url;
+    int ret = http_parse_url(url.ptr, url.len, &parsed_url);
+    if (ret != url.len) {
+        // TODO
+        ERROR;
+        return;
+    }
+
+    bool secure = false;
+    if (http_streq(parsed_url.scheme, HTTP_STR("https"))) {
+        secure = true;
+    } else if (!http_streq(parsed_url.scheme, HTTP_STR("http"))) {
+        // TODO
+        ERROR;
+        return;
+    }
+
+    int port = parsed_url.authority.port;
+    if (port == 0) {
+        if (secure)
+            port = 443;
+        else
+            port = 80;
+    }
+
+    SocketGroup *group = secure ? &client->group : NULL;
+    switch (parsed_url.authority.host.mode) {
+        case HTTP_HOST_MODE_IPV4: socket_connect_ipv4(&conn->socket, group, parsed_url.authority.host.ipv4, port); break;
+        case HTTP_HOST_MODE_IPV6: socket_connect_ipv6(&conn->socket, group, parsed_url.authority.host.ipv6, port); break;
+        case HTTP_HOST_MODE_NAME: socket_connect     (&conn->socket, group, parsed_url.authority.host.name, port); break;
+
+        case HTTP_HOST_MODE_VOID:
+        // TODO
+        ERROR;
+        return;
+    }
+
+    http_engine_url(&conn->engine, method, url, 1);
+}
+
+void http_request_header(HTTP_RequestHandle handle, char *header, int len)
+{
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return;
+    if (conn->state != CLIENT_CONNECTION_INIT)
+        return;
+
+    http_engine_header(&conn->engine, header, len);
+}
+
+void http_request_body(HTTP_RequestHandle handle, char *body, int len)
+{
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return;
+    if (conn->state != CLIENT_CONNECTION_INIT)
+        return;
+
+    http_engine_body(&conn->engine, body, len);
+}
+
+void http_request_submit(HTTP_RequestHandle handle)
+{
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return;
+    if (conn->state != CLIENT_CONNECTION_INIT)
+        return;
+
+    http_engine_done(&conn->engine);
+    conn->state = CLIENT_CONNECTION_WAIT;
+}
+
+HTTP_Response *http_request_result(HTTP_RequestHandle handle)
+{
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return NULL;
+    if (conn->state != CLIENT_CONNECTION_DONE)
+        return NULL;
+    HTTP_EngineState engine_state = http_engine_state(&conn->engine);
+    if (engine_state != HTTP_ENGINE_STATE_CLIENT_READY)
+        return NULL;
+    return http_engine_getres(&conn->engine);
+}
+
+void http_request_free(HTTP_RequestHandle handle)
+{
+    HTTP_Client *client = handle.data0;
+    ClientConnection *conn = handle2clientconn(handle);
+    if (conn == NULL)
+        return;
+    if (conn->state != CLIENT_CONNECTION_DONE)
+        return;
+    http_engine_free(&conn->engine);
+    socket_free(&conn->socket);
+    conn->state = CLIENT_CONNECTION_FREE;
+    client->num_conns--;
+}