/home/mrjunejune/zenbu: seobeo/s

comparison seobeo/s_web.c @ 96:70401cf61e97

[Seobeo] Added logging.

author	June Park <parkjune1995@gmail.com>
date	Fri, 02 Jan 2026 19:16:17 -0800
parents	655ea0b661fd
children	65e5a5b89a4e

comparison

equal deleted inserted replaced

-:b51f8cce9170
+:70401cf61e97
 }
 void Seobeo_Web_HandleClientRequest(Seobeo_Handle  *p_cli_handle,
 Seobeo_Cache_Entry *p_html_cache)
 {
+Seobeo_Log(SEOBEO_INFO, "Client is from %s\n", p_cli_handle->host);
 Dowa_Arena *p_request_arena = Dowa_Arena_Create(1*1024*1024); // 1MB for request parsing
 if (!p_request_arena) { perror("Dowa_Arena_Create request"); goto clean_up; }
-Dowa_Arena *p_response_arena = Dowa_Arena_Create(5*1024*1024); // 1MB for response
+Dowa_Arena *p_response_arena = Dowa_Arena_Create(5*1024*1024); // 5MB for response
 if (!p_response_arena) { perror("Dowa_Arena_Create response"); goto clean_up; }
 void *p_response_header = Dowa_Arena_Allocate(p_response_arena, (size_t)1024*5); // 5Kb
 if (!p_response_header) { perror("Dowa_Arena_Allocate"); goto clean_up; }
-// Parse request headers into hashmap using arena
 Seobeo_Request_Entry *p_req_map = NULL;
 int parse_result = Seobeo_Web_Header_Parse(p_cli_handle, &p_req_map, p_request_arena);
-// Treat EAGAIN (return code 1) as success - headers were parsed, body may still be coming
 if (parse_result != 0 && parse_result != 1)
 {
-printf("ERROR: Seobeo_Web_Header_Parse failed with code %d\n", parse_result);
+Seobeo_Log(SEOBEO_ERROR, "Seobeo_Web_Header_Parse failed with code %d\n", parse_result);
 fflush(stdout);
 Seobeo_Web_Header_Generate(p_response_header,
 HTTP_BAD_REQUEST,
 "text/plain", 0);
 Seobeo_Handle_Queue(p_cli_handle,
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Flush(p_cli_handle);
 goto clean_up;
 }
-printf("DEBUG: Parse completed with code %d\n", parse_result);
+Seobeo_Log(SEOBEO_DEBUG, "Parse completed with code %d\n", parse_result);
 fflush(stdout);
-// Extract method (GET, POST, etc.)
 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;
-printf("DEBUG: Parsed request, method=%s\n", method ? method : "NULL");
+Seobeo_Log(SEOBEO_DEBUG, "Parsed request, method=%s\n", method ? method : "NULL");
 fflush(stdout);
 if (!method)
 {
-printf("ERROR: No HTTP method found in request\n");
+Seobeo_Log(SEOBEO_ERROR, "No HTTP method found in request\n");
 fflush(stdout);
 Seobeo_Web_Header_Generate(p_response_header,
 HTTP_BAD_REQUEST,
 "text/plain", 0);
 Seobeo_Handle_Queue(p_cli_handle,
 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";
-printf("File path: %s\nBody Size: %zu\n", file_path, body_size);
+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);
 (uint32)strlen(p_response_header));
 Seobeo_Handle_Queue(p_cli_handle,
 (const uint8*)file_content,
 (uint32)body_size);
 Seobeo_Handle_Flush(p_cli_handle);
-printf("DONE\n\n\n");
+Seobeo_Log(SEOBEO_DEBUG, "Request handled successfully\n");
 }
 else
 {
 Seobeo_Web_Header_Generate(p_response_header,
 HTTP_FORBIDDEN,
 Seobeo_Handle_Flush(p_cli_handle);
 }
 goto clean_up;
 clean_up:
-printf("clean up\n\n");
+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)
 // Debug: Print the first line of the request
 char *first_line_end = strstr(buf, "\r\n");
 if (first_line_end)
 {
 size_t first_line_len = first_line_end - buf;
-printf("DEBUG: Request line (first %zu bytes): '", first_line_len > 200 ? 200 : first_line_len);
+Seobeo_Log(SEOBEO_DEBUG, "Request line (first %zu bytes)\n", first_line_len > 200 ? 200 : first_line_len);
-fwrite(buf, 1, first_line_len > 200 ? 200 : first_line_len, stdout);
-printf("'\n");
 fflush(stdout);
 }
 // This seems kinda bad ?
 char method[16], path[256], version[16];
 int scan_result = sscanf(buf, "%15s %255s %15s", method, path, version);
-printf("DEBUG: sscanf returned %d (method='%s', path='%s', version='%s')\n",
+Seobeo_Log(SEOBEO_DEBUG, "sscanf returned %d (method='%s', path='%s', version='%s')\n",
 scan_result,
 scan_result >= 1 ? method : "N/A",
 scan_result >= 2 ? path : "N/A",
 scan_result >= 3 ? version : "N/A");
 fflush(stdout);
 if (scan_result != 3)
 {
-printf("ERROR: Failed to parse request line\n");
+Seobeo_Log(SEOBEO_ERROR, "Failed to parse request line\n");
 fflush(stdout);
 return -1;
 }
 // Copy strings to arena and store in hashmap
-printf("DEBUG: Allocating method_copy\n");
+Seobeo_Log(SEOBEO_DEBUG, "Allocating method_copy\n");
 fflush(stdout);
 char *method_copy = Dowa_Arena_Allocate(p_arena, strlen(method) + 1);
-if (!method_copy) { printf("ERROR: Failed to allocate method_copy\n"); return -1; }
+if (!method_copy) { Seobeo_Log(SEOBEO_ERROR, "Failed to allocate method_copy\n"); return -1; }
 strcpy(method_copy, method);
-printf("DEBUG: Allocating version_copy\n");
+Seobeo_Log(SEOBEO_DEBUG, "Allocating version_copy\n");
 fflush(stdout);
 char *version_copy = Dowa_Arena_Allocate(p_arena, strlen(version) + 1);
-if (!version_copy) { printf("ERROR: Failed to allocate version_copy\n"); return -1; }
+if (!version_copy) { Seobeo_Log(SEOBEO_ERROR, "Failed to allocate version_copy\n"); return -1; }
 strcpy(version_copy, version);
-printf("DEBUG: Pushing HTTP_Method and Version to map\n");
+Seobeo_Log(SEOBEO_DEBUG, "Pushing HTTP_Method and Version to map\n");
 fflush(stdout);
 Dowa_HashMap_Push_Arena(*pp_map, "HTTP_Method", method_copy, p_arena);
 Dowa_HashMap_Push_Arena(*pp_map, "Version", version_copy, p_arena);
-printf("DEBUG: Map now has %zu entries\n", Dowa_Array_Length(*pp_map));
+Seobeo_Log(SEOBEO_DEBUG, "Map now has %zu entries\n", Dowa_Array_Length(*pp_map));
 fflush(stdout);
 // 1) Separate raw path and query string
 char *raw_path = path;
 char *query_start = strchr(raw_path, '?');
 if (p_cl_kv)
 {
 const char *content_length_str = ((Seobeo_Request_Entry*)p_cl_kv)->value;
 size_t body_len = atoi(content_length_str);
-printf("DEBUG: Content-Length=%zu, reading body in chunks...\n", body_len);
+Seobeo_Log(SEOBEO_DEBUG, "Content-Length=%zu, reading body in chunks...\n", body_len);
 fflush(stdout);
 // Allocate buffer for entire body
 char *body = Dowa_Arena_Allocate(p_arena, body_len + 1);
 if (!body)
 {
-printf("ERROR: Failed to allocate %zu bytes for body\n", body_len);
+Seobeo_Log(SEOBEO_ERROR, "Failed to allocate %zu bytes for body\n", body_len);
 fflush(stdout);
 return -1;
 }
 size_t total_read = 0;
 {
 memcpy(body + total_read, p_handle->read_buffer, to_copy);
 total_read += to_copy;
 Seobeo_Handle_Consume(p_handle, (uint32)to_copy);
-printf("DEBUG: Copied %zu bytes, total %zu/%zu\n", to_copy, total_read, body_len);
+Seobeo_Log(SEOBEO_DEBUG, "Copied %zu bytes, total %zu/%zu\n", to_copy, total_read, body_len);
 fflush(stdout);
 }
 // If we still need more data, read another chunk
 if (total_read < body_len)
 {
 int r = Seobeo_Handle_Read(p_handle);
 if (r < 0)
 {
-printf("ERROR: Read failed with %d\n", r);
+Seobeo_Log(SEOBEO_ERROR, "Read failed with %d\n", r);
 fflush(stdout);
 return -1;
 }
 if (r == 0)
 {
 }
 }
 }
 body[body_len] = '\0';
-printf("DEBUG: Body fully received (%zu bytes)\n", body_len);
+Seobeo_Log(SEOBEO_DEBUG, "Body fully received (%zu bytes)\n", body_len);
 fflush(stdout);
 // Body is arena-allocated
 Dowa_HashMap_Push_Arena(*pp_map, "Body", body, p_arena);
 }
 Seobeo_Handle *p_server_handle =
 Seobeo_Stream_Handle_Server_Create(NULL, port);
 if (p_server_handle->socket < 0) return 1;
-printf("Listening on port %s\n", port);
+Seobeo_Log(SEOBEO_INFO, "Listening on port %s\n", port);
 // Fork‐based fallback
 if (mode == SEOBEO_MODE_FORK)
 {
-printf("FORK MODE\n");
+Seobeo_Log(SEOBEO_INFO, "Server mode: FORK\n");
 struct sigaction sa;
 sa.sa_handler = SigchildHandler;
 sigemptyset(&sa.sa_mask);
 sa.sa_flags = SA_RESTART;
 sigaction(SIGCHLD, &sa, NULL);
 }
 }
 if (mode == SEOBEO_MODE_EDGE)
 {
-printf("EDGE MODE\n");
+Seobeo_Log(SEOBEO_INFO, "Server mode: EDGE\n");
 Seobeo_Web_Edge(p_server_handle, thread_count, p_html_cache);
 }
 return -1;
 }
 if (!p_request_body) { Seobeo_Handle_Destroy(h); return -1; }
 while (1)
 {
 int n = Seobeo_Handle_Read(h);
-printf("Size: %d\n", n);
+Seobeo_Log(SEOBEO_DEBUG, "Received size: %d bytes\n", n);
 if (n > 0)
 {
 // TODO: Maybe directly use arena inside of the struct? idk if that is useful or not...
 memcpy(p_request_body + used, h->read_buffer, h->read_buffer_len);
 used += h->read_buffer_len;
 continue;
 }else if (n == -2)
 {
 // Debug
 // peer closed; we’ve got everything
-printf("\n\nCLOSED\n\n");
+Seobeo_Log(SEOBEO_DEBUG, "Connection closed by client\n");
 break;
 }else
 {
 Dowa_Arena_Free(p_request_arena);
 Seobeo_Handle_Destroy(h);
 return -1;
 }
 }
 // Debug
