/home/mrjunejune/zenbu: seobeo/s

comparison seobeo/s_web.c @ 183:a8976a008a9d

[BenchMark] Added bun bench mark to test seoboe vs other popular benchmarks.

author	MrJuneJune <me@mrjunejune.com>
date	Fri, 23 Jan 2026 21:19:08 -0800
parents	bdcc610eeed8
children	8c74204fd362

comparison

equal deleted inserted replaced

-:8d17f6e6e290
+:a8976a008a9d
 #include "seobeo/seobeo.h"
+#include <strings.h>  // for strcasecmp
+#include <time.h>     // for time_t
 static char g_folder_path[512] = ".";
 char* Seobeo_Web_LoadFile(const char *file_path, size_t *p_file_size)
 {
 }
 void Seobeo_Web_Header_Generate(
 void *buffer, int status,
 const char *content_type, const int content_length)
+{
+Seobeo_Web_Header_Generate_KeepAlive(buffer, status, content_type, content_length, FALSE);
+}
+void Seobeo_Web_Header_Generate_KeepAlive(
+void *buffer, int status,
+const char *content_type, const int content_length,
+boolean keep_alive)
 {
 const char *status_text;
 switch(status)
 {
 case HTTP_OK: status_text = "OK"; break;
 case HTTP_FORBIDDEN: status_text = "Forbidden"; break;
 case HTTP_NOT_FOUND: status_text = "Not Found"; break;
 case HTTP_INTERNAL_ERROR: status_text = "Internal Server Error"; break;
 default: status_text = "Unknown"; break;
 }
 sprintf(
 buffer,
 "HTTP/1.1 %d %s\r\n"
 "Content-Type: %s\r\n"
 "Content-Length: %d\r\n"
-"Connection: close\r\n"
+"Connection: %s\r\n"
 "\r\n",
-status, status_text, content_type, content_length
+status, status_text, content_type, content_length,
+keep_alive ? "keep-alive" : "close"
 );
 }
