feat: added list

core/src/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(CORE_SRC
+  list.c
   log.c
   hash_table.c
   http_server.c

core/src/http_server.c

@@ -1,7 +1,74 @@
 #include "http_server.h"
+#include "thread_util.h"
+#include <netinet/in.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/socket.h>
+#include <unistd.h>
+
+void worker() {
+  // TODO: wait for data in queue
+  // TODO: parse url in search route handler in hash table
+}
+
+static void prepare_workers(http_server_p server, http_server_config_t config) {
+  if (config.workers_count == 0) {
+    server->workers_count = get_core_count();
+  } else {
+    server->workers_count = config.workers_count;
+  }
+
+  server->workers = calloc(server->workers_count, sizeof(pthread_t));
+
+  for (size_t i = 0; i < server->workers_count; i++) {
+    pthread_create(&server->workers[i], NULL, (void *)&worker, NULL);
+  }
+}
+
+static int32_t initialize_socket(http_server_p server,
+                                 http_server_config_t *config) {
+  struct sockaddr_in server_addr;
+
+  memset(&server_addr, 0, sizeof(struct sockaddr_in));
+
+  if ((server->socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+    return -1;
+  }
+
+  server_addr.sin_family = AF_INET;
+  server_addr.sin_addr.s_addr = INADDR_ANY;
+  server_addr.sin_port = htons(config->port);
+
+  if (bind(server->socket_fd, (struct sockaddr *)&server_addr,
+           sizeof(struct sockaddr_in)) < 0) {
+    return -1;
+  }
+
+  return 0;
+}
 
 http_server_p http_server_init(http_server_config_t config) {
   http_server_p server;
-  struct sockaddr_in server_addr;
+
+  server = calloc(1, sizeof(http_server_t));
+
+  if (!initialize_socket(server, &config)) {
+    return NULL;
+  }
+
+  return server;
+}
+
+void http_server_stop(http_server_p server) {
+
+  // TODO: Make sure socket was properly closed before closing descriptor
+  for (size_t i = 0; i < server->workers_count; i++) {
+    pthread_cancel(server->workers[i]);
+    pthread_join(server->workers[i], NULL);
+  }
+  free(server->workers);
+
+  close(server->socket_fd);
+  free(server);
 }

core/src/http_server.h

@@ -1,14 +1,24 @@
 #ifndef HTTP_SERVER_H
 #define HTTP_SERVER_H
 
+#include "list.h"
+#include <pthread.h>
+#include <stddef.h>
 #include <stdint.h>
 
 typedef struct {
-  int32_t port;
+  uint16_t port;
+  size_t workers_count;
 } http_server_config_t;
 
 typedef struct {
   int32_t socket_fd;
+  pthread_t *workers;
+  size_t workers_count;
+
+  // Requests queue
+  list_t queue_list;
+  pthread_mutex_t queue_mt;
 } http_server_t, *http_server_p;
 
 http_server_p http_server_init(http_server_config_t config);

core/src/list.c

@@ -0,0 +1,100 @@
+#include "list.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+list_t *list_init(size_t type_size, size_t capacity) {
+  list_t *list;
+
+  list = calloc(1, sizeof(list_t));
+  if (!list) {
+    return NULL;
+  }
+
+  list->real_capacity = capacity * 2;
+
+  list->data = calloc(1, sizeof(type_size * list->real_capacity));
+  if (!list) {
+    free(list);
+    return NULL;
+  }
+
+  list->capacity = capacity;
+  list->type_size = type_size;
+
+  return list;
+}
+
+list_error_e list_get_last_error(list_t *list) {
+  list_error_e error = list->error;
+
+  list->error = LIST_NONE;
+
+  return error;
+}
+
+void list_resize(list_t *list, size_t new_capacity) {
+  void *new_data = calloc(new_capacity * 2, list->type_size);
+
+  if (!new_data) {
+    list->error = LIST_MEM;
+    return;
+  }
+
+  memcpy(new_data, list->data, list->type_size * list->capacity);
+  free(list->data);
+  list->data = new_data;
+}
+
+void list_append(list_t *list, void *value) {
+  if (list->capacity + 1 > list->real_capacity) {
+    list_resize(list, list->real_capacity * 2);
+  }
+
+  list->capacity++;
+  list_set(list, list->capacity, value);
+}
+
+void list_set(list_t *list, size_t idx, void *value) {
+  if (idx > list->capacity) {
+    list->error = LIST_OOR;
+    return;
+  }
+
+  memcpy(list->data + (idx * list->type_size), value, list->type_size);
+}
+
+void *list_get(list_t *list, size_t idx) {
+  if (idx <= list->capacity) {
+    return &list->data[idx];
+  }
+
+  list->error = LIST_OOR;
+
+  return NULL;
+}
+
+void list_remove(list_t *list, size_t idx) {
+  if (idx > list->capacity) {
+    list->error = LIST_OOR;
+
+    return;
+  }
+
+  if (idx == list->capacity) {
+    list->capacity -= 1;
+  }
+
+  if (idx < list->capacity) {
+    memcpy(list->data + (idx * list->type_size),
+           list->data + ((idx + 1) * list->type_size),
+           (list->capacity - idx) * list->type_size);
+  }
+}
+
+size_t list_size(list_t *list) { return list->capacity; }
+
+void list_deinit(list_t *list) {
+  free(list->data);
+  free(list);
+}

core/src/list.h

@@ -0,0 +1,31 @@
+#ifndef LIST_H
+#define LIST_H
+
+#include <stddef.h>
+
+typedef enum {
+  LIST_NONE = 0,
+  LIST_MEM,
+  LIST_OOR, // Out of range
+} list_error_e;
+
+typedef struct {
+  void *data;
+  size_t type_size;
+  size_t capacity;
+  size_t real_capacity;
+
+  list_error_e error;
+} list_t;
+
+list_t *list_init(size_t type_size, size_t capacity);
+list_error_e list_get_last_error(list_t *list);
+void list_resize(list_t *list, size_t new_capacity);
+void list_append(list_t *list, void *value);
+void list_set(list_t *list, size_t idx, void *value);
+void *list_get(list_t *list, size_t idx);
+void list_remove(list_t *list, size_t idx);
+size_t list_size(list_t *list);
+void list_deinit(list_t *list);
+
+#endif // !LIST_H