-printf("Request body %s", p_request_body);
+Seobeo_Log(SEOBEO_DEBUG, "Request body: %s\n", p_request_body);
 Dowa_Arena_Free(p_request_arena);
 Seobeo_Handle_Destroy(h);
 return 0;
 }
+/* Router logic */
+struct Seobeo_Route_Struct {
+char *method; // "GET", "POST", "PUT", "DELETE"
+char *path_pattern; // "/v1/users/:id/posts/:post_id"
+Seobeo_Route_Handler handler;
+// Pre-parsed path segments for efficient matching
+char **path_segments; // ["v1", "users", ":id", "posts", ":post_id"]
+boolean *is_param; // [false, false, true, false, true]
+size_t segment_count;
+};
+static Seobeo_Route *g_routes = NULL;
+void Seobeo_Router_Init()
+{
+Dowa_Array_Reserve(g_routes, 20);
+}
+void Seobeo_Router_Register(const char *method, const char *path_pattern, Seobeo_Route_Handler handler)
+{
+Seobeo_Route route = {0};
+route.method = strdup(method);
+route.path_pattern = strdup(path_pattern);
+route.handler = handler;
+route.path_segments = Dowa_String_Split(path_pattern, "/", strlen(path_pattern), 1, NULL);
+route.segment_count = Dowa_Array_Length(route.path_segments);
+route.is_param = (boolean*)malloc(sizeof(boolean) * route.segment_count);
+for (size_t i = 0; i < route.segment_count; i++)
+route.is_param[i] = (route.path_segments[i][0] == ':');
+Dowa_Array_Push(g_routes, route);
+}
+// Match route and extract path parameters
+static boolean match_route_and_extract(
+Seobeo_Route *route,
+const char *request_path,
+Seobeo_Request_Entry **pp_request_map,
+Dowa_Arena *p_arena)
+{
+Dowa_Arena *p_temp_arena = Dowa_Arena_Create(1024);
+char **request_segments = Dowa_String_Split(request_path, "/", strlen(request_path), 1, p_temp_arena);
+size_t request_segment_count = Dowa_Array_Length(request_segments);
+// Check segment count matches
+if (request_segment_count != route->segment_count)
+{
+Dowa_Arena_Free(p_temp_arena);
+return FALSE;
+}
+for (size_t i = 0; i < route->segment_count; i++)
+{
+// parameters
+if (route->is_param[i])
+{
+char *param_name = route->path_segments[i];  // e.g., ":id"
+char *param_value = request_segments[i];    // e.g., "123"
+// Should Copy to arena
+char *key = Dowa_String_Copy_Arena(param_name, p_arena);
+char *value = Dowa_String_Copy_Arena(param_value, p_arena);
+Dowa_HashMap_Push_Arena(*pp_request_map, key, value, p_arena);
+}
+else
+{
+// Does not match.
+if (strcmp(route->path_segments[i], request_segments[i]) != 0)
+{
+Dowa_Arena_Free(p_temp_arena);
+return FALSE;
+}
+}
+}
+Dowa_Arena_Free(p_temp_arena);
+return TRUE;
+}
+Seobeo_Route_Handler Seobeo_Router_Find_Handler(const char *method,
+const char *path,
+Seobeo_Request_Entry **pp_request_map,
+Dowa_Arena *p_arena) {
+if (g_routes == NULL)
+{
+return NULL;
+}
+size_t route_count = Dowa_Array_Length(g_routes);
+for (size_t i = 0; i < route_count; i++)
+{
+Seobeo_Route *route = &g_routes[i];
+if (strcmp(route->method, method) != 0)
+{
+continue;
+}
+if (match_route_and_extract(route, path, pp_request_map, p_arena))
+{
+return route->handler;
+}
+}
+return NULL;
+}
+void Seobeo_Router_Send_Response(
+Seobeo_Handle *p_handle,
+Seobeo_Request_Entry *p_response_map,
+Dowa_Arena *p_arena)
+{
+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_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;
+}
+// Header
+int status = HTTP_OK;
+void *p_status_kv = Dowa_HashMap_Get_Ptr(p_response_map, "status");
+if (p_status_kv)
+{
+const char *status_str = ((Seobeo_Request_Entry*)p_status_kv)->value;
+status = atoi(status_str);
+}
+// Body
+const char *body = "";
+void *p_body_kv = Dowa_HashMap_Get_Ptr(p_response_map, "body");
+if (p_body_kv)
+{
+body = ((Seobeo_Request_Entry*)p_body_kv)->value;
+}
+// Default text plain
+const char *content_type = "text/html";
+void *p_content_type_kv = Dowa_HashMap_Get_Ptr(p_response_map, "content-type");
+if (p_content_type_kv)
+{
+content_type = ((Seobeo_Request_Entry*)p_content_type_kv)->value;
+}
+// Check for custom content-length (for binary data)
+size_t body_length = strlen(body);
+void *p_content_length_kv = Dowa_HashMap_Get_Ptr(p_response_map, "content-length");
+if (p_content_length_kv)
+{
+const char *content_length_str = ((Seobeo_Request_Entry*)p_content_length_kv)->value;
+body_length = atoi(content_length_str);
+}
+// All other types are default thoguht to be headers.
+char *header = Dowa_Arena_Allocate(p_arena, 4096);
+Seobeo_Web_Header_Generate(header, status, content_type, body_length);
+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")  // Skip custom content-length
+)
+continue;
+int32 current_header_len = strlen(header);
+char *temp = malloc(sizeof(char) * 1024);
+sprintf(temp, "%s: %s\r\n\r\n", p_response_map[i].key, p_response_map[i].value);
+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);  // Use actual body length
+Seobeo_Handle_Flush(p_handle);
+}
+void Seobeo_Router_Destroy()
+{
+if (g_routes == NULL)
+return;
+size_t route_count = Dowa_Array_Length(g_routes);
+for (size_t i = 0; i < route_count; i++)
+{
+Seobeo_Route *route = &g_routes[i];
+if (route->method) free(route->method);
+if (route->path_pattern) free(route->path_pattern);
+if (route->path_segments) Dowa_Array_Free(route->path_segments);
+if (route->is_param) free(route->is_param);
+}
+Dowa_Array_Free(g_routes);
+g_routes = NULL;
+}
+static char *Seobeo_Log_Level_String(Seobeo_Log_Level level)
+{
+switch(level) {
+case SEOBEO_DEBUG:   return "DEBUG";
+case SEOBEO_INFO:    return "INFO";
+case SEOBEO_WARNING: return "WARNING";
+case SEOBEO_ERROR:   return "ERROR";
+default:          return "INFO";
+}
+}
+int Seobeo_Log(Seobeo_Log_Level level, const char * restrict format, ...)
+{
+#ifndef SEOBEO_ENABLE_DEBUG
+if (level == SEOBEO_DEBUG)
+return 0;
+#endif
+int result;
+va_list args;
+printf("[%s] ", Seobeo_Log_Level_String(level));
+va_start(args, format);
+result = vprintf(format, args);
+va_end(args);
+return result;
+}

Mercurial

comparison seobeo/s_web.c @ 96:70401cf61e97