-void Seobeo_Web_HandleClientRequest(Seobeo_Handle  *p_cli_handle,
+// Default arena size (5MB) - will allocate more if Content-Length requires it
-Seobeo_Cache_Entry *p_html_cache)
+#define DEFAULT_ARENA_SIZE (5 * 1024 * 1024)
-{
-// TODO: This should be splitted up instead of handling up to 50 MB as it will fail more often...
+// Helper to check if Connection header contains a specific value (case-insensitive)
-Dowa_Arena *p_request_arena = Dowa_Arena_Create(50*1024*1024); // 50 MB because of files...
+static boolean connection_header_contains(const char *header_value, const char *target)
-if (!p_request_arena) { perror("Dowa_Arena_Create request"); goto clean_up; }
+{
+if (!header_value || !target) return FALSE;
-Dowa_Arena *p_response_arena = Dowa_Arena_Create(50*1024*1024); // 50 MB for response
-if (!p_response_arena) { perror("Dowa_Arena_Create response"); goto clean_up; }
+// Make a copy to tokenize
+char *copy = strdup(header_value);
+if (!copy) return FALSE;
+boolean found = FALSE;
+char *token = strtok(copy, ", \t");
+while (token) {
+if (strcasecmp(token, target) == 0) {
+found = TRUE;
+break;
+}
+token = strtok(NULL, ", \t");
+}
+free(copy);
+return found;
+}
+// Returns TRUE if connection should be kept alive, FALSE if it should be closed
+boolean Seobeo_Web_ClientHandle_Request(Seobeo_Handle *p_cli_handle,
+Seobeo_Cache_Entry *p_html_cache,
+boolean use_keep_alive)
+{
+boolean should_keep_alive = FALSE;
+// Start with default arena size (5MB)
+size_t arena_size = DEFAULT_ARENA_SIZE;
+// We'll peek at Content-Length to potentially allocate larger arena
+// For now, start with default and handle body reading separately
+Dowa_Arena *p_request_arena = Dowa_Arena_Create(arena_size);
+if (!p_request_arena) { perror("Dowa_Arena_Create request"); return FALSE; }
+Dowa_Arena *p_response_arena = Dowa_Arena_Create(arena_size);
+if (!p_response_arena) { perror("Dowa_Arena_Create response"); Dowa_Arena_Free(p_request_arena); return FALSE; }
 void *p_response_header = Dowa_Arena_Allocate(p_response_arena, 1024*5); // 5Kb
-if (!p_response_header) { perror("Dowa_Arena_Allocate"); goto clean_up; }
+if (!p_response_header) { perror("Dowa_Arena_Allocate"); goto clean_up_arenas; }
 Seobeo_Request_Entry *p_req_map = NULL;
 int parse_result = Seobeo_Web_Header_Parse(p_cli_handle, &p_req_map, p_request_arena);
-if (parse_result != 0 && parse_result != 1)
+// Handle parse errors
-{
+if (parse_result < 0) {
-Seobeo_Log(SEOBEO_ERROR, "Seobeo_Web_Header_Parse failed with code %d\n", parse_result);
+// Fatal error or connection closed
+Seobeo_Log(SEOBEO_DEBUG, "Seobeo_Web_Header_Parse failed with code %d\n", parse_result);
+if (parse_result == -2) {
+// Connection closed by client - don't send error response
+goto clean_up_arenas;
+}
 Seobeo_Web_Header_Generate(p_response_header,
 HTTP_BAD_REQUEST,
 "text/plain", 0);
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)p_response_header,
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Flush(p_cli_handle);
-goto clean_up;
+goto clean_up_arenas;
 }
-Seobeo_Log(SEOBEO_DEBUG, "Parse completed with code %d\n", parse_result);
+// Determine keep-alive based on HTTP version and Connection header
+// HTTP/1.1: keep-alive by default unless "Connection: close"
-// Recording IP to see who is ddosing or any web scrappers...
+// HTTP/1.0: close by default unless "Connection: keep-alive"
-void *p_real_ip_kv = Dowa_HashMap_Get_Ptr(p_req_map, "X-Real-IP");
-const char *real_ip = p_real_ip_kv ? ((Seobeo_Request_Entry*)p_real_ip_kv)->value : NULL;
+void *p_ver_kv = Dowa_HashMap_Get_Ptr(p_req_map, "Version");
-// Fallback
+const char *http_version = p_ver_kv ? ((Seobeo_Request_Entry*)p_ver_kv)->value : "HTTP/1.0";
-if (!real_ip)
+boolean is_http11 = (strstr(http_version, "1.1") != NULL);
-{
-void *p_forwarded_kv = Dowa_HashMap_Get_Ptr(p_req_map, "X-Forwarded-For");
+void *p_conn_kv = Dowa_HashMap_Get_Ptr(p_req_map, "Connection");
-real_ip = p_forwarded_kv ? ((Seobeo_Request_Entry*)p_forwarded_kv)->value : NULL;
+const char *conn_header = p_conn_kv ? ((Seobeo_Request_Entry*)p_conn_kv)->value : NULL;
-}
-// Fallback
+if (conn_header) {
-if (!real_ip)
+// Explicit Connection header - check for keep-alive or close
-real_ip = p_cli_handle->host;
+if (connection_header_contains(conn_header, "close")) {
+should_keep_alive = FALSE;
+} else if (connection_header_contains(conn_header, "keep-alive")) {
+should_keep_alive = use_keep_alive;
+} else {
+// Unknown value, use version default
+should_keep_alive = is_http11 && use_keep_alive;
+}
+} else {
+// No Connection header - use HTTP version defaults
+should_keep_alive = is_http11 && use_keep_alive;
+}
 void *p_method_kv = Dowa_HashMap_Get_Ptr(p_req_map, "HTTP_Method");
 const char *method = p_method_kv ? ((Seobeo_Request_Entry*)p_method_kv)->value : NULL;
-void *p_path_kv_log = Dowa_HashMap_Get_Ptr(p_req_map, "Path");
+void *p_path_kv = Dowa_HashMap_Get_Ptr(p_req_map, "Path");
-const char *path_log = p_path_kv_log ? ((Seobeo_Request_Entry*)p_path_kv_log)->value : "/";
+const char *path = p_path_kv ? ((Seobeo_Request_Entry*)p_path_kv)->value : "/";
-Seobeo_Log(SEOBEO_INFO, "%s - %s %s\n",
-real_ip ? real_ip : "unknown",
-method ? method : "UNKNOWN",
-path_log);
-Seobeo_Log(SEOBEO_DEBUG, "Parsed request, method=%s\n", method ? method : "NULL");
 if (!method)
 {
-Seobeo_Log(SEOBEO_ERROR, "No HTTP method found in request\n");
+Seobeo_Log(SEOBEO_DEBUG, "No HTTP method found in request\n");
 Seobeo_Web_Header_Generate(p_response_header,
 HTTP_BAD_REQUEST,
 "text/plain", 0);
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)p_response_header,
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Flush(p_cli_handle);
-goto clean_up;
+should_keep_alive = FALSE;
-}
+goto clean_up_arenas;
+}
-void *p_path_kv = Dowa_HashMap_Get_Ptr(p_req_map, "Path");
-const char *path = p_path_kv ? ((Seobeo_Request_Entry*)p_path_kv)->value : "/";
 // --- Check for WebSocket upgrade request ---
 #ifdef SEOBEO_WEBSOCKET_SERVER
