Non blocking + Multi-threaded

#define _GNU_SOURCE
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <stdatomic.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/sysinfo.h>

#define NUM_EVENTS 64
#define READ_BUFFER (64 * 1024)
#define RESPONSE "HTTP/1.1 200 Ok\r\nContent-Length: 11\r\n\r\nHello World"

int find_clrf(const char* buffer, int len) {
    const char* start_buffer = buffer;
    for (; len >= sizeof(int); len--, buffer++)
        if (*((int*)buffer) == *(int*)"\r\n\r\n")
            return buffer - start_buffer;
    return -1;
}

typedef struct {
    int value;
    char padding[64 - sizeof(int)];
} Lock;
int efd, server;
Lock locks[1024] = { 0 };

void* worker(void* arg) {
    char buffer[READ_BUFFER];
    struct epoll_event events[NUM_EVENTS];
    while (1) {
        int n = epoll_wait(efd, events, NUM_EVENTS, -1);
        for (int i = 0; i < n; i++) {
            int* fd_lock = &locks[events[i].data.fd].value;
            int client, expect,
                fd = events[i].data.fd,
                error = events[i].events & (EPOLLHUP | EPOLLERR);
            if (error || atomic_exchange_explicit(fd_lock, 1, memory_order_acquire) != 0) {
                if (error) close(fd);
                continue;
            }

            do {
                expect = 2;
                atomic_store_explicit(fd_lock, expect, memory_order_relaxed);
                if (fd == server) {
                    while ((client = accept4(server, NULL, NULL, SOCK_NONBLOCK)) > 0) {
                        int opt = 1;
                        events[i].data.fd = client;
                        events[i].events = EPOLLIN | EPOLLET;
                        if (setsockopt(client, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0) perror("no delay");
                        if (epoll_ctl(efd, EPOLL_CTL_ADD, client, &events[i]) < 0) perror("epoll add client");
                    }
                } else {
                    int bytes, offset = 0;
                    while ((bytes = read(fd, buffer + offset, READ_BUFFER - offset)) > 0) {
                        int clrf_offset = 0;
                        while ((clrf_offset = find_clrf(buffer + clrf_offset + offset, bytes)) != -1)
                            if (send(fd, RESPONSE, sizeof(RESPONSE) - 1, MSG_NOSIGNAL) == -1)
                                break;
                        offset += bytes;
                    }
                    if (bytes == 0 || (bytes == -1 && errno != EAGAIN))
                        close(fd);
                }
            } while (!atomic_compare_exchange_weak_explicit(
                fd_lock, &expect, 0, memory_order_release, memory_order_relaxed));
        }
    }
}

int main() {
    int opt = 1;
    server = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
    if (server < 0) perror("socket create");
    if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) perror("reuse addr");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(12345);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(server, (struct sockaddr*)&addr, sizeof(addr)) < 0) perror("bind");
    if (listen(server, SOMAXCONN) < 0) perror("listen");

    efd = epoll_create1(0);
    if (efd < 0) perror("epoll");
    struct epoll_event event;
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = server;
    if (epoll_ctl(efd, EPOLL_CTL_ADD, server, &event) < 0) perror("epoll add server");

    pthread_t thread;
    for (int i = get_nprocs() - 1; i > 0; i--)
        if (pthread_create(&thread, NULL, worker, NULL) != 0)
            perror("create thread");
    worker(NULL);
}