initial

felipeagger · felipeagger · commit db3b09a8786d · 2024-12-02T10:27:24.000-03:00
diff --git a/Dockerfile b/Dockerfile
@@ -0,0 +1,24 @@
+FROM alpine:latest AS build
+
+WORKDIR /app
+
+RUN apk add --no-cache \
+    clang \
+    llvm \
+    musl-dev \
+    build-base
+
+COPY . .
+
+# Compile - # clang main.c -o app -static
+RUN make all
+
+# Etapa final: contêiner mínimo para executar o binário
+FROM alpine:latest
+
+WORKDIR /home
+
+COPY --from=build /app/simple-server .
+COPY --from=build /app/epoll-server .
+
+#CMD ["./app"]
diff --git a/Makefile b/Makefile
@@ -0,0 +1,26 @@
+CC = clang
+CFLAGS = -static -lm -Wall -Wextra -O2
+
+# files
+SOURCES = simple-server.c epoll-server.c #uring-server.c
+TARGETS = simple epoll #uring-server
+
+all: $(TARGETS)
+
+# Regras específicas para cada arquivo
+simple: simple-server.c
+	$(CC) -o simple-server simple-server.c request-handle.c cpu-bound.c $(CFLAGS)
+#	$(CC) $(CFLAGS) -o $@ $< -DFILE1_DEFINE
+
+epoll: epoll-server.c
+	$(CC) -o epoll-server epoll-server.c request-handle.c cpu-bound.c $(CFLAGS)
+#	$(CC) $(CFLAGS) -o $@ $< -DFILE2_DEFINE -DADDITIONAL_FLAG
+
+uring: uring-server.c
+#	# $(CC) $(CFLAGS) -o $@ $< -DFILE3_DEFINE -lm
+	$(CC) -g -o uring-server uring-server.c request-handle.c cpu-bound.c $(CFLAGS) -I/usr/local/include -L/usr/local/lib -luring
+#	# musl-gcc -o rest_server rest_server.c -I/usr/local/include -L/usr/local/lib -luring
+
+
+clean:
+	rm -f $(TARGETS)
diff --git a/README.md b/README.md
@@ -0,0 +1,22 @@
+# c-http-server-from-scratch
+
+This is a implementation of Http server using directly Linux SystemCalls.
+
+There are some implementations:
+- simple-server.c: Using only accept syscall.
+- epoll-server.c: Using epoll syscall with 10 events.
+- io_uring.c: TODO.
+
+### Default port is 8080.
+
+# Endpoints:
+- GET /health-check: just return Healthy!
+- GET /api/io-bound: simulate io-bound with sleep
+- GET /api/cpu-bound: simulate cpu-bound with prime numbers
+
+# Params QueryString
+- timeout: in ms (default is 10ms)
+
+# Entrypoints:
+- /home/simple-server
+- /home/epoll-server
diff --git a/epoll-server.c b/epoll-server.c
@@ -0,0 +1,123 @@
+#include <sys/epoll.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include "request-handle.h"
+
+#define PORT 8080
+#define MAX_EVENTS 10
+#define BUFFER_SIZE 1024
+
+int server_fd = -1; // global server socket
+
+void cleanup_and_exit(int signum) {
+    if (server_fd != -1) {
+        printf("\nRecebido sinal %d, fechando o servidor...\n", signum);
+        close(server_fd);
+    }
+    exit(0);
+}
+
+void setup_signal_handler() {
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = cleanup_and_exit;
+    sa.sa_flags = 0;
+
+    // Mascara de sinais vazia
+    sigemptyset(&sa.sa_mask);
+
+    // Configurar para SIGINT (Ctrl+C) e SIGTERM (kill)
+    if (sigaction(SIGINT, &sa, NULL) == -1) {
+        perror("Erro ao configurar SIGINT");
+        exit(EXIT_FAILURE);
+    }
+    if (sigaction(SIGTERM, &sa, NULL) == -1) {
+        perror("Erro ao configurar SIGTERM");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void set_nonblocking(int sock) {
+    int flags = fcntl(sock, F_GETFL, 0);
+    fcntl(sock, F_SETFL, flags | O_NONBLOCK);
+}
+
+int main() {
+    int epoll_fd;
+    struct sockaddr_in server_addr;
+    struct epoll_event event, events[MAX_EVENTS];
+
+    setup_signal_handler();
+
+    // Criar socket
+    server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd < 0) {
+        perror("Erro ao criar socket");
+        exit(EXIT_FAILURE);
+    }
+
+    // Configurar endereço e bind
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port = htons(PORT);
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+        perror("Erro ao associar socket");
+        close(server_fd);
+        exit(EXIT_FAILURE);
+    }
+
+    // Colocar o socket em escuta
+    if (listen(server_fd, MAX_EVENTS) < 0) {
+        perror("Erro ao escutar socket");
+        close(server_fd);
+        exit(EXIT_FAILURE);
+    }
+
+    // Criar epoll
+    epoll_fd = epoll_create1(0);
+    if (epoll_fd == -1) {
+        perror("Erro ao criar epoll");
+        close(server_fd);
+        exit(EXIT_FAILURE);
+    }
+
+    // Adicionar o socket do servidor ao epoll
+    event.events = EPOLLIN; // Monitorar para leitura
+    event.data.fd = server_fd;
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event) < 0) {
+        perror("Erro ao adicionar ao epoll");
+        close(server_fd);
+        close(epoll_fd);
+        exit(EXIT_FAILURE);
+    }
+
+    printf("Servidor ouvindo na porta %d\n", PORT);
+
+    while (1) {
+        int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
+        for (int i = 0; i < n; i++) {
+            if (events[i].data.fd == server_fd) {
+                // Aceitar nova conexão
+                int client_fd = accept(server_fd, NULL, NULL);
+                set_nonblocking(client_fd);
+                event.events = EPOLLIN | EPOLLET;
+                event.data.fd = client_fd;
+                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
+                printf("Nova conexão aceita\n");
+            } else {
+                // process request
+                handle_request(events[i].data.fd);
+            }
+        }
+    }
+
+    close(server_fd);
+    return 0;
+}
diff --git a/request-handle.c b/request-handle.c
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include "cpu-bound.h"
+#include "request-handle.h"
+
+#define BUF_SIZE 1024
+
+
+char* getParamQueryString(char buffer[BUF_SIZE], const char *param_name) {
+    char *query_string = strstr(buffer, "?");
+
+    if (query_string != NULL) {
+        query_string++; // Move o ponteiro para depois do '?'
+        char *param_value = NULL;
+
+        size_t param_name_length = strlen(param_name);
+        char *param_start = strstr(query_string, param_name);
+        
+        if (param_start != NULL && *(param_start + param_name_length) == '=') {
+            param_start += param_name_length + 1; // Move o ponteiro para depois de 'param_name='
+            char *end_of_param = strchr(param_start, '&'); // Encontra o próximo '&' ou fim da string
+            char *end_of_param_fallback = strchr(param_start, ' '); // Encontra o próximo ' ' ou fim da string
+
+            if (end_of_param != NULL) {
+                size_t param_length = end_of_param - param_start; // Calcula o tamanho do valor do parâmetro
+                param_value = malloc(param_length + 1); // Aloca memória para o valor do parâmetro
+                strncpy(param_value, param_start, param_length);
+                param_value[param_length] = '\0'; // Adiciona o terminador nulo
+            } else if (end_of_param_fallback != NULL) {
+                size_t param_length = end_of_param_fallback - param_start; // Calcula o tamanho do valor do parâmetro
+                param_value = malloc(param_length + 1); // Aloca memória para o valor do parâmetro
+                strncpy(param_value, param_start, param_length);
+                param_value[param_length] = '\0';
+            } else {
+                // Se não houver '&', pega até o final da string
+                param_value = strdup(param_start); // Duplica a string até o final
+            }
+        }
+
+        return param_value; // Retorna o valor do parâmetro ou NULL se não encontrado
+    }
+    
+    return NULL;
+}
+
+void handle_request(int client_fd) {
+    char buffer[BUF_SIZE];
+    int bytes_read = read(client_fd, buffer, BUF_SIZE - 1);
+
+    if (bytes_read < 0) {
+        perror("Erro ao ler do cliente");
+        close(client_fd);
+        return;
+    }
+
+    buffer[bytes_read] = '\0'; // Garante que o buffer seja uma string
+    printf("Requisição recebida:\n%s\n", buffer);
+
+    //params
+    char *timeout = getParamQueryString(buffer, "timeout");
+    if (timeout == NULL) {
+        timeout = "10"; // ms
+    }
+
+    const char *response =
+            "HTTP/1.1 200 OK\r\n"
+            "Content-Type: application/json\r\n"
+            "Content-Length: 32\r\n"
+            "\r\n"
+            "{\"message\": \"request completed\"}";
+
+    // Routing
+    if (strstr(buffer, "GET /api/cpu-bound") == buffer) {
+        
+        simulateCPU(atoi(timeout));
+
+        write(client_fd, response, strlen(response));
+
+    } else if (strstr(buffer, "GET /api/io-bound") == buffer) {
+        
+        usleep(atoi(timeout) * 1000);
+
+        write(client_fd, response, strlen(response));
+
+    } else if (strstr(buffer, "GET /health") == buffer) {
+        
+        // response 200
+        char *resp = "HTTP/1.1 200 OK\r\nContent-Length: 8\r\n\r\nHealthy!";
+        write(client_fd, resp, strlen(resp));
+
+    } else {
+        
+        // response 404
+        char *resp = "HTTP/1.1 404 Not Found\r\nContent-Length: 16\r\n\r\nRoute not found!";
+        write(client_fd, resp, strlen(resp));
+    }
+
+    //free(timeout);
+    //free(resp_size);
+    close(client_fd);
+}
diff --git a/request-handle.h b/request-handle.h
@@ -0,0 +1,7 @@
+#ifndef REQUEST_HANDLE_H
+#define REQUEST_HANDLE_H
+
+
+void handle_request(int);
+
+#endif
diff --git a/simple-server.c b/simple-server.c