-Seobeo_Log(SEOBEO_DEBUG, "Web soceket path \n");
 if (Seobeo_WebSocket_Server_Handle_Upgrade(p_cli_handle, p_req_map, path))
 {
 Seobeo_Log(SEOBEO_INFO, "WebSocket connection established\n");
-if (p_request_arena)
+Dowa_Arena_Free(p_request_arena);
-Dowa_Arena_Free(p_request_arena);
+Dowa_Arena_Free(p_response_arena);
-if (p_response_arena)
+return FALSE; // WebSocket takes over, don't keep-alive in HTTP sense
-Dowa_Arena_Free(p_response_arena);
-return;
 }
 #endif
 // --- Try to match API route first ---
 Seobeo_Route_Handler handler = Seobeo_Router_Find_Handler(method, path, &p_req_map, p_request_arena);
 if (handler != NULL)
 {
 Seobeo_Request_Entry *p_response_map = handler(p_req_map, p_response_arena);
-Seobeo_Router_Send_Response(p_cli_handle, p_response_map, p_response_arena);
+Seobeo_Router_Send_Response_KeepAlive(p_cli_handle, p_response_map, p_response_arena, should_keep_alive);
-goto clean_up;
+goto clean_up_arenas;
 }
-// --- Static files fallback for GET ---
+// --- Static files fallback for GET (use original large arena logic) ---
 if (strcmp(method, "GET") == 0)
 {
-void *p_kv = Dowa_HashMap_Get_Ptr(p_req_map, "Path");
+char *file_path = Dowa_Arena_Allocate(p_response_arena, (size_t)5 * 1024);
-const char *path = p_kv ? ((Seobeo_Request_Entry*)p_kv)->value : NULL;
-char *file_path = Dowa_Arena_Allocate(p_response_arena, (size_t)5 * 1024); // 5Kb only for path
 if (!path || strcmp(path, "/") == 0)
 {
 strcpy(file_path, "index.html");
 }
 }
 else
 strcpy(file_path, path);
 }
-// Check if file is in cache, load if not
 void *p_file_kv = Dowa_HashMap_Get_Ptr(p_html_cache, file_path);
 const char *file_content = NULL;
 size_t body_size = 0;
 if (p_file_kv)
 {
-// File is cached - use stored size for binary file support
 Seobeo_Cached_File *cached = ((Seobeo_Cache_Entry*)p_file_kv)->value;
 file_content = cached->content;
 body_size = cached->size;
 }
 else
 }
 }
 if (!file_content)
 {
-Seobeo_Web_Header_Generate(p_response_header,
+Seobeo_Web_Header_Generate_KeepAlive(p_response_header,
 HTTP_NOT_FOUND,
-"text/html", 0);
+"text/html", 0, should_keep_alive);
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)p_response_header,
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Flush(p_cli_handle);
-goto clean_up;
+goto clean_up_arenas;
 }
-Seobeo_Log(SEOBEO_DEBUG, "Serving Static Files\n");
-// Serve static file
 const char *mime = "application/octet-stream";
 if (strstr(file_path, ".html")) mime = "text/html; charset=utf-8";
 else if (strstr(file_path, ".css")) mime = "text/css";
 else if (strstr(file_path, ".js")) mime = "application/javascript";
 else if (strstr(file_path, ".png")) mime = "image/png";
 else if (strstr(file_path, ".jpg") || strstr(file_path, ".jpeg")) mime = "image/jpeg";
-else if (strstr(file_path, ".webp")) mime = "image/webp";
-else if (strstr(file_path, ".gif")) mime = "image/gif";
-else if (strstr(file_path, ".svg")) mime = "image/svg+xml";
-else if (strstr(file_path, ".ico")) mime = "image/x-icon";
 else if (strstr(file_path, ".json")) mime = "application/json";
-else if (strstr(file_path, ".wasm")) mime = "application/wasm";
-else if (strstr(file_path, ".mp4")) mime = "video/mp4";
+Seobeo_Web_Header_Generate_KeepAlive(p_response_header,
-else if (strstr(file_path, ".webm")) mime = "video/webm";
-else if (strstr(file_path, ".glb")) mime = "model/gltf-binary";
-else if (strstr(file_path, ".gltf")) mime = "model/gltf+json";
-Seobeo_Log(SEOBEO_DEBUG, "File path: %s\nBody Size: %zu\n", file_path, body_size);
-Seobeo_Web_Header_Generate(p_response_header,
 HTTP_OK,
 mime,
-body_size);
+body_size, should_keep_alive);
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)p_response_header,
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)file_content,
 (uint32)body_size);
 Seobeo_Handle_Flush(p_cli_handle);
-Seobeo_Log(SEOBEO_DEBUG, "Request handled successfully\n");
 }
 else
 {
-Seobeo_Web_Header_Generate(p_response_header,
+Seobeo_Web_Header_Generate_KeepAlive(p_response_header,
-HTTP_FORBIDDEN,
+HTTP_NOT_FOUND,
-"text/plain", 0);
+"text/plain", 0, should_keep_alive);
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)p_response_header,
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Flush(p_cli_handle);
 }
-goto clean_up;
+clean_up_arenas:
-clean_up:
-Seobeo_Log(SEOBEO_INFO, "Clean up all Arenas\n");
-if (p_cli_handle)
-Seobeo_Handle_Destroy(p_cli_handle);
 if (p_request_arena)
 Dowa_Arena_Free(p_request_arena);
 if (p_response_arena)
 Dowa_Arena_Free(p_response_arena);
-return;
+return should_keep_alive;
 }
 int Seobeo_Web_Header_Parse(Seobeo_Handle *p_handle, Seobeo_Request_Entry **pp_map, Dowa_Arena *p_arena)
 {
 while (1)
 {
 Seobeo_Stream_Handle_Server_Accept(p_server_handle);
 if (!p_cli_handle) continue;
 if (fork() == 0)
 {
-Seobeo_Web_HandleClientRequest(p_cli_handle,
+Seobeo_Web_ClientHandle_Request(p_cli_handle, p_html_cache, FALSE);
-p_html_cache);
 _exit(0);
 }
 }
 }
 void Seobeo_Router_Send_Response(
 Seobeo_Handle *p_handle,
 Seobeo_Request_Entry *p_response_map,
 Dowa_Arena *p_arena)
 {
+Seobeo_Router_Send_Response_KeepAlive(p_handle, p_response_map, p_arena, FALSE);
+}
+void Seobeo_Router_Send_Response_KeepAlive(
+Seobeo_Handle *p_handle,
+Seobeo_Request_Entry *p_response_map,
+Dowa_Arena *p_arena,
+boolean keep_alive)
+{
 if (p_response_map == NULL)
 {
 char *header = Dowa_Arena_Allocate(p_arena, 1024);
-Seobeo_Web_Header_Generate(header, HTTP_INTERNAL_ERROR, "text/plain", 21);
+Seobeo_Web_Header_Generate_KeepAlive(header, HTTP_INTERNAL_ERROR, "text/plain", 21, keep_alive);
 Seobeo_Handle_Queue(p_handle, (uint8_t*)header, strlen(header));
 Seobeo_Handle_Queue(p_handle, (uint8_t*)"Internal Server Error", 21);
 Seobeo_Handle_Flush(p_handle);
 return;
 }
 const char *content_length_str = ((Seobeo_Request_Entry*)p_content_length_kv)->value;
 body_length = atoi(content_length_str);
 }
 char *header = Dowa_Arena_Allocate(p_arena, 4096);
-Seobeo_Web_Header_Generate(header, status, content_type, body_length);
+Seobeo_Web_Header_Generate_KeepAlive(header, status, content_type, body_length, keep_alive);
 for (int i = 0; i < Dowa_Array_Length(p_response_map); i++)
 {
 if (
 strstr(p_response_map[i].key, "status") ||
 strstr(p_response_map[i].key, "body") ||
 strstr(p_response_map[i].key, "content-type") ||
 strstr(p_response_map[i].key, "content-length")
 )
 continue;
 int32 current_header_len = strlen(header);
 char *temp = malloc(sizeof(char) * 1024);
 memcpy(&header[current_header_len - 2 /* \r\n */], temp, strlen(temp));
 free(temp);
 }
 Seobeo_Handle_Queue(p_handle, (uint8_t*)header, strlen(header));
 Seobeo_Handle_Queue(p_handle, (uint8_t*)body, body_length);
 Seobeo_Handle_Flush(p_handle);
 }
 void Seobeo_Router_Destroy()
 {

Mercurial

comparison seobeo/s_web.c @ 183:a8976a008a9d