Refactor async_exec

.gitignore

@@ -1,10 +1,12 @@
 *
 !src
 !src/**
+!res
+!res/**
 !doc
 !doc/**
 !test
 !test/**
 !Makefile
 !.gitignore
-!README.md
+!*.md

Makefile

@@ -3,11 +3,11 @@ CC=gcc
 CFLAGS=-std=gnu11 -Wno-unused-but-set-variable -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_POSIX_C_SOURCE=200809L
 LDFLAGS=-lssl -lcrypto -lmagic -lz -lmaxminddb -lbrotlienc
 
-DEBIAN_OPTS=-D CACHE_MAGIC_FILE="\"/usr/share/file/magic.mgc\"" -D PHP_FPM_SOCKET="\"/var/run/php/php8.2-fpm.sock\""
+DEBIAN_OPTS=-D CACHE_MAGIC_FILE="\"/usr/share/file/magic.mgc\"" -D PHP_FPM_SOCKET="\"/var/run/php/php7.4-fpm.sock\""
 
 .PHONY: all prod debug default debian permit clean test
 all: prod
-default: bin bin/lib bin/sesimos
+default: bin bin/lib bin/worker bin/res bin/sesimos
 
 prod: CFLAGS += -O3
 prod: default
@@ -29,6 +29,11 @@ bin:
 bin/lib:
 	mkdir -p bin/lib
 
+bin/worker:
+	mkdir -p bin/worker
+
+bin/res:
+	mkdir -p bin/res
 
 bin/test: test/mock_*.c test/test_*.c src/lib/utils.c src/lib/sock.c
 	$(CC) -o $@ $(CFLAGS) $^ -lcriterion
@@ -40,34 +45,61 @@ bin/%.o: src/%.c
 bin/lib/%.o: src/lib/%.c
 	$(CC) -c -o $@ $(CFLAGS) $<
 
-bin/sesimos: bin/server.o bin/client.o \
+bin/worker/%.o: src/worker/%.c
-			 bin/lib/cache.o bin/lib/compress.o bin/lib/config.o bin/lib/fastcgi.o bin/lib/geoip.o \
+	$(CC) -c -o $@ $(CFLAGS) $<
-			 bin/lib/http.o bin/lib/http_static.o bin/lib/rev_proxy.o bin/lib/sock.o bin/lib/uri.o \
+
-		     bin/lib/utils.o bin/lib/websocket.o
+bin/res/%.o: bin/res/%.txt
+	objcopy -I binary --rename-section .data=.rodata -O elf64-x86-64 $^ $@
+
+bin/res/%.txt: res/%.*
+	cp $^ $@
+	echo -ne "\x00" >> $@
+
+bin/sesimos: bin/server.o bin/logger.o bin/cache_handler.o bin/async.o bin/workers.o \
+			 bin/worker/request_handler.o bin/worker/tcp_acceptor.o \
+			 bin/worker/fastcgi_handler.o bin/worker/local_handler.o bin/worker/proxy_handler.o \
+			 bin/lib/http_static.o bin/res/default.o bin/res/proxy.o bin/res/style.o \
+			 bin/lib/compress.o bin/lib/config.o bin/lib/fastcgi.o bin/lib/geoip.o \
+			 bin/lib/http.o  bin/lib/proxy.o bin/lib/sock.o bin/lib/uri.o \
+		     bin/lib/utils.o bin/lib/websocket.o bin/lib/mpmc.o
 	$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
 
 
-bin/server.o: src/server.h src/defs.h src/client.h src/lib/cache.h src/lib/config.h src/lib/sock.h \
+bin/server.o: src/server.h src/defs.h src/cache_handler.h src/lib/config.h src/lib/sock.h \
-              src/lib/rev_proxy.h src/lib/geoip.h src/lib/utils.h
+              src/lib/proxy.h src/lib/geoip.h src/lib/utils.h src/logger.h
 
-bin/client.o: src/client.h src/defs.h src/server.h src/lib/utils.h src/lib/config.h src/lib/sock.h \
+bin/logger.o: src/logger.h
-              src/lib/http.h src/lib/rev_proxy.h src/lib/fastcgi.h src/lib/cache.h src/lib/geoip.h src/lib/compress.h \
-              src/lib/websocket.h
 
-bin/lib/cache.o: src/lib/cache.h src/lib/utils.h src/lib/uri.h src/lib/compress.h
+bin/cache_handler.o: src/cache_handler.h src/lib/utils.h src/lib/uri.h src/lib/compress.h src/logger.h
+
+bin/async.o: src/async.h src/logger.h
+
+bin/workers.o: src/workers.h src/lib/mpmc.h src/worker/func.h
+
+bin/worker/request_handler.o: src/worker/func.h
+
+bin/worker/tcp_acceptor.o: src/worker/func.h
+
+bin/worker/fastcgi_handler.o: src/worker/func.h
+
+bin/worker/local_handler.o: src/worker/func.h
+
+bin/worker/proxy_handler.o: src/worker/func.h
 
 bin/lib/compress.o: src/lib/compress.h
 
-bin/lib/config.o: src/lib/config.h src/lib/utils.h src/lib/uri.h
+bin/lib/config.o: src/lib/config.h src/lib/utils.h src/lib/uri.h src/logger.h
 
 bin/lib/fastcgi.o: src/lib/fastcgi.h src/server.h src/lib/utils.h src/lib/compress.h src/lib/http.h \
-                   src/lib/uri.h src/lib/include/fastcgi.h
+                   src/lib/uri.h src/lib/include/fastcgi.h src/logger.h
 
 bin/lib/geoip.o: src/lib/geoip.h
 
-bin/lib/http.o: src/lib/http.h src/lib/utils.h src/lib/compress.h src/lib/sock.h
+bin/lib/http.o: src/lib/http.h src/lib/utils.h src/lib/compress.h src/lib/sock.h src/logger.h
 
-bin/lib/rev_proxy.o: src/lib/rev_proxy.h src/defs.h src/server.h src/lib/compress.h
+bin/lib/mpmc.o: src/lib/mpmc.h src/logger.h
+
+bin/lib/proxy.o: src/lib/proxy.h src/defs.h src/server.h src/lib/compress.h src/logger.h
 
 bin/lib/sock.o: src/lib/sock.h
 
@@ -75,7 +107,7 @@ bin/lib/uri.o: src/lib/uri.h src/lib/utils.h
 
 bin/lib/utils.o: src/lib/utils.h
 
-bin/lib/websocket.o: src/lib/websocket.h src/defs.h src/lib/utils.h src/lib/sock.h
+bin/lib/websocket.o: src/lib/websocket.h src/defs.h src/lib/utils.h src/lib/sock.h src/logger.h
 
 
 permit:

architecture.md

@@ -0,0 +1,22 @@
+
+# Architecture
+
+* logger (1)
+* listener (2) - 80, 443
+* cache_handler (1)
+* connection_initializer
+* request_handler
+* local_handler
+* proxy_handler
+* ws_handler
+* fastcgi_handler
+
+
+* -> logger
+* main -> listener
+* listener -> connection_handler
+* connection_initializer -> request_handler
+* request_handler -> local_handler -> request_handler
+* local_handler -> fastcgi_handler -> request_handler
+* request_handler -> rp_handler -> request_handler
+* proxy_handler -> ws_handler -> request_handler

res/default.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>%1$i %2$s - %7$s</title>
+  <meta charset="UTF-8"/>
+  <meta name="theme-color" content="%6$s"/>
+  <meta name="color-scheme" content="light dark"/>
+  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent"/>
+  <meta name="viewport" content="width=device-width,initial-scale=1.0"/>
+  <link rel="shortcut icon" type="image/x-icon" href="/favicon.ico"/>
+  <link rel="stylesheet" type="text/css" href="/.sesimos/style.css"/>
+%5$s  <style>html{--color:var(--%4$s);}</style>
+</head>
+<body>
+  <main>
+    <section>
+%3$s%9$s      <div class="footer"><a href="https://%7$s/">%7$s</a> - %10$s</div>
+    </section>
+%8$s  </main>
+</body>
+</html>

res/proxy.html

@@ -0,0 +1,31 @@
+    <section class="error-ctx">
+      <div class="box%1$s">
+        <div class="content">
+          <span>Client</span>
+          <img src="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNjQiIGhlaWdodD0iNjQiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTIsMzIgYTMwLDMwLDAsMSwwLDYwLDAgYTMwLDMwLDAsMSwwLC02MCwwIEw2MiwzMiBNNiwxNiBMNTgsMTYgTTYsNDggTDU4LDQ4IE0zMiwyIEwzMiw2MiBhMTUsMzAsMCwxLDAsMCwtNjAgYTE1LDMwLDAsMSwwLDAsNjAgWiIgc3Ryb2tlPSIjMDA4MDAwIiBzdHJva2Utd2lkdGg9IjIiIGZpbGw9IiMwMDAwMDAwMCIvPjwvc3ZnPgo="/>
+          <span>Your Browser</span>
+        </div>
+        <div class="arrow request%2$s"></div>
+      </div>
+      <div class="border%8$s"></div>
+      <div class="box%3$s">
+        <div class="content">
+          <span>Reverse Proxy</span>
+          <h3>%10$03i</h3>
+          <h4>%11$s</h4>
+          <span>%15$s</span>
+        </div>
+        <div class="arrow request%4$s"></div>
+        <div class="arrow response%5$s"></div>
+      </div>
+      <div class="border%9$s"></div>
+      <div class="box%6$s">
+        <div class="content">
+          <span>Server</span>
+          <h3>%12$s</h3>
+          <h4>%13$s</h4>
+          <span>%14$s</span>
+        </div>
+        <div class="arrow response%7$s"></div>
+      </div>
+    </section>

res/style.css

@@ -0,0 +1,66 @@
+html{
+	font-family:"Arial",sans-serif;
+	--error:#C00000;
+	--warning:#E0C000;
+	--success:#008000;
+	--info:#606060;
+	--soft:#808080;
+}
+
+body{background-color:#F0F0F0;margin:0;}
+main{max-width:650px;margin:2em auto;}
+section{margin:2em 1em;background-color:#FFFFFF;border: 1px solid var(--color);border-radius:4px;padding:1em;}
+h1,h2,h3,h4,h5,h6{text-align:center;color:var(--color);font-weight:normal;}
+h1{font-size:3em;margin:0.125em 0;}
+h2{font-size:1.5em;margin:0.25em 0 1em 0;}
+p{text-align:center;font-size:0.875em;}
+div.footer{color:var(--soft);font-size:0.75em;text-align:center;margin:2em 0 0.5em 0;}
+div.footer a{color:var(--soft);}
+ul,ol{width:fit-content;margin:auto;}
+pre{width:fit-content;margin:2em auto 0 auto;}
+
+section.error-ctx{display:flex;padding:0;border:none;}
+div.box{flex:100% 1 1;border:1px solid var(--info);color:var(--info);position:relative;padding:1em;box-sizing:border-box;text-align:center;}
+div.box.error{border-color:var(--error);color:var(--error);}
+div.box.success{border-color:var(--success);color:var(--success);}
+div.arrow{position:absolute;height:20px;width:30px;z-index:10;background-repeat:no-repeat;background-size:contain;}
+div.arrow.response{left:-17.5px;bottom:calc(33.3333% - 10px);}
+div.arrow.request{right:-17.5px;top:calc(33.3333% - 10px);}
+div.border{flex:1px 0 0;background-color:var(--info);}
+div.border.error{background-color:var(--error);}
+div.border.success{background-color:var(--success);}
+div.content>span{display:block;color:var(--soft);font-size:0.75em;}
+div.content>img{height:3.75rem;margin:0.75rem auto;display:block;}
+h3{font-size:2.25em;margin:0.75rem 0 0 0;color:unset;height:2.5rem;}
+h4{font-size:1em;margin:0 0 0.75rem 0;color:unset;height:1.25rem;}
+
+div.arrow.request.success{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjRkZGRkZGIiBzdHJva2U9IiMwMDgwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}
+div.arrow.request.error{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjRkZGRkZGIiBzdHJva2U9IiNDMDAwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}
+div.arrow.response.success{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiNGRkZGRkYiIHN0cm9rZT0iIzAwODAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}
+div.arrow.response.error{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiNGRkZGRkYiIHN0cm9rZT0iI0MwMDAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}
+
+@media(prefers-color-scheme:dark){
+	html{color:#FFFFFF;--soft:#404040;}
+	body{background-color:#101010;}
+	section{background-color:#181818;}
+
+	div.arrow.request.success{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjMTgxODE4IiBzdHJva2U9IiMwMDgwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}
+	div.arrow.request.error{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjMTgxODE4IiBzdHJva2U9IiNDMDAwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}
+	div.arrow.response.success{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiMxODE4MTgiIHN0cm9rZT0iIzAwODAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}
+	div.arrow.response.error{background-image:url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiMxODE4MTgiIHN0cm9rZT0iI0MwMDAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}
+}
+
+@media(min-width:650px){
+	div.box:first-child{border-top-left-radius:4px;border-bottom-left-radius:4px;border-right:none;}
+	div.box:last-child{border-top-right-radius:4px;border-bottom-right-radius:4px;border-left:none;}
+	div.box:not(:last-child):not(:first-child){border-left:none;border-right:none;}
+}
+
+@media(max-width:650px){
+	section.error-ctx{flex-direction:column;height:unset;}
+	div.box:first-child{border-top-left-radius:4px;border-top-right-radius:4px;border-bottom:none;padding-top:1em;}
+	div.box:last-child{border-bottom-right-radius:4px;border-bottom-left-radius:4px;border-top:none;padding-bottom:1em;}
+	div.box:not(:last-child):not(:first-child){border-top:none;border-bottom:none;}
+	div.arrow.response{transform:rotate(90deg);top:-10px;left:calc(33.3333% - 22.5px);right:unset;}
+	div.arrow.request{transform:rotate(90deg);bottom:-10px;right:calc(33.3333% - 22.5px);top:unset;}
+}

src/async.c

@@ -0,0 +1,163 @@
+/**
+ * Sesimos - secure, simple, modern web server
+ * @brief Async handler
+ * @file src/async.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-28
+ */
+
+#include "async.h"
+#include "logger.h"
+
+#include <poll.h>
+#include <signal.h>
+#include <errno.h>
+#include <memory.h>
+#include <pthread.h>
+
+typedef struct {
+    int fd;
+    sock *socket;
+    short events;
+    int flags;
+    void (*cb)(void *);
+    void *arg;
+    void (*err_cb)(void *);
+    void *err_arg;
+} evt_listen_t;
+
+typedef struct {
+    int n;
+    evt_listen_t q[256];
+} listen_queue_t;
+
+static listen_queue_t listen1, listen2, *listen_q = &listen1;
+static volatile sig_atomic_t alive = 1;
+static pthread_t thread = -1;
+
+static int async_add_to_queue(evt_listen_t *evt) {
+    // TODO locking
+    memcpy(&listen_q->q[listen_q->n++], evt, sizeof(*evt));
+    return 0;
+}
+
+static int async_exec(evt_listen_t *evt, short r_events) {
+    int ret, e = errno;
+    if (r_events & evt->events) {
+        // specified event(s) occurred
+        if (evt->socket && !sock_check(evt->socket)) {
+            evt->err_cb(evt->err_arg);
+            ret = 0;
+        } else {
+            evt->cb(evt->arg);
+            ret = (evt->flags & ASYNC_KEEP) ? 1 : 0;
+        }
+    } else if (r_events & (POLLERR | POLLHUP | POLLNVAL)) {
+        // error occurred
+        evt->err_cb(evt->err_arg);
+        ret = 0;
+    } else {
+        // no event occurred
+        ret = -1;
+    }
+
+    logger_set_prefix("");
+    errno = e;
+    return ret;
+}
+
+static int async_check(evt_listen_t *evt) {
+    struct pollfd fds[1] = {{.fd = evt->fd, .events = evt->events}};
+
+    // check, if fd is already ready
+    if (poll(fds, 1, 0) == 1) {
+        // fd already read
+        if (async_exec(evt, fds[0].revents) == 0)
+            return 1;
+    }
+
+    return 0;
+}
+
+static int async_add(evt_listen_t *evt) {
+    if (async_check(evt) == 1)
+        return 0;
+
+    int ret = async_add_to_queue(evt);
+    if (ret == 0 && thread != -1)
+        pthread_kill(thread, SIGUSR1);
+
+    return ret;
+}
+
+int async_fd(int fd, short events, int flags, void cb(void *), void *arg, void err_cb(void *), void *err_arg) {
+    evt_listen_t evt = {
+            .fd = fd,
+            .socket = NULL,
+            .events = events,
+            .flags = flags,
+            .cb = cb,
+            .arg = arg,
+            .err_cb = err_cb,
+            .err_arg = err_arg,
+    };
+    return async_add(&evt);
+}
+
+int async(sock *s, short events, int flags, void cb(void *), void *arg, void err_cb(void *), void *err_arg) {
+    evt_listen_t evt = {
+            .fd = s->socket,
+            .socket = s,
+            .events = events,
+            .flags = flags,
+            .cb = cb,
+            .arg = arg,
+            .err_cb = err_cb,
+            .err_arg = err_arg,
+    };
+    return async_add(&evt);
+}
+
+void async_thread(void) {
+    int num_fds;
+    struct pollfd fds[256];  // TODO dynamic
+
+    thread = pthread_self();
+
+    // main event loop
+    while (alive) {
+        // swap listen queue
+        listen_queue_t *l = listen_q;
+        listen_q = (listen_q == &listen1) ? &listen2 : &listen1;
+
+        // fill fds with newly added queue entries
+        for (num_fds = 0; num_fds < l->n; num_fds++) {
+            fds[num_fds].fd = l->q[num_fds].fd;
+            fds[num_fds].events = l->q[num_fds].events;
+        }
+
+        if (poll(fds, num_fds, -1) < 0) {
+            if (errno == EINTR) {
+                // interrupt
+                errno = 0;
+            } else {
+                // other error
+                critical("Unable to poll for events");
+                return;
+            }
+        }
+
+        for (int i = 0; i < num_fds; i++) {
+            evt_listen_t *e = &l->q[i];
+            if (async_exec(e, fds[i].revents) != 0)
+                async_add_to_queue(e);
+        }
+
+        // reset size of queue
+        l->n = 0;
+    }
+}
+
+void async_stop(void) {
+    alive = 0;
+}

src/async.h

@@ -0,0 +1,26 @@
+/**
+ * Sesimos - secure, simple, modern web server
+ * @brief Async handler (header file)
+ * @file src/async.h
+ * @author Lorenz Stechauner
+ * @date 2022-12-28
+ */
+
+#ifndef SESIMOS_ASYNC_H
+#define SESIMOS_ASYNC_H
+
+#include "lib/sock.h"
+
+#include <poll.h>
+
+#define ASYNC_KEEP 1
+
+int async(sock *s, short events, int flags, void cb(void *), void *arg, void err_cb(void *), void *err_arg);
+
+int async_fd(int fd, short events, int flags, void cb(void *), void *arg, void err_cb(void *), void *err_arg);
+
+void async_thread(void);
+
+void async_stop(void);
+
+#endif //SESIMOS_ASYNC_H

src/cache_handler.c

@@ -0,0 +1,390 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief File cache implementation
+ * @file src/cache_handler.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-19
+ */
+
+#include "server.h"
+#include "logger.h"
+#include "cache_handler.h"
+#include "lib/utils.h"
+#include "lib/compress.h"
+#include "lib/config.h"
+
+#include <stdio.h>
+#include <magic.h>
+#include <string.h>
+#include <errno.h>
+#include <openssl/evp.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <semaphore.h>
+
+#define CACHE_BUF_SIZE 16
+
+
+static magic_t magic;
+static pthread_t thread;
+static sem_t sem_free, sem_used, sem_lock;
+
+typedef struct {
+    int rd;
+    int wr;
+    cache_entry_t *msgs[CACHE_BUF_SIZE];
+} buf_t;
+
+static buf_t buffer;
+
+static int magic_init(void) {
+    if ((magic = magic_open(MAGIC_MIME)) == NULL) {
+        critical("Unable to open magic cookie");
+        return 1;
+    }
+
+    if (magic_load(magic, CACHE_MAGIC_FILE) != 0) {
+        critical("Unable to load magic cookie: %s", magic_error(magic));
+        return 1;
+    }
+
+    return 0;
+}
+
+static void cache_free(void) {
+    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
+        host_config_t *hc = &config.hosts[i];
+        if (hc->type == CONFIG_TYPE_UNSET) break;
+        if (hc->type != CONFIG_TYPE_LOCAL) continue;
+
+        munmap(hc->cache, sizeof(cache_t));
+    }
+}
+
+static cache_entry_t *cache_get_entry(cache_t *cache, const char *filename) {
+    // search entry
+    cache_entry_t *entry;
+    for (int i = 0; i < CACHE_ENTRIES; i++) {
+        entry = &cache->entries[i];
+        if (entry->filename[0] == 0) break;
+        if (strcmp(entry->filename, filename) == 0) {
+            // found
+            return entry;
+        }
+    }
+
+    // not found
+    return NULL;
+}
+
+static cache_entry_t *cache_get_new_entry(cache_t *cache) {
+    // search empty slot
+    cache_entry_t *entry;
+    for (int i = 0; i < CACHE_ENTRIES; i++) {
+        entry = &cache->entries[i];
+        if (entry->filename[0] == 0)
+            return entry;
+    }
+
+    // not found
+    return NULL;
+}
+
+static void cache_process_entry(cache_entry_t *entry) {
+    char buf[16384], comp_buf[16384], filename_comp_gz[256], filename_comp_br[256];
+
+    info("Hashing file %s", entry->filename);
+
+    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+    EVP_DigestInit(ctx, EVP_sha1());
+    FILE *file = fopen(entry->filename, "rb");
+    int compress = mime_is_compressible(entry->meta.type);
+
+    compress_ctx comp_ctx;
+    FILE *comp_file_gz = NULL, *comp_file_br = NULL;
+    if (compress) {
+        sprintf(buf, "%.*s/.sesimos", entry->webroot_len, entry->filename);
+        if (mkdir(buf, 0755) != 0 && errno != EEXIST) {
+            error("Unable to create directory %s", buf);
+            goto comp_err;
+        }
+
+        sprintf(buf, "%.*s/.sesimos/cache", entry->webroot_len, entry->filename);
+        if (mkdir(buf, 0700) != 0 && errno != EEXIST) {
+            error("Unable to create directory %s", buf);
+            goto comp_err;
+        }
+        errno = 0;
+
+        char *rel_path = entry->filename + entry->webroot_len + 1;
+        for (int j = 0; j < strlen(rel_path); j++) {
+            char ch = rel_path[j];
+            if (ch == '/') ch = '_';
+            buf[j] = ch;
+        }
+        buf[strlen(rel_path)] = 0;
+
+        int p_len_gz = snprintf(filename_comp_gz, sizeof(filename_comp_gz),
+                                "%.*s/.sesimos/cache/%s.gz",
+                                entry->webroot_len, entry->filename, buf);
+        int p_len_br = snprintf(filename_comp_br, sizeof(filename_comp_br),
+                                "%.*s/.sesimos/cache/%s.br",
+                                entry->webroot_len, entry->filename, buf);
+        if (p_len_gz < 0 || p_len_gz >= sizeof(filename_comp_gz) || p_len_br < 0 || p_len_br >= sizeof(filename_comp_br)) {
+            error("Unable to open cached file: File name for compressed file too long");
+            goto comp_err;
+        }
+
+        info("Compressing file %s", entry->filename);
+
+        comp_file_gz = fopen(filename_comp_gz, "wb");
+        comp_file_br = fopen(filename_comp_br, "wb");
+        if (comp_file_gz == NULL || comp_file_br == NULL) {
+            error("Unable to open cached file");
+            comp_err:
+            compress = 0;
+        } else {
+            if ((compress_init(&comp_ctx, COMPRESS_GZ | COMPRESS_BR)) != 0) {
+                error("Unable to init compression");
+                compress = 0;
+                fclose(comp_file_gz);
+                fclose(comp_file_br);
+            }
+        }
+    }
+
+    unsigned long read;
+    while ((read = fread(buf, 1, sizeof(buf), file)) > 0) {
+        EVP_DigestUpdate(ctx, buf, read);
+        if (compress) {
+            unsigned long avail_in, avail_out;
+            avail_in = read;
+            do {
+                avail_out = sizeof(comp_buf);
+                compress_compress_mode(&comp_ctx, COMPRESS_GZ, buf + read - avail_in, &avail_in, comp_buf, &avail_out, feof(file));
+                fwrite(comp_buf, 1, sizeof(comp_buf) - avail_out, comp_file_gz);
+            } while (avail_in != 0 || avail_out != sizeof(comp_buf));
+            avail_in = read;
+            do {
+                avail_out = sizeof(comp_buf);
+                compress_compress_mode(&comp_ctx, COMPRESS_BR, buf + read - avail_in, &avail_in, comp_buf, &avail_out, feof(file));
+                fwrite(comp_buf, 1, sizeof(comp_buf) - avail_out, comp_file_br);
+            } while (avail_in != 0 || avail_out != sizeof(comp_buf));
+        }
+    }
+
+    if (compress) {
+        compress_free(&comp_ctx);
+        fclose(comp_file_gz);
+        fclose(comp_file_br);
+        info("Finished compressing file %s", entry->filename);
+        strcpy(entry->meta.filename_comp_gz, filename_comp_gz);
+        strcpy(entry->meta.filename_comp_br, filename_comp_br);
+    } else {
+        memset(entry->meta.filename_comp_gz, 0, sizeof(entry->meta.filename_comp_gz));
+        memset(entry->meta.filename_comp_br, 0, sizeof(entry->meta.filename_comp_br));
+    }
+
+    unsigned int md_len;
+    unsigned char hash[EVP_MAX_MD_SIZE];
+    EVP_DigestFinal(ctx, hash, &md_len);
+    EVP_MD_CTX_free(ctx);
+
+    memset(entry->meta.etag, 0, sizeof(entry->meta.etag));
+    for (int j = 0; j < md_len; j++) {
+        sprintf(entry->meta.etag + j * 2, "%02x", hash[j]);
+    }
+    fclose(file);
+    entry->flags &= !CACHE_DIRTY;
+
+    info("Finished hashing file %s", entry->filename);
+}
+
+static void *cache_thread(void *arg) {
+    logger_set_name("cache");
+
+    while (server_alive) {
+        pthread_testcancel();
+        if (sem_wait(&sem_used) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                continue;
+            } else {
+                error("Unable to lock semaphore");
+                errno = 0;
+                break;
+            }
+        }
+
+        cache_entry_t *entry = buffer.msgs[buffer.wr];
+        buffer.wr = (buffer.wr + 1) % CACHE_BUF_SIZE;
+
+        cache_process_entry(entry);
+
+        // unlock slot in buffer
+        sem_post(&sem_free);
+    }
+
+    cache_free();
+
+    return NULL;
+}
+
+int cache_init(void) {
+    char buf[512];
+    int ret, fd;
+    if ((ret = magic_init()) != 0)
+        return ret;
+
+    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
+        host_config_t *hc = &config.hosts[i];
+        if (hc->type == CONFIG_TYPE_UNSET) break;
+        if (hc->type != CONFIG_TYPE_LOCAL) continue;
+
+        sprintf(buf, "%s/.sesimos/metadata", hc->local.webroot);
+        if ((fd = open(buf, O_CREAT | O_RDWR, 0600)) == -1) {
+            critical("Unable to open file %s", buf);
+            return 1;
+        }
+
+        if (ftruncate(fd, sizeof(cache_t)) == -1) {
+            critical("Unable to truncate file %s", buf);
+            return 1;
+        }
+
+        if ((hc->cache = mmap(NULL, sizeof(cache_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == NULL) {
+            critical("Unable to map file %s", buf);
+            close(fd);
+            return 1;
+        }
+
+        close(fd);
+        errno = 0;
+    }
+
+    // try to initialize all three semaphores
+    if (sem_init(&sem_lock, 0, 1) != 0 ||
+        sem_init(&sem_free, 0, 1) != 0 ||
+        sem_init(&sem_used, 0, 0) != 0)
+    {
+        critical("Unable to initialize semaphore");
+        return -1;
+    }
+
+    // initialize read/write heads
+    buffer.rd = 0;
+    buffer.wr = 0;
+
+    pthread_create(&thread, NULL, cache_thread, NULL);
+
+    return 0;
+}
+
+int cache_join(void) {
+    return pthread_join(thread, NULL);
+}
+
+static void cache_mark_entry_dirty(cache_entry_t *entry) {
+    if (entry->flags & CACHE_DIRTY)
+        return;
+
+    memset(entry->meta.etag, 0, sizeof(entry->meta.etag));
+    memset(entry->meta.filename_comp_gz, 0, sizeof(entry->meta.filename_comp_gz));
+    memset(entry->meta.filename_comp_br, 0, sizeof(entry->meta.filename_comp_br));
+    entry->flags |= CACHE_DIRTY;
+
+    try_again_free:
+    if (sem_wait(&sem_free) != 0) {
+        if (errno == EINTR) {
+            errno = 0;
+            goto try_again_free;
+        } else {
+            error("Unable to lock semaphore");
+            errno = 0;
+        }
+        return;
+    }
+
+    // try to lock buffer
+    try_again_lock:
+    if (sem_wait(&sem_lock) != 0) {
+        if (errno == EINTR) {
+            errno = 0;
+            goto try_again_lock;
+        } else {
+            error("Unable to lock semaphore");
+            errno = 0;
+        }
+        return;
+    }
+
+    // write to buffer
+    buffer.msgs[buffer.rd] = entry;
+    buffer.rd = (buffer.rd + 1) % CACHE_BUF_SIZE;
+
+    // unlock buffer
+    sem_post(&sem_lock);
+
+    // unlock slot in buffer for logger
+    sem_post(&sem_used);
+}
+
+static void cache_update_entry(cache_entry_t *entry, const char *filename, const char *webroot) {
+    struct stat statbuf;
+    stat(filename, &statbuf);
+    memcpy(&entry->meta.stat, &statbuf, sizeof(statbuf));
+
+    entry->webroot_len = (unsigned char) strlen(webroot);
+    strcpy(entry->filename, filename);
+
+    magic_setflags(magic, MAGIC_MIME_TYPE);
+    const char *type = magic_file(magic, filename);
+    char type_new[URI_TYPE_SIZE];
+    sprintf(type_new, "%s", type);
+    if (strncmp(type, "text/", 5) == 0) {
+        if (strcmp(filename + strlen(filename) - 4, ".css") == 0) {
+            sprintf(type_new, "text/css");
+        } else if (strcmp(filename + strlen(filename) - 3, ".js") == 0) {
+            sprintf(type_new, "application/javascript");
+        }
+    }
+    strcpy(entry->meta.type, type_new);
+
+    magic_setflags(magic, MAGIC_MIME_ENCODING);
+    strcpy(entry->meta.charset, magic_file(magic, filename));
+
+    cache_mark_entry_dirty(entry);
+}
+
+void cache_mark_dirty(cache_t *cache, const char *filename) {
+    cache_entry_t *entry = cache_get_entry(cache, filename);
+    if (entry) cache_mark_entry_dirty(entry);
+}
+
+void cache_init_uri(cache_t *cache, http_uri *uri) {
+    if (!uri->filename)
+        return;
+
+    cache_entry_t *entry = cache_get_entry(cache, uri->filename);
+    if (!entry) {
+        // no entry found -> create new entry
+        if ((entry = cache_get_new_entry(cache))) {
+            cache_update_entry(entry, uri->filename, uri->webroot);
+            uri->meta = &entry->meta;
+        } else {
+            warning("No empty cache entry slot found");
+        }
+    } else {
+        uri->meta = &entry->meta;
+        if (entry->flags & CACHE_DIRTY)
+            return;
+
+        // check, if file has changed
+        struct stat statbuf;
+        stat(uri->filename, &statbuf);
+        if (memcmp(&uri->meta->stat.st_mtime, &statbuf.st_mtime, sizeof(statbuf.st_mtime)) != 0) {
+            // modify time has changed
+            cache_update_entry(entry, uri->filename, uri->webroot);
+        }
+    }
+}

src/cache_handler.h

@@ -0,0 +1,44 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief File cache implementation (header file)
+ * @file src/cache_handler.h
+ * @author Lorenz Stechauner
+ * @date 2020-12-19
+ */
+
+#ifndef SESIMOS_CACHE_HANDLER_H
+#define SESIMOS_CACHE_HANDLER_H
+
+#include "lib/uri.h"
+
+#define CACHE_ENTRIES 1024
+
+#define CACHE_DIRTY 1
+
+#ifndef CACHE_MAGIC_FILE
+#   define CACHE_MAGIC_FILE "/usr/share/file/misc/magic.mgc"
+#endif
+
+
+typedef struct {
+    char filename[256];
+    unsigned char webroot_len;
+    unsigned char flags;
+    metadata_t meta;
+} cache_entry_t;
+
+typedef struct {
+    char sig[6];
+    unsigned char ver;
+    cache_entry_t entries[CACHE_ENTRIES];
+} cache_t;
+
+int cache_init(void);
+
+int cache_join(void);
+
+void cache_mark_dirty(cache_t *cache, const char *filename);
+
+void cache_init_uri(cache_t *cache, http_uri *uri);
+
+#endif //SESIMOS_CACHE_HANDLER_H

src/client.c

@@ -1,916 +0,0 @@
-/**
- * sesimos - secure, simple, modern web server
- * @brief Client connection and request handlers
- * @file src/client.c
- * @author Lorenz Stechauner
- * @date 2020-12-03
- */
-
-#include "defs.h"
-#include "client.h"
-#include "server.h"
-
-#include "lib/utils.h"
-#include "lib/config.h"
-#include "lib/sock.h"
-#include "lib/http.h"
-#include "lib/rev_proxy.h"
-#include "lib/fastcgi.h"
-#include "lib/cache.h"
-#include "lib/geoip.h"
-#include "lib/compress.h"
-#include "lib/websocket.h"
-
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#include <signal.h>
-#include <arpa/inet.h>
-
-
-volatile sig_atomic_t server_keep_alive = 1;
-struct timeval client_timeout = {.tv_sec = CLIENT_TIMEOUT, .tv_usec = 0};
-
-char *log_client_prefix, *log_conn_prefix, *log_req_prefix, *client_geoip;
-char *client_addr_str, *client_addr_str_ptr, *server_addr_str, *server_addr_str_ptr, *client_host_str;
-
-host_config *get_host_config(const char *host) {
-    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
-        host_config *hc = &config->hosts[i];
-        if (hc->type == CONFIG_TYPE_UNSET) break;
-        if (strcmp(hc->name, host) == 0) return hc;
-        if (hc->name[0] == '*' && hc->name[1] == '.') {
-            const char *pos = strstr(host, hc->name + 1);
-            if (pos != NULL && strlen(pos) == strlen(hc->name + 1)) return hc;
-        }
-    }
-    return NULL;
-}
-
-void client_terminate(int _) {
-    server_keep_alive = 0;
-}
-
-int client_request_handler(sock *client, unsigned long client_num, unsigned int req_num) {
-    struct timespec begin, end;
-    long ret;
-    int client_keep_alive;
-
-    char buf0[1024], buf1[1024];
-    char msg_buf[8192], msg_pre_buf_1[4096], msg_pre_buf_2[4096], err_msg[256];
-    char msg_content[1024];
-    char buffer[CHUNK_SIZE];
-    char host[256];
-    const char *host_ptr, *hdr_connection;
-
-    msg_buf[0] = 0;
-    err_msg[0] = 0;
-    msg_content[0] = 0;
-
-    host_config *conf = NULL;
-    FILE *file = NULL;
-
-    long content_length = 0;
-    int accept_if_modified_since = 0;
-    int use_fastcgi = 0;
-    int use_rev_proxy = 0;
-    int p_len;
-
-    fastcgi_conn fcgi_conn = {.socket = 0, .req_id = 0};
-    http_status custom_status;
-
-    http_res res = {.version = "1.1", .status = http_get_status(501), .hdr.field_num = 0, .hdr.last_field_num = -1};
-    http_status_ctx ctx = {.status = 0, .origin = NONE, .ws_key = NULL};
-
-    clock_gettime(CLOCK_MONOTONIC, &begin);
-
-    ret = sock_poll_read(&client, NULL, NULL, 1, NULL, NULL, CLIENT_TIMEOUT * 1000);
-
-    http_add_header_field(&res.hdr, "Date", http_get_date(buf0, sizeof(buf0)));
-    http_add_header_field(&res.hdr, "Server", SERVER_STR);
-    if (ret <= 0) {
-        if (errno != 0) return 1;
-
-        client_keep_alive = 0;
-        res.status = http_get_status(408);
-        goto respond;
-    }
-    clock_gettime(CLOCK_MONOTONIC, &begin);
-
-    http_req req;
-    ret = http_receive_request(client, &req);
-    if (ret != 0) {
-        client_keep_alive = 0;
-        if (ret < 0) {
-            goto abort;
-        } else if (ret == 1) {
-            sprintf(err_msg, "Unable to parse http header: Invalid header format.");
-        } else if (ret == 2) {
-            sprintf(err_msg, "Unable to parse http header: Invalid method.");
-        } else if (ret == 3) {
-            sprintf(err_msg, "Unable to parse http header: Invalid version.");
-        } else if (ret == 4) {
-            sprintf(err_msg, "Unable to parse http header: Header contains illegal characters.");
-        } else if (ret == 5) {
-            sprintf(err_msg, "Unable to parse http header: End of header not found.");
-        }
-        res.status = http_get_status(400);
-        goto respond;
-    }
-
-    hdr_connection = http_get_header_field(&req.hdr, "Connection");
-    client_keep_alive = (hdr_connection != NULL && (strstr(hdr_connection, "keep-alive") != NULL || strstr(hdr_connection, "Keep-Alive") != NULL));
-    host_ptr = http_get_header_field(&req.hdr, "Host");
-    if (host_ptr != NULL && strlen(host_ptr) > 255) {
-        host[0] = 0;
-        res.status = http_get_status(400);
-        sprintf(err_msg, "Host header field is too long.");
-        goto respond;
-    } else if (host_ptr == NULL || strchr(host_ptr, '/') != NULL) {
-        if (strchr(client_addr_str, ':') == NULL) {
-            strcpy(host, client_addr_str);
-        } else {
-            sprintf(host, "[%s]", client_addr_str);
-        }
-        res.status = http_get_status(400);
-        sprintf(err_msg, "The client provided no or an invalid Host header field.");
-        goto respond;
-    } else {
-        strcpy(host, host_ptr);
-    }
-
-    sprintf(log_req_prefix, "[%6i][%s%*s%s]%s ", getpid(), BLD_STR, INET6_ADDRSTRLEN, host, CLR_STR, log_client_prefix);
-    log_prefix = log_req_prefix;
-    print(BLD_STR "%s %s" CLR_STR, req.method, req.uri);
-
-    conf = get_host_config(host);
-    if (conf == NULL) {
-        print("Unknown host, redirecting to default");
-        res.status = http_get_status(307);
-        sprintf(buf0, "https://%s%s", DEFAULT_HOST, req.uri);
-        http_add_header_field(&res.hdr, "Location", buf0);
-        goto respond;
-    }
-
-    http_uri uri;
-    unsigned char dir_mode = (conf->type == CONFIG_TYPE_LOCAL ? conf->local.dir_mode : URI_DIR_MODE_NO_VALIDATION);
-    ret = uri_init(&uri, conf->local.webroot, req.uri, dir_mode);
-    if (ret != 0) {
-        if (ret == 1) {
-            sprintf(err_msg, "Invalid URI: has to start with slash.");
-            res.status = http_get_status(400);
-        } else if (ret == 2) {
-            sprintf(err_msg, "Invalid URI: contains relative path change (/../).");
-            res.status = http_get_status(400);
-        } else if (ret == 3) {
-            sprintf(err_msg, "The specified webroot directory does not exist.");
-            res.status = http_get_status(404);
-        } else {
-            res.status = http_get_status(500);
-        }
-        goto respond;
-    }
-
-    if (dir_mode != URI_DIR_MODE_NO_VALIDATION) {
-        ssize_t size = sizeof(buf0);
-        url_decode(req.uri, buf0, &size);
-        int change_proto = strncmp(uri.uri, "/.well-known/", 13) != 0 && !client->enc;
-        if (strcmp(uri.uri, buf0) != 0 || change_proto) {
-            res.status = http_get_status(308);
-            size = url_encode(uri.uri, strlen(uri.uri), buf0, sizeof(buf0));
-            if (change_proto) {
-                p_len = snprintf(buf1, sizeof(buf1), "https://%s%s", host, buf0);
-                if (p_len < 0 || p_len >= sizeof(buf1)) {
-                    res.status = http_get_status(500);
-                    print(ERR_STR "Header field 'Location' too long" CLR_STR);
-                    goto respond;
-                }
-                http_add_header_field(&res.hdr, "Location", buf1);
-            } else {
-                http_add_header_field(&res.hdr, "Location", buf0);
-            }
-            goto respond;
-        }
-    } else if (!client->enc) {
-        res.status = http_get_status(308);
-        sprintf(buf0, "https://%s%s", host, req.uri);
-        http_add_header_field(&res.hdr, "Location", buf0);
-        goto respond;
-    }
-
-    if (conf->type == CONFIG_TYPE_LOCAL) {
-        if (strcmp(req.method, "TRACE") == 0) {
-            res.status = http_get_status(200);
-            http_add_header_field(&res.hdr, "Content-Type", "message/http");
-
-            content_length = snprintf(msg_buf, sizeof(msg_buf) - content_length, "%s %s HTTP/%s\r\n", req.method, req.uri, req.version);
-            for (int i = 0; i < req.hdr.field_num; i++) {
-                const http_field *f = &req.hdr.fields[i];
-                content_length += snprintf(msg_buf + content_length, sizeof(msg_buf) - content_length, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
-            }
-
-            goto respond;
-        }
-
-        if (strncmp(uri.req_path, "/.well-known/", 13) == 0) {
-            http_add_header_field(&res.hdr, "Access-Control-Allow-Origin", "*");
-        }
-
-        if (strncmp(uri.req_path, "/.well-known/", 13) != 0 && strstr(uri.path, "/.") != NULL) {
-            res.status = http_get_status(403);
-            sprintf(err_msg, "Parts of this URI are hidden.");
-            goto respond;
-        } else if (uri.filename == NULL && (int) uri.is_static && (int) uri.is_dir && strlen(uri.pathinfo) == 0) {
-            res.status = http_get_status(403);
-            sprintf(err_msg, "It is not allowed to list the contents of this directory.");
-            goto respond;
-        } else if (uri.filename == NULL && (int) !uri.is_static && (int) uri.is_dir && strlen(uri.pathinfo) == 0) {
-            // TODO list directory contents
-            res.status = http_get_status(501);
-            sprintf(err_msg, "Listing contents of an directory is currently not implemented.");
-            goto respond;
-        } else if (uri.filename == NULL || (strlen(uri.pathinfo) > 0 && (int) uri.is_static)) {
-            res.status = http_get_status(404);
-            goto respond;
-        } else if (strlen(uri.pathinfo) != 0 && conf->local.dir_mode != URI_DIR_MODE_INFO) {
-            res.status = http_get_status(404);
-            goto respond;
-        }
-
-        if (uri.is_static) {
-            res.status = http_get_status(200);
-            http_add_header_field(&res.hdr, "Accept-Ranges", "bytes");
-            if (strcmp(req.method, "GET") != 0 && strcmp(req.method, "HEAD") != 0) {
-                res.status = http_get_status(405);
-                goto respond;
-            }
-
-            if (http_get_header_field(&req.hdr, "Content-Length") != NULL || http_get_header_field(&req.hdr, "Transfer-Encoding") != NULL) {
-                res.status = http_get_status(400);
-                sprintf(err_msg, "A GET request must not contain a payload");
-                goto respond;
-            }
-
-            ret = uri_cache_init(&uri);
-            if (ret != 0) {
-                res.status = http_get_status(500);
-                sprintf(err_msg, "Unable to communicate with internal file cache.");
-                goto respond;
-            }
-            const char *last_modified = http_format_date(uri.meta->stat.st_mtime, buf0, sizeof(buf0));
-            http_add_header_field(&res.hdr, "Last-Modified", last_modified);
-            sprintf(buf1, "%s; charset=%s", uri.meta->type, uri.meta->charset);
-            http_add_header_field(&res.hdr, "Content-Type", buf1);
-
-
-            const char *accept_encoding = http_get_header_field(&req.hdr, "Accept-Encoding");
-            int enc = 0;
-            if (accept_encoding != NULL) {
-                if (uri.meta->filename_comp_br[0] != 0 && strstr(accept_encoding, "br") != NULL) {
-                    file = fopen(uri.meta->filename_comp_br, "rb");
-                    if (file == NULL) {
-                        cache_filename_comp_invalid(uri.filename);
-                    } else {
-                        http_add_header_field(&res.hdr, "Content-Encoding", "br");
-                        enc = COMPRESS_BR;
-                    }
-                } else if (uri.meta->filename_comp_gz[0] != 0 && strstr(accept_encoding, "gzip") != NULL) {
-                    file = fopen(uri.meta->filename_comp_gz, "rb");
-                    if (file == NULL) {
-                        cache_filename_comp_invalid(uri.filename);
-                    } else {
-                        http_add_header_field(&res.hdr, "Content-Encoding", "gzip");
-                        enc = COMPRESS_GZ;
-                    }
-                }
-                if (enc != 0) {
-                    http_add_header_field(&res.hdr, "Vary", "Accept-Encoding");
-                }
-            }
-
-            if (uri.meta->etag[0] != 0) {
-                if (enc) {
-                    sprintf(buf0, "%s-%s", uri.meta->etag, (enc & COMPRESS_BR) ? "br" : (enc & COMPRESS_GZ) ? "gzip" : "");
-                    http_add_header_field(&res.hdr, "ETag", buf0);
-                } else {
-                    http_add_header_field(&res.hdr, "ETag", uri.meta->etag);
-                }
-            }
-
-            if (strncmp(uri.meta->type, "text/", 5) == 0) {
-                http_add_header_field(&res.hdr, "Cache-Control", "public, max-age=3600");
-            } else {
-                http_add_header_field(&res.hdr, "Cache-Control", "public, max-age=86400");
-            }
-
-            const char *if_modified_since = http_get_header_field(&req.hdr, "If-Modified-Since");
-            const char *if_none_match = http_get_header_field(&req.hdr, "If-None-Match");
-            if ((if_none_match != NULL && strstr(if_none_match, uri.meta->etag) == NULL) ||
-                (accept_if_modified_since && if_modified_since != NULL && strcmp(if_modified_since, last_modified) == 0))
-            {
-                res.status = http_get_status(304);
-                goto respond;
-            }
-
-            const char *range = http_get_header_field(&req.hdr, "Range");
-            if (range != NULL) {
-                if (strlen(range) <= 6 || strncmp(range, "bytes=", 6) != 0) {
-                    res.status = http_get_status(416);
-                    http_remove_header_field(&res.hdr, "Content-Type", HTTP_REMOVE_ALL);
-                    http_remove_header_field(&res.hdr, "Last-Modified", HTTP_REMOVE_ALL);
-                    http_remove_header_field(&res.hdr, "ETag", HTTP_REMOVE_ALL);
-                    http_remove_header_field(&res.hdr, "Cache-Control", HTTP_REMOVE_ALL);
-                    goto respond;
-                }
-                range += 6;
-                char *ptr = strchr(range, '-');
-                if (ptr == NULL) {
-                    res.status = http_get_status(416);
-                    goto respond;
-                }
-                file = fopen(uri.filename, "rb");
-                fseek(file, 0, SEEK_END);
-                unsigned long file_len = ftell(file);
-                fseek(file, 0, SEEK_SET);
-                if (file_len == 0) {
-                    content_length = 0;
-                    goto respond;
-                }
-                long num1 = 0;
-                long num2 = (long) file_len - 1;
-
-                if (ptr != range) num1 = (long) strtoul(range, NULL, 10);
-                if (ptr[1] != 0) num2 = (long) strtoul(ptr + 1, NULL, 10);
-
-                if (num1 >= file_len || num2 >= file_len || num1 > num2) {
-                    res.status = http_get_status(416);
-                    goto respond;
-                }
-                sprintf(buf0, "bytes %li-%li/%li", num1, num2, file_len);
-                http_add_header_field(&res.hdr, "Content-Range", buf0);
-
-                res.status = http_get_status(206);
-                fseek(file, num1, SEEK_SET);
-                content_length = num2 - num1 + 1;
-
-                goto respond;
-            }
-
-            if (file == NULL) {
-                file = fopen(uri.filename, "rb");
-            }
-
-            fseek(file, 0, SEEK_END);
-            content_length = ftell(file);
-            fseek(file, 0, SEEK_SET);
-        } else {
-            int mode;
-            if (strcmp(uri.filename + strlen(uri.filename) - 4, ".ncr") == 0) {
-                mode = FASTCGI_SESIMOS;
-            } else if (strcmp(uri.filename + strlen(uri.filename) - 4, ".php") == 0) {
-                mode = FASTCGI_PHP;
-            } else {
-                res.status = http_get_status(500);
-                print(ERR_STR "Invalid FastCGI extension: %s" CLR_STR, uri.filename);
-                goto respond;
-            }
-
-            struct stat statbuf;
-            stat(uri.filename, &statbuf);
-            char *last_modified = http_format_date(statbuf.st_mtime, buf0, sizeof(buf0));
-            http_add_header_field(&res.hdr, "Last-Modified", last_modified);
-
-            res.status = http_get_status(200);
-            if (fastcgi_init(&fcgi_conn, mode, client_num, req_num, client, &req, &uri) != 0) {
-                res.status = http_get_status(503);
-                sprintf(err_msg, "Unable to communicate with FastCGI socket.");
-                goto respond;
-            }
-
-            const char *client_content_length = http_get_header_field(&req.hdr, "Content-Length");
-            const char *client_transfer_encoding = http_get_header_field(&req.hdr, "Transfer-Encoding");
-            if (client_content_length != NULL) {
-                unsigned long client_content_len = strtoul(client_content_length, NULL, 10);
-                ret = fastcgi_receive(&fcgi_conn, client, client_content_len);
-            } else if (client_transfer_encoding != NULL && strstr(client_transfer_encoding, "chunked") != NULL) {
-                ret = fastcgi_receive_chunked(&fcgi_conn, client);
-            } else {
-                ret = 0;
-            }
-            if (ret != 0) {
-                if (ret < 0) {
-                    goto abort;
-                } else {
-                    sprintf(err_msg, "Unable to communicate with FastCGI socket.");
-                }
-                res.status = http_get_status(502);
-                goto respond;
-            }
-            fastcgi_close_stdin(&fcgi_conn);
-
-            ret = fastcgi_header(&fcgi_conn, &res, err_msg);
-            if (ret != 0) {
-                if (ret < 0) goto abort;
-                goto respond;
-            }
-
-            const char *status = http_get_header_field(&res.hdr, "Status");
-            if (status != NULL) {
-                int status_code = (int) strtoul(status, NULL, 10);
-                res.status = http_get_status(status_code);
-                http_remove_header_field(&res.hdr, "Status", HTTP_REMOVE_ALL);
-                if (res.status == NULL && status_code >= 100 && status_code <= 999) {
-                    custom_status.code = status_code;
-                    strcpy(custom_status.type, "");
-                    strcpy(custom_status.msg, status + 4);
-                    res.status = &custom_status;
-                } else if (res.status == NULL) {
-                    res.status = http_get_status(500);
-                    sprintf(err_msg, "The status code was set to an invalid or unknown value.");
-                    goto respond;
-                }
-            }
-
-            const char *content_length_f = http_get_header_field(&res.hdr, "Content-Length");
-            content_length = (content_length_f == NULL) ? -1 : strtol(content_length_f, NULL, 10);
-
-            const char *content_type = http_get_header_field(&res.hdr, "Content-Type");
-            const char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
-            if (content_encoding == NULL &&
-                content_type != NULL &&
-                strncmp(content_type, "text/html", 9) == 0 &&
-                content_length != -1 &&
-                content_length <= sizeof(msg_content) - 1)
-            {
-                fastcgi_dump(&fcgi_conn, msg_content, sizeof(msg_content));
-                goto respond;
-            }
-
-            use_fastcgi = 1;
-
-            if (content_length != -1 && content_length < 1024000) {
-                use_fastcgi |= FASTCGI_COMPRESS_HOLD;
-            }
-
-            content_length = -1;
-
-            int http_comp = http_get_compression(&req, &res);
-            if (http_comp & COMPRESS) {
-                if (http_comp & COMPRESS_BR) {
-                    use_fastcgi |= FASTCGI_COMPRESS_BR;
-                    sprintf(buf0, "br");
-                } else if (http_comp & COMPRESS_GZ) {
-                    use_fastcgi |= FASTCGI_COMPRESS_GZ;
-                    sprintf(buf0, "gzip");
-                }
-                http_add_header_field(&res.hdr, "Vary", "Accept-Encoding");
-                http_add_header_field(&res.hdr, "Content-Encoding", buf0);
-                http_remove_header_field(&res.hdr, "Content-Length", HTTP_REMOVE_ALL);
-            }
-
-            if (http_get_header_field(&res.hdr, "Content-Length") == NULL) {
-                http_add_header_field(&res.hdr, "Transfer-Encoding", "chunked");
-            }
-        }
-    } else if (conf->type == CONFIG_TYPE_REVERSE_PROXY) {
-        print("Reverse proxy for " BLD_STR "%s:%i" CLR_STR, conf->rev_proxy.hostname, conf->rev_proxy.port);
-        http_remove_header_field(&res.hdr, "Date", HTTP_REMOVE_ALL);
-        http_remove_header_field(&res.hdr, "Server", HTTP_REMOVE_ALL);
-
-        ret = rev_proxy_init(&req, &res, &ctx, conf, client, &custom_status, err_msg);
-        use_rev_proxy = (ret == 0);
-
-        if (res.status->code == 101) {
-            const char *connection = http_get_header_field(&res.hdr, "Connection");
-            const char *upgrade = http_get_header_field(&res.hdr, "Upgrade");
-            if (connection != NULL && upgrade != NULL &&
-                (strstr(connection, "upgrade") != NULL || strstr(connection, "Upgrade") != NULL) &&
-                strcmp(upgrade, "websocket") == 0)
-            {
-                const char *ws_accept = http_get_header_field(&res.hdr, "Sec-WebSocket-Accept");
-                if (ws_calc_accept_key(ctx.ws_key, buf0) == 0) {
-                    use_rev_proxy = (strcmp(buf0, ws_accept) == 0) ? 2 : 1;
-                }
-            } else {
-                ctx.status = 101;
-                ctx.origin = INTERNAL;
-                res.status = http_get_status(501);
-            }
-        }
-
-        // Let 300 be formatted by origin server
-        if (use_rev_proxy && res.status->code >= 301 && res.status->code < 600) {
-            const char *content_type = http_get_header_field(&res.hdr, "Content-Type");
-            const char *content_length_f = http_get_header_field(&res.hdr, "Content-Length");
-            const char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
-            if (content_encoding == NULL && content_type != NULL && content_length_f != NULL && strncmp(content_type, "text/html", 9) == 0) {
-                long content_len = strtol(content_length_f, NULL, 10);
-                if (content_len <= sizeof(msg_content) - 1) {
-                    if (ctx.status != 101) {
-                        ctx.status = res.status->code;
-                        ctx.origin = res.status->code >= 400 ? SERVER : NONE;
-                    }
-                    use_rev_proxy = 0;
-                    rev_proxy_dump(msg_content, content_len);
-                }
-            }
-        }
-
-        /*
-        char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
-        if (use_rev_proxy && content_encoding == NULL) {
-            int http_comp = http_get_compression(&req, &res);
-            if (http_comp & COMPRESS_BR) {
-                use_rev_proxy |= REV_PROXY_COMPRESS_BR;
-            } else if (http_comp & COMPRESS_GZ) {
-                use_rev_proxy |= REV_PROXY_COMPRESS_GZ;
-            }
-        }
-
-        char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
-        int chunked = transfer_encoding != NULL && strcmp(transfer_encoding, "chunked") == 0;
-        http_remove_header_field(&res.hdr, "Transfer-Encoding", HTTP_REMOVE_ALL);
-        ret = sprintf(buf0, "%s%s%s",
-                      (use_rev_proxy & REV_PROXY_COMPRESS_BR) ? "br" :
-                      ((use_rev_proxy & REV_PROXY_COMPRESS_GZ) ? "gzip" : ""),
-                      ((use_rev_proxy & REV_PROXY_COMPRESS) && chunked) ? ", " : "",
-                      chunked ? "chunked" : "");
-        if (ret > 0) {
-            http_add_header_field(&res.hdr, "Transfer-Encoding", buf0);
-        }
-        */
-    } else {
-        print(ERR_STR "Unknown host type: %i" CLR_STR, conf->type);
-        res.status = http_get_status(501);
-    }
-
-    respond:
-    if (!use_rev_proxy) {
-        if (conf != NULL && conf->type == CONFIG_TYPE_LOCAL && uri.is_static && res.status->code == 405) {
-            http_add_header_field(&res.hdr, "Allow", "GET, HEAD, TRACE");
-        }
-        if (http_get_header_field(&res.hdr, "Accept-Ranges") == NULL) {
-            http_add_header_field(&res.hdr, "Accept-Ranges", "none");
-        }
-        if (!use_fastcgi && file == NULL) {
-            http_remove_header_field(&res.hdr, "Date", HTTP_REMOVE_ALL);
-            http_remove_header_field(&res.hdr, "Server", HTTP_REMOVE_ALL);
-            http_remove_header_field(&res.hdr, "Cache-Control", HTTP_REMOVE_ALL);
-            http_remove_header_field(&res.hdr, "Content-Type", HTTP_REMOVE_ALL);
-            http_remove_header_field(&res.hdr, "Content-Encoding", HTTP_REMOVE_ALL);
-            http_add_header_field(&res.hdr, "Date", http_get_date(buf0, sizeof(buf0)));
-            http_add_header_field(&res.hdr, "Server", SERVER_STR);
-            http_add_header_field(&res.hdr, "Cache-Control", "no-cache");
-            http_add_header_field(&res.hdr, "Content-Type", "text/html; charset=UTF-8");
-
-            // TODO list Locations on 3xx Redirects
-            const http_doc_info *info = http_get_status_info(res.status);
-            const http_status_msg *http_msg = http_get_error_msg(res.status);
-
-            if (msg_content[0] == 0) {
-                if (res.status->code >= 300 && res.status->code < 400) {
-                    const char *location = http_get_header_field(&res.hdr, "Location");
-                    if (location != NULL) {
-                        snprintf(msg_content, sizeof(msg_content), "<ul>\n\t<li><a href=\"%1$s\">%1$s</a></li>\n</ul>\n", location);
-                    }
-                }
-            } else if (strncmp(msg_content, "<!DOCTYPE html>", 15) == 0 || strncmp(msg_content, "<html", 5) == 0) {
-                msg_content[0] = 0;
-                // TODO let relevant information pass?
-            }
-
-            char *rev_proxy_doc = "";
-            if (conf != NULL && conf->type == CONFIG_TYPE_REVERSE_PROXY) {
-                const http_status *status = http_get_status(ctx.status);
-                char stat_str[8];
-                sprintf(stat_str, "%03i", ctx.status);
-                sprintf(msg_pre_buf_2, http_rev_proxy_document,
-                        " success",
-                        (ctx.origin == CLIENT_REQ) ? " error" : " success",
-                        (ctx.origin == INTERNAL) ? " error" : " success",
-                        (ctx.origin == SERVER_REQ) ? " error" : (ctx.status == 0 ? "" : " success"),
-                        (ctx.origin == CLIENT_RES) ? " error" : " success",
-                        (ctx.origin == SERVER) ? " error" : (ctx.status == 0 ? "" : " success"),
-                        (ctx.origin == SERVER_RES) ? " error" : (ctx.status == 0 ? "" : " success"),
-                        (ctx.origin == INTERNAL) ? " error" : " success",
-                        (ctx.origin == INTERNAL || ctx.origin == SERVER) ? " error" : " success",
-                        res.status->code,
-                        res.status->msg,
-                        (ctx.status == 0) ? "???" : stat_str,
-                        (status != NULL) ? status->msg : "",
-                        host);
-                rev_proxy_doc = msg_pre_buf_2;
-            }
-
-            sprintf(msg_pre_buf_1, info->doc, res.status->code, res.status->msg, http_msg != NULL ? http_msg->msg : "", err_msg[0] != 0 ? err_msg : "");
-            content_length = snprintf(msg_buf, sizeof(msg_buf), http_default_document, res.status->code,
-                                      res.status->msg, msg_pre_buf_1, info->mode, info->icon, info->color, host,
-                                      rev_proxy_doc, msg_content[0] != 0 ? msg_content : "");
-        }
-        if (content_length >= 0) {
-            sprintf(buf0, "%li", content_length);
-            http_remove_header_field(&res.hdr, "Content-Length", HTTP_REMOVE_ALL);
-            http_add_header_field(&res.hdr, "Content-Length", buf0);
-        } else if (http_get_header_field(&res.hdr, "Transfer-Encoding") == NULL) {
-            server_keep_alive = 0;
-        }
-    }
-
-    int close_proxy = 0;
-    if (use_rev_proxy != 2) {
-        const char *conn = http_get_header_field(&res.hdr, "Connection");
-        close_proxy = (conn == NULL || (strstr(conn, "keep-alive") == NULL && strstr(conn, "Keep-Alive") == NULL));
-        http_remove_header_field(&res.hdr, "Connection", HTTP_REMOVE_ALL);
-        http_remove_header_field(&res.hdr, "Keep-Alive", HTTP_REMOVE_ALL);
-        if (server_keep_alive && client_keep_alive) {
-            http_add_header_field(&res.hdr, "Connection", "keep-alive");
-            sprintf(buf0, "timeout=%i, max=%i", CLIENT_TIMEOUT, REQ_PER_CONNECTION);
-            http_add_header_field(&res.hdr, "Keep-Alive", buf0);
-        } else {
-            http_add_header_field(&res.hdr, "Connection", "close");
-        }
-    }
-
-    http_send_response(client, &res);
-    clock_gettime(CLOCK_MONOTONIC, &end);
-    const char *location = http_get_header_field(&res.hdr, "Location");
-    unsigned long micros = (end.tv_nsec - begin.tv_nsec) / 1000 + (end.tv_sec - begin.tv_sec) * 1000000;
-    print("%s%s%03i %s%s%s (%s)%s", http_get_status_color(res.status), use_rev_proxy ? "-> " : "", res.status->code,
-          res.status->msg, location != NULL ? " -> " : "", location != NULL ? location : "",
-          format_duration(micros, buf0), CLR_STR);
-
-    // TODO access/error log file
-
-    if (use_rev_proxy == 2) {
-        // WebSocket
-        print("Upgrading connection to WebSocket connection");
-        ret = ws_handle_connection(client, &rev_proxy);
-        if (ret != 0) {
-            client_keep_alive = 0;
-            close_proxy = 1;
-        }
-        print("WebSocket connection closed");
-    } else if (strcmp(req.method, "HEAD") != 0) {
-        // default response
-        unsigned long snd_len = 0;
-        unsigned long len;
-        if (msg_buf[0] != 0) {
-            ret = sock_send(client, msg_buf, content_length, 0);
-            if (ret <= 0) {
-                print(ERR_STR "Unable to send: %s" CLR_STR, sock_strerror(client));
-            }
-            snd_len += ret;
-        } else if (file != NULL) {
-            while (snd_len < content_length) {
-                len = fread(buffer, 1, CHUNK_SIZE, file);
-                if (snd_len + len > content_length) {
-                    len = content_length - snd_len;
-                }
-                ret = sock_send(client, buffer, len, feof(file) ? 0 : MSG_MORE);
-                if (ret <= 0) {
-                    print(ERR_STR "Unable to send: %s" CLR_STR, sock_strerror(client));
-                    break;
-                }
-                snd_len += ret;
-            }
-        } else if (use_fastcgi) {
-            const char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
-            int chunked = (transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL);
-
-            int flags = (chunked ? FASTCGI_CHUNKED : 0) | (use_fastcgi & (FASTCGI_COMPRESS | FASTCGI_COMPRESS_HOLD));
-            ret = fastcgi_send(&fcgi_conn, client, flags);
-        } else if (use_rev_proxy) {
-            const char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
-            int chunked = transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL;
-
-            const char *content_len = http_get_header_field(&res.hdr, "Content-Length");
-            unsigned long len_to_send = 0;
-            if (content_len != NULL) {
-                len_to_send = strtol(content_len, NULL, 10);
-            }
-
-            int flags = (chunked ? REV_PROXY_CHUNKED : 0) | (use_rev_proxy & REV_PROXY_COMPRESS);
-            ret = rev_proxy_send(client, len_to_send, flags);
-        }
-
-        if (ret < 0) {
-            client_keep_alive = 0;
-        }
-    }
-
-    if (close_proxy && rev_proxy.socket != 0) {
-        print(BLUE_STR "Closing proxy connection" CLR_STR);
-        sock_close(&rev_proxy);
-    }
-
-    clock_gettime(CLOCK_MONOTONIC, &end);
-    micros = (end.tv_nsec - begin.tv_nsec) / 1000 + (end.tv_sec - begin.tv_sec) * 1000000;
-    print("Transfer complete: %s", format_duration(micros, buf0));
-
-    uri_free(&uri);
-    abort:
-    if (fcgi_conn.socket != 0) {
-        shutdown(fcgi_conn.socket, SHUT_RDWR);
-        close(fcgi_conn.socket);
-        fcgi_conn.socket = 0;
-    }
-    http_free_req(&req);
-    http_free_res(&res);
-    return !client_keep_alive;
-}
-
-int client_connection_handler(sock *client, unsigned long client_num) {
-    struct timespec begin, end;
-    int ret, req_num;
-    char buf[1024];
-
-    clock_gettime(CLOCK_MONOTONIC, &begin);
-
-    if (dns_server[0] != 0) {
-        sprintf(buf, "dig @%s +short +time=1 -x %s", dns_server, client_addr_str);
-        FILE *dig = popen(buf, "r");
-        if (dig == NULL) {
-            print(ERR_STR "Unable to start dig: %s" CLR_STR "\n", strerror(errno));
-            goto dig_err;
-        }
-        unsigned long read = fread(buf, 1, sizeof(buf), dig);
-        ret = pclose(dig);
-        if (ret != 0) {
-            print(ERR_STR "Dig terminated with exit code %i" CLR_STR "\n", ret);
-            goto dig_err;
-        }
-        char *ptr = memchr(buf, '\n', read);
-        if (ptr == buf || ptr == NULL) {
-            goto dig_err;
-        }
-        ptr[-1] = 0;
-        client_host_str = malloc(strlen(buf) + 1);
-        strcpy(client_host_str, buf);
-    } else {
-        dig_err:
-        client_host_str = NULL;
-    }
-
-    client_geoip = malloc(GEOIP_MAX_SIZE);
-    long str_off = 0;
-    for (int i = 0; i < MAX_MMDB && mmdbs[i].filename != NULL; i++) {
-        int gai_error, mmdb_res;
-        MMDB_lookup_result_s result = MMDB_lookup_string(&mmdbs[i], client_addr_str, &gai_error, &mmdb_res);
-        if (mmdb_res != MMDB_SUCCESS) {
-            print(ERR_STR "Unable to lookup geoip info: %s" CLR_STR "\n", MMDB_strerror(mmdb_res));
-            continue;
-        } else if (gai_error != 0) {
-            print(ERR_STR "Unable to lookup geoip info" CLR_STR "\n");
-            continue;
-        } else if (!result.found_entry) {
-            continue;
-        }
-
-        MMDB_entry_data_list_s *list;
-        mmdb_res = MMDB_get_entry_data_list(&result.entry, &list);
-        if (mmdb_res != MMDB_SUCCESS) {
-            print(ERR_STR "Unable to lookup geoip info: %s" CLR_STR "\n", MMDB_strerror(mmdb_res));
-            continue;
-        }
-
-        long prev = str_off;
-        if (str_off != 0) {
-            str_off--;
-        }
-        mmdb_json(list, client_geoip, &str_off, GEOIP_MAX_SIZE);
-        if (prev != 0) {
-            client_geoip[prev - 1] = ',';
-        }
-
-        MMDB_free_entry_data_list(list);
-    }
-
-    char client_cc[3];
-    client_cc[0] = 0;
-    if (str_off == 0) {
-        free(client_geoip);
-        client_geoip = NULL;
-    } else {
-        char *pos = client_geoip;
-        pos = strstr(pos, "\"country\":");
-        if (pos != NULL) {
-            pos = strstr(pos, "\"iso_code\":");
-            pos += 12;
-            snprintf(client_cc, sizeof(client_cc), "%s", pos);
-        }
-    }
-
-    print("Connection accepted from %s %s%s%s[%s]", client_addr_str, client_host_str != NULL ? "(" : "",
-          client_host_str != NULL ? client_host_str : "", client_host_str != NULL ? ") " : "",
-          client_cc[0] != 0 ? client_cc : "N/A");
-
-    client_timeout.tv_sec = CLIENT_TIMEOUT;
-    client_timeout.tv_usec = 0;
-    if (setsockopt(client->socket, SOL_SOCKET, SO_RCVTIMEO, &client_timeout, sizeof(client_timeout)) < 0)
-        goto set_timeout_err;
-    if (setsockopt(client->socket, SOL_SOCKET, SO_SNDTIMEO, &client_timeout, sizeof(client_timeout)) < 0) {
-        set_timeout_err:
-        print(ERR_STR "Unable to set timeout for socket: %s" CLR_STR, strerror(errno));
-        return 1;
-    }
-
-    if (client->enc) {
-        client->ssl = SSL_new(client->ctx);
-        SSL_set_fd(client->ssl, client->socket);
-        SSL_set_accept_state(client->ssl);
-
-        ret = SSL_accept(client->ssl);
-        client->_last_ret = ret;
-        client->_errno = errno;
-        client->_ssl_error = ERR_get_error();
-        if (ret <= 0) {
-            print(ERR_STR "Unable to perform handshake: %s" CLR_STR, sock_strerror(client));
-            ret = -1;
-            goto close;
-        }
-    }
-
-    req_num = 0;
-    ret = 0;
-    while (ret == 0 && server_keep_alive && req_num < REQ_PER_CONNECTION) {
-        ret = client_request_handler(client, client_num, req_num++);
-        log_prefix = log_conn_prefix;
-    }
-
-    close:
-    sock_close(client);
-
-    if (rev_proxy.socket != 0) {
-        print(BLUE_STR "Closing proxy connection" CLR_STR);
-        sock_close(&rev_proxy);
-    }
-
-    clock_gettime(CLOCK_MONOTONIC, &end);
-    unsigned long micros = (end.tv_nsec - begin.tv_nsec) / 1000 + (end.tv_sec - begin.tv_sec) * 1000000;
-
-    print("Connection closed (%s)", format_duration(micros, buf));
-    return 0;
-}
-
-int client_handler(sock *client, unsigned long client_num, struct sockaddr_in6 *client_addr) {
-    int ret;
-    struct sockaddr_in6 *server_addr;
-    struct sockaddr_storage server_addr_storage;
-
-    char *color_table[] = {"\x1B[31m", "\x1B[32m", "\x1B[33m", "\x1B[34m", "\x1B[35m", "\x1B[36m"};
-
-    signal(SIGINT, client_terminate);
-    signal(SIGTERM, client_terminate);
-
-    client_addr_str_ptr = malloc(INET6_ADDRSTRLEN);
-    inet_ntop(client_addr->sin6_family, (void *) &client_addr->sin6_addr, client_addr_str_ptr, INET6_ADDRSTRLEN);
-    if (strncmp(client_addr_str_ptr, "::ffff:", 7) == 0) {
-        client_addr_str = client_addr_str_ptr + 7;
-    } else {
-        client_addr_str = client_addr_str_ptr;
-    }
-
-    socklen_t len = sizeof(server_addr_storage);
-    getsockname(client->socket, (struct sockaddr *) &server_addr_storage, &len);
-    server_addr = (struct sockaddr_in6 *) &server_addr_storage;
-    server_addr_str_ptr = malloc(INET6_ADDRSTRLEN);
-    inet_ntop(server_addr->sin6_family, (void *) &server_addr->sin6_addr, server_addr_str_ptr, INET6_ADDRSTRLEN);
-    if (strncmp(server_addr_str_ptr, "::ffff:", 7) == 0) {
-        server_addr_str = server_addr_str_ptr + 7;
-    } else {
-        server_addr_str = server_addr_str_ptr;
-    }
-
-    log_req_prefix = malloc(256);
-    log_client_prefix = malloc(256);
-    sprintf(log_client_prefix, "[%s%4i%s]%s[%*s][%5i]%s", (int) client->enc ? HTTPS_STR : HTTP_STR,
-            ntohs(server_addr->sin6_port), CLR_STR, color_table[client_num % 6], INET6_ADDRSTRLEN, client_addr_str,
-            ntohs(client_addr->sin6_port), CLR_STR);
-
-    log_conn_prefix = malloc(256);
-    sprintf(log_conn_prefix, "[%6i][%*s]%s ", getpid(), INET6_ADDRSTRLEN, server_addr_str, log_client_prefix);
-    log_prefix = log_conn_prefix;
-
-    print("Started child process with PID %i", getpid());
-
-    ret = client_connection_handler(client, client_num);
-
-    free(client_addr_str_ptr);
-    client_addr_str_ptr = NULL;
-    free(server_addr_str_ptr);
-    server_addr_str_ptr = NULL;
-    if (client_host_str != NULL) {
-        free(client_host_str);
-        client_host_str = NULL;
-    }
-    free(log_conn_prefix);
-    log_conn_prefix = NULL;
-    free(log_req_prefix);
-    log_req_prefix = NULL;
-    free(log_client_prefix);
-    log_client_prefix = NULL;
-
-    return ret;
-}

src/client.h

@@ -1,21 +0,0 @@
-/**
- * sesimos - secure, simple, modern web server
- * @brief Client connection and request handlers (header file)
- * @file src/client.h
- * @author Lorenz Stechauner
- * @date 2022-08-16
- */
-
-#ifndef SESIMOS_CLIENT_H
-#define SESIMOS_CLIENT_H
-
-#include "lib/config.h"
-#include "lib/sock.h"
-
-#include <arpa/inet.h>
-
-host_config *get_host_config(const char *host);
-
-int client_handler(sock *client, unsigned long client_num, struct sockaddr_in6 *client_addr);
-
-#endif //SESIMOS_CLIENT_H

src/defs.h

@@ -10,10 +10,11 @@
 #define SESIMOS_DEF_H
 
 #define SERVER_VERSION "4.6"
-#define SERVER_STR "Sesimos/" SERVER_VERSION
+#define SERVER_STR "sesimos/" SERVER_VERSION
-#define SERVER_STR_HTML "Sesimos web server " SERVER_VERSION
+#define SERVER_STR_HTML "sesimos web server " SERVER_VERSION
 
 #define CHUNK_SIZE 8192
+#define MAX_PROXY_CNX_PER_HOST 16
 
 #ifndef DEFAULT_HOST
 #   define DEFAULT_HOST "www.necronda.net"

src/lib/cache.c

@@ -1,394 +0,0 @@
-/**
- * sesimos - secure, simple, modern web server
- * @brief File cache implementation
- * @file src/lib/cache.c
- * @author Lorenz Stechauner
- * @date 2020-12-19
- */
-
-#include "cache.h"
-#include "utils.h"
-#include "compress.h"
-
-#include <stdio.h>
-#include <magic.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#include <string.h>
-#include <errno.h>
-#include <signal.h>
-#include <openssl/evp.h>
-
-
-int cache_continue = 1;
-magic_t magic;
-cache_entry *cache;
-
-int magic_init(void) {
-    magic = magic_open(MAGIC_MIME);
-    if (magic == NULL) {
-        fprintf(stderr, ERR_STR "Unable to open magic cookie: %s" CLR_STR "\n", strerror(errno));
-        return -1;
-    }
-    if (magic_load(magic, CACHE_MAGIC_FILE) != 0) {
-        fprintf(stderr, ERR_STR "Unable to load magic cookie: %s" CLR_STR "\n", magic_error(magic));
-        return -2;
-    }
-    return 0;
-}
-
-void cache_process_term(int _) {
-    cache_continue = 0;
-}
-
-int cache_process(void) {
-    signal(SIGINT, cache_process_term);
-    signal(SIGTERM, cache_process_term);
-
-    int shm_id = shmget(CACHE_SHM_KEY, CACHE_ENTRIES * sizeof(cache_entry), 0);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to create cache shared memory: %s" CLR_STR "\n", strerror(errno));
-        return -1;
-    }
-
-    shmdt(cache);
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach cache shared memory (rw): %s" CLR_STR "\n", strerror(errno));
-        return -2;
-    }
-    cache = shm_rw;
-
-    if (mkdir("/var/sesimos/", 0755) < 0 && errno != EEXIST) {
-        fprintf(stderr, ERR_STR "Unable to create directory '/var/sesimos/': %s" CLR_STR "\n", strerror(errno));
-        return -3;
-    }
-
-    if (mkdir("/var/sesimos/server/", 0755) < 0 && errno != EEXIST) {
-        fprintf(stderr, ERR_STR "Unable to create directory '/var/sesimos/server/': %s" CLR_STR "\n", strerror(errno));
-        return -3;
-    }
-
-    FILE *cache_file = fopen("/var/sesimos/server/cache", "rb");
-    if (cache_file != NULL) {
-        fread(cache, sizeof(cache_entry), CACHE_ENTRIES, cache_file);
-        fclose(cache_file);
-    }
-
-    for (int i = 0; i < CACHE_ENTRIES; i++) {
-        cache[i].is_updating = 0;
-    }
-
-    FILE *file;
-    char buf[CACHE_BUF_SIZE], comp_buf[CACHE_BUF_SIZE], filename_comp_gz[256], filename_comp_br[256];
-    unsigned long read;
-    int compress;
-    EVP_MD_CTX *ctx;
-    unsigned char hash[EVP_MAX_MD_SIZE];
-    unsigned int md_len;
-    int cache_changed = 0;
-    int p_len_gz, p_len_br;
-    int ret;
-    while (cache_continue) {
-        for (int i = 0; i < CACHE_ENTRIES; i++) {
-            if (cache[i].filename[0] != 0 && cache[i].meta.etag[0] == 0 && !cache[i].is_updating) {
-                cache[i].is_updating = 1;
-                fprintf(stdout, "[cache] Hashing file %s\n", cache[i].filename);
-
-                ctx = EVP_MD_CTX_new();
-                EVP_DigestInit(ctx, EVP_sha1());
-                file = fopen(cache[i].filename, "rb");
-                compress = mime_is_compressible(cache[i].meta.type);
-
-                compress_ctx comp_ctx;
-                FILE *comp_file_gz = NULL;
-                FILE *comp_file_br = NULL;
-                if (compress) {
-                    sprintf(buf, "%.*s/.sesimos", cache[i].webroot_len, cache[i].filename);
-                    if (mkdir(buf, 0755) != 0 && errno != EEXIST) {
-                        fprintf(stderr, ERR_STR "Unable to create directory %s: %s" CLR_STR "\n", buf, strerror(errno));
-                        goto comp_err;
-                    }
-
-                    sprintf(buf, "%.*s/.sesimos/cache", cache[i].webroot_len, cache[i].filename);
-                    if (mkdir(buf, 0700) != 0 && errno != EEXIST) {
-                        fprintf(stderr, ERR_STR "Unable to create directory %s: %s" CLR_STR "\n", buf, strerror(errno));
-                        goto comp_err;
-                    }
-
-                    char *rel_path = cache[i].filename + cache[i].webroot_len + 1;
-                    for (int j = 0; j < strlen(rel_path); j++) {
-                        char ch = rel_path[j];
-                        if (ch == '/') ch = '_';
-                        buf[j] = ch;
-                    }
-                    buf[strlen(rel_path)] = 0;
-
-                    p_len_gz = snprintf(filename_comp_gz, sizeof(filename_comp_gz),
-                                        "%.*s/.sesimos/cache/%s.gz",
-                                        cache[i].webroot_len, cache[i].filename, buf);
-                    p_len_br = snprintf(filename_comp_br, sizeof(filename_comp_br),
-                                        "%.*s/.sesimos/cache/%s.br",
-                                        cache[i].webroot_len, cache[i].filename, buf);
-                    if (p_len_gz < 0 || p_len_gz >= sizeof(filename_comp_gz) || p_len_br < 0 || p_len_br >= sizeof(filename_comp_br)) {
-                        fprintf(stderr, ERR_STR "Unable to open cached file: File name for compressed file too long" CLR_STR "\n");
-                        goto comp_err;
-                    }
-
-                    fprintf(stdout, "[cache] Compressing file %s\n", cache[i].filename);
-
-                    comp_file_gz = fopen(filename_comp_gz, "wb");
-                    comp_file_br = fopen(filename_comp_br, "wb");
-                    if (comp_file_gz == NULL || comp_file_br == NULL) {
-                        fprintf(stderr, ERR_STR "Unable to open cached file: %s" CLR_STR "\n", strerror(errno));
-                        comp_err:
-                        compress = 0;
-                    } else {
-                        ret = compress_init(&comp_ctx, COMPRESS_GZ | COMPRESS_BR);
-                        if (ret != 0) {
-                            fprintf(stderr, ERR_STR "Unable to init compression: %s" CLR_STR "\n", strerror(errno));
-                            compress = 0;
-                            fclose(comp_file_gz);
-                            fclose(comp_file_br);
-                        }
-                    }
-                }
-
-                while ((read = fread(buf, 1, CACHE_BUF_SIZE, file)) > 0) {
-                    EVP_DigestUpdate(ctx, buf, read);
-                    if (compress) {
-                        unsigned long avail_in, avail_out;
-                        avail_in = read;
-                        do {
-                            avail_out = CACHE_BUF_SIZE;
-                            compress_compress_mode(&comp_ctx, COMPRESS_GZ,buf + read - avail_in, &avail_in, comp_buf, &avail_out, feof(file));
-                            fwrite(comp_buf, 1, CACHE_BUF_SIZE - avail_out, comp_file_gz);
-                        } while (avail_in != 0 || avail_out != CACHE_BUF_SIZE);
-                        avail_in = read;
-                        do {
-                            avail_out = CACHE_BUF_SIZE;
-                            compress_compress_mode(&comp_ctx, COMPRESS_BR, buf + read - avail_in, &avail_in, comp_buf, &avail_out, feof(file));
-                            fwrite(comp_buf, 1, CACHE_BUF_SIZE - avail_out, comp_file_br);
-                        } while (avail_in != 0 || avail_out != CACHE_BUF_SIZE);
-                    }
-                }
-
-                if (compress) {
-                    compress_free(&comp_ctx);
-                    fclose(comp_file_gz);
-                    fclose(comp_file_br);
-                    fprintf(stdout, "[cache] Finished compressing file %s\n", cache[i].filename);
-                    strcpy(cache[i].meta.filename_comp_gz, filename_comp_gz);
-                    strcpy(cache[i].meta.filename_comp_br, filename_comp_br);
-                } else {
-                    memset(cache[i].meta.filename_comp_gz, 0, sizeof(cache[i].meta.filename_comp_gz));
-                    memset(cache[i].meta.filename_comp_br, 0, sizeof(cache[i].meta.filename_comp_br));
-                }
-
-                EVP_DigestFinal(ctx, hash, &md_len);
-                EVP_MD_CTX_free(ctx);
-
-                memset(cache[i].meta.etag, 0, sizeof(cache[i].meta.etag));
-                for (int j = 0; j < md_len; j++) {
-                    sprintf(cache[i].meta.etag + j * 2, "%02x", hash[j]);
-                }
-                fclose(file);
-                fprintf(stdout, "[cache] Finished hashing file %s\n", cache[i].filename);
-                cache[i].is_updating = 0;
-                cache_changed = 1;
-            }
-        }
-
-        if (cache_changed) {
-            cache_changed = 0;
-            cache_file = fopen("/var/sesimos/server/cache", "wb");
-            if (cache_file == NULL) {
-                fprintf(stderr, ERR_STR "Unable to open cache file: %s" CLR_STR "\n", strerror(errno));
-                return -1;
-            }
-            fwrite(cache, sizeof(cache_entry), CACHE_ENTRIES, cache_file);
-            fclose(cache_file);
-        } else {
-            sleep(1);
-        }
-    }
-
-    return 0;
-}
-
-int cache_init(void) {
-    if (magic_init() != 0) {
-        return -1;
-    }
-
-    int shm_id = shmget(CACHE_SHM_KEY, CACHE_ENTRIES * sizeof(cache_entry), IPC_CREAT | IPC_EXCL | 0600);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to create cache shared memory: %s" CLR_STR "\n", strerror(errno));
-        return -2;
-    }
-
-    void *shm = shmat(shm_id, NULL, SHM_RDONLY);
-    if (shm == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach cache shared memory (ro): %s" CLR_STR "\n", strerror(errno));
-        return -3;
-    }
-    cache = shm;
-
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach cache shared memory (rw): %s" CLR_STR "\n", strerror(errno));
-        return -4;
-    }
-    cache = shm_rw;
-    memset(cache, 0, CACHE_ENTRIES * sizeof(cache_entry));
-    shmdt(shm_rw);
-    cache = shm;
-
-    pid_t pid = fork();
-    if (pid == 0) {
-        // child
-        if (cache_process() == 0) {
-            return 0;
-        } else {
-            return -6;
-        }
-    } else if (pid > 0) {
-        // parent
-        fprintf(stderr, "Started child process with PID %i as cache-updater\n", pid);
-        return pid;
-    } else {
-        fprintf(stderr, ERR_STR "Unable to create child process: %s" CLR_STR "\n", strerror(errno));
-        return -5;
-    }
-}
-
-int cache_unload(void) {
-    int shm_id = shmget(CACHE_SHM_KEY, 0, 0);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to get cache shared memory id: %s" CLR_STR "\n", strerror(errno));
-        shmdt(cache);
-        return -1;
-    } else if (shmctl(shm_id, IPC_RMID, NULL) < 0) {
-        fprintf(stderr, ERR_STR "Unable to configure cache shared memory: %s" CLR_STR "\n", strerror(errno));
-        shmdt(cache);
-        return -1;
-    }
-    shmdt(cache);
-    return 0;
-}
-
-int cache_update_entry(int entry_num, const char *filename, const char *webroot) {
-    void *cache_ro = cache;
-    int shm_id = shmget(CACHE_SHM_KEY, 0, 0);
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        print(ERR_STR "Unable to attach cache shared memory (rw): %s" CLR_STR, strerror(errno));
-        return -1;
-    }
-    cache = shm_rw;
-
-    struct stat statbuf;
-    stat(filename, &statbuf);
-    memcpy(&cache[entry_num].meta.stat, &statbuf, sizeof(statbuf));
-
-    cache[entry_num].webroot_len = (unsigned char) strlen(webroot);
-    strcpy(cache[entry_num].filename, filename);
-
-    magic_setflags(magic, MAGIC_MIME_TYPE);
-    const char *type = magic_file(magic, filename);
-    char type_new[24];
-    sprintf(type_new, "%s", type);
-    if (strncmp(type, "text/", 5) == 0) {
-        if (strcmp(filename + strlen(filename) - 4, ".css") == 0) {
-            sprintf(type_new, "text/css");
-        } else if (strcmp(filename + strlen(filename) - 3, ".js") == 0) {
-            sprintf(type_new, "application/javascript");
-        }
-    }
-    strcpy(cache[entry_num].meta.type, type_new);
-
-    magic_setflags(magic, MAGIC_MIME_ENCODING);
-    strcpy(cache[entry_num].meta.charset, magic_file(magic, filename));
-
-    memset(cache[entry_num].meta.etag, 0, sizeof(cache[entry_num].meta.etag));
-    memset(cache[entry_num].meta.filename_comp_gz, 0, sizeof(cache[entry_num].meta.filename_comp_gz));
-    memset(cache[entry_num].meta.filename_comp_br, 0, sizeof(cache[entry_num].meta.filename_comp_br));
-    cache[entry_num].is_updating = 0;
-
-    shmdt(shm_rw);
-    cache = cache_ro;
-    return 0;
-}
-
-int cache_filename_comp_invalid(const char *filename) {
-    void *cache_ro = cache;
-    int shm_id = shmget(CACHE_SHM_KEY, 0, 0);
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        print(ERR_STR "Unable to attach cache shared memory (rw): %s" CLR_STR, strerror(errno));
-        return -1;
-    }
-    cache = shm_rw;
-
-    int i;
-    for (i = 0; i < CACHE_ENTRIES; i++) {
-        if (cache[i].filename[0] != 0 && strlen(cache[i].filename) == strlen(filename) &&
-                strcmp(cache[i].filename, filename) == 0) {
-            if (cache[i].is_updating) {
-                return 0;
-            } else {
-                break;
-            }
-        }
-    }
-
-    memset(cache[i].meta.etag, 0, sizeof(cache[i].meta.etag));
-    memset(cache[i].meta.filename_comp_gz, 0, sizeof(cache[i].meta.filename_comp_gz));
-    memset(cache[i].meta.filename_comp_br, 0, sizeof(cache[i].meta.filename_comp_br));
-    cache[i].is_updating = 0;
-
-    shmdt(shm_rw);
-    cache = cache_ro;
-    return 0;
-}
-
-int uri_cache_init(http_uri *uri) {
-    if (uri->filename == NULL) {
-        return 0;
-    }
-
-    int i;
-    for (i = 0; i < CACHE_ENTRIES; i++) {
-        if (cache[i].filename[0] != 0 && strlen(cache[i].filename) == strlen(uri->filename) &&
-                strcmp(cache[i].filename, uri->filename) == 0) {
-            uri->meta = &cache[i].meta;
-            if (cache[i].is_updating) {
-                return 0;
-            } else {
-                break;
-            }
-        }
-    }
-
-    if (uri->meta == NULL) {
-        for (i = 0; i < CACHE_ENTRIES; i++) {
-            if (cache[i].filename[0] == 0) {
-                if (cache_update_entry(i, uri->filename, uri->webroot) != 0) {
-                    return -1;
-                }
-                uri->meta = &cache[i].meta;
-                break;
-            }
-        }
-    } else {
-        struct stat statbuf;
-        stat(uri->filename, &statbuf);
-        if (memcmp(&uri->meta->stat.st_mtime, &statbuf.st_mtime, sizeof(statbuf.st_mtime)) != 0) {
-            if (cache_update_entry(i, uri->filename, uri->webroot) != 0) {
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}

src/lib/cache.h

@@ -1,50 +0,0 @@
-/**
- * sesimos - secure, simple, modern web server
- * @brief File cache implementation (header file)
- * @file src/lib/cache.h
- * @author Lorenz Stechauner
- * @date 2020-12-19
- */
-
-#ifndef SESIMOS_CACHE_H
-#define SESIMOS_CACHE_H
-
-#include "uri.h"
-
-#define CACHE_SHM_KEY 255641
-#define CACHE_ENTRIES 1024
-#define CACHE_BUF_SIZE 16384
-
-#ifndef CACHE_MAGIC_FILE
-#   define CACHE_MAGIC_FILE "/usr/share/file/misc/magic.mgc"
-#endif
-
-
-typedef struct {
-    char filename[256];
-    unsigned char webroot_len;
-    unsigned char is_updating:1;
-    meta_data meta;
-} cache_entry;
-
-extern cache_entry *cache;
-
-extern int cache_continue;
-
-int magic_init(void);
-
-void cache_process_term(int _);
-
-int cache_process(void);
-
-int cache_init(void);
-
-int cache_unload(void);
-
-int cache_update_entry(int entry_num, const char *filename, const char *webroot);
-
-int cache_filename_comp_invalid(const char *filename);
-
-int uri_cache_init(http_uri *uri);
-
-#endif //SESIMOS_CACHE_H

src/lib/compress.c

@@ -8,22 +8,19 @@
 
 #include "compress.h"
 
-#include <malloc.h>
 #include <errno.h>
 
 
 int compress_init(compress_ctx *ctx, int mode) {
-    ctx->gzip = NULL;
     ctx->brotli = NULL;
     ctx->mode = 0;
     int ret;
     if (mode & COMPRESS_GZ) {
         ctx->mode |= COMPRESS_GZ;
-        ctx->gzip = malloc(sizeof(z_stream));
+        ctx->gzip.zalloc = Z_NULL;
-        ctx->gzip->zalloc = Z_NULL;
+        ctx->gzip.zfree = Z_NULL;
-        ctx->gzip->zfree = Z_NULL;
+        ctx->gzip.opaque = Z_NULL;
-        ctx->gzip->opaque = Z_NULL;
+        ret = deflateInit2(&ctx->gzip, COMPRESS_LEVEL_GZIP, Z_DEFLATED, 15 + 16, 9, Z_DEFAULT_STRATEGY);
-        ret = deflateInit2(ctx->gzip, COMPRESS_LEVEL_GZIP, Z_DEFLATED, 15 + 16, 9, Z_DEFAULT_STRATEGY);
         if (ret != Z_OK) return -1;
     }
     if (mode & COMPRESS_BR) {
@@ -49,13 +46,13 @@ int compress_compress_mode(compress_ctx *ctx, int mode, const char *in, unsigned
         errno = EINVAL;
         return -1;
     } else if (mode & COMPRESS_GZ) {
-        ctx->gzip->next_in = (unsigned char*) in;
+        ctx->gzip.next_in = (unsigned char*) in;
-        ctx->gzip->avail_in = *in_len;
+        ctx->gzip.avail_in = *in_len;
-        ctx->gzip->next_out = (unsigned char*) out;
+        ctx->gzip.next_out = (unsigned char*) out;
-        ctx->gzip->avail_out = *out_len;
+        ctx->gzip.avail_out = *out_len;
-        int ret = deflate(ctx->gzip, finish ? Z_FINISH : Z_NO_FLUSH);
+        int ret = deflate(&ctx->gzip, finish ? Z_FINISH : Z_NO_FLUSH);
-        *in_len = ctx->gzip->avail_in;
+        *in_len = ctx->gzip.avail_in;
-        *out_len = ctx->gzip->avail_out;
+        *out_len = ctx->gzip.avail_out;
         return ret;
     } else if (mode & COMPRESS_BR) {
         int ret = BrotliEncoderCompressStream(ctx->brotli, finish ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
@@ -68,11 +65,6 @@ int compress_compress_mode(compress_ctx *ctx, int mode, const char *in, unsigned
 }
 
 int compress_free(compress_ctx *ctx) {
-    if (ctx->gzip != NULL) {
-        deflateEnd(ctx->gzip);
-        free(ctx->gzip);
-        ctx->gzip = NULL;
-    }
     if (ctx->brotli != NULL) {
         BrotliEncoderDestroyInstance(ctx->brotli);
         ctx->brotli = NULL;

src/lib/compress.h

@@ -21,17 +21,15 @@
 
 typedef struct {
     int mode;
-    z_stream *gzip;
+    z_stream gzip;
     BrotliEncoderState *brotli;
 } compress_ctx;
 
 int compress_init(compress_ctx *ctx, int mode);
 
-int compress_compress(compress_ctx *ctx, const char *in, unsigned long *in_len, char *out, unsigned long *out_len,
+int compress_compress(compress_ctx *ctx, const char *in, unsigned long *in_len, char *out, unsigned long *out_len, int finish);
-                      int finish);
 
-int compress_compress_mode(compress_ctx *ctx, int mode, const char *in, unsigned long *in_len, char *out,
+int compress_compress_mode(compress_ctx *ctx, int mode, const char *in, unsigned long *in_len, char *out, unsigned long *out_len, int finish);
-                           unsigned long *out_len, int finish);
 
 int compress_free(compress_ctx *ctx);
 

src/lib/config.c

@@ -6,92 +6,41 @@
  * @date 2021-01-05
  */
 
+#include "../logger.h"
 #include "config.h"
-#include "utils.h"
 
 #include <stdio.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
 #include <string.h>
-#include <errno.h>
 #include <stdlib.h>
 
-
+config_t config;
-t_config *config;
-char geoip_dir[256], dns_server[256];
-
-int config_init(void) {
-    int shm_id = shmget(CONFIG_SHM_KEY, sizeof(t_config), IPC_CREAT | IPC_EXCL | 0640);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to create config shared memory: %s" CLR_STR "\n", strerror(errno));
-        return -1;
-    }
-
-    void *shm = shmat(shm_id, NULL, SHM_RDONLY);
-    if (shm == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach config shared memory (ro): %s" CLR_STR "\n", strerror(errno));
-        return -2;
-    }
-    config = shm;
-
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach config shared memory (rw): %s" CLR_STR "\n", strerror(errno));
-        return -3;
-    }
-    config = shm_rw;
-    memset(config, 0, sizeof(t_config));
-    shmdt(shm_rw);
-    config = shm;
-    return 0;
-}
-
-int config_unload(void) {
-    int shm_id = shmget(CONFIG_SHM_KEY, 0, 0);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to get config shared memory id: %s" CLR_STR "\n", strerror(errno));
-        shmdt(config);
-        return -1;
-    } else if (shmctl(shm_id, IPC_RMID, NULL) < 0) {
-        fprintf(stderr, ERR_STR "Unable to configure config shared memory: %s" CLR_STR "\n", strerror(errno));
-        shmdt(config);
-        return -1;
-    }
-    shmdt(config);
-    return 0;
-}
 
 int config_load(const char *filename) {
     FILE *file = fopen(filename, "r");
     if (file == NULL) {
-        fprintf(stderr, ERR_STR "Unable to open config file: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to open config file");
         return -1;
     }
 
-    fseek(file, 0, SEEK_END);
+    memset(&config, 0, sizeof(config));
-    unsigned long len = ftell(file);
-    fseek(file, 0, SEEK_SET);
-    char *conf = alloca(len + 1);
-    fread(conf, 1, len, file);
-    conf[len] = 0;
-    fclose(file);
-
-    t_config *tmp_config = malloc(sizeof(t_config));
-    memset(tmp_config, 0, sizeof(t_config));
 
     int i = 0;
     int j = 0;
-    int line = 0;
+    int line_num = 0;
     int mode = 0;
     char section = 0;
-    char *ptr = NULL;
     char *source, *target;
-    while ((ptr = strsep(&conf, "\r\n")) != NULL) {
+
-        line++;
+    char *line = NULL;
-        char *comment = strchr(ptr, '#');
+    ssize_t read;
+    size_t line_len = 0;
+    while ((read = getline(&line, &line_len, file)) != -1) {
+        line_num++;
+        char *ptr = line;
+        char *comment = strpbrk(ptr, "#\r\n");
         if (comment != NULL) comment[0] = 0;
 
-        len = strlen(ptr);
+        unsigned long len = strlen(ptr);
         char *end_ptr = ptr + len - 1;
         while (end_ptr[0] == ' ' || end_ptr[0] == '\t') {
             end_ptr[0] = 0;
@@ -109,7 +58,7 @@ int config_load(const char *filename) {
                 while (ptr[0] == ' ' || ptr[0] == '\t' || ptr[0] == ']') ptr++;
                 while (ptr[l] != ' ' && ptr[l] != '\t' && ptr[l] != ']') l++;
                 if (l == 0) goto err;
-                snprintf(tmp_config->hosts[i].name, sizeof(tmp_config->hosts[i].name), "%.*s", l, ptr);
+                snprintf(config.hosts[i].name, sizeof(config.hosts[i].name), "%.*s", l, ptr);
                 i++;
                 section = 'h';
             } else if (strncmp(ptr, "cert", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
@@ -117,7 +66,7 @@ int config_load(const char *filename) {
                 while (ptr[0] == ' ' || ptr[0] == '\t' || ptr[0] == ']') ptr++;
                 while (ptr[l] != ' ' && ptr[l] != '\t' && ptr[l] != ']') l++;
                 if (l == 0) goto err;
-                snprintf(tmp_config->certs[j].name, sizeof(tmp_config->certs[j].name), "%.*s", l, ptr);
+                snprintf(config.certs[j].name, sizeof(config.certs[j].name), "%.*s", l, ptr);
                 j++;
                 section = 'c';
             } else {
@@ -127,15 +76,15 @@ int config_load(const char *filename) {
         } else if (section == 0) {
             if (len > 10 && strncmp(ptr, "geoip_dir", 9) == 0 && (ptr[9] == ' ' || ptr[9] == '\t')) {
                 source = ptr + 9;
-                target = geoip_dir;
+                target = config.geoip_dir;
             } else if (len > 11 && strncmp(ptr, "dns_server", 10) == 0 && (ptr[10] == ' ' || ptr[10] == '\t')) {
                 source = ptr + 10;
-                target = dns_server;
+                target = config.dns_server;
             } else {
                 goto err;
             }
         } else if (section == 'c') {
-            cert_config *cc = &tmp_config->certs[j - 1];
+            cert_config_t *cc = &config.certs[j - 1];
             if (len > 12 && strncmp(ptr, "certificate", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
                 source = ptr + 11;
                 target = cc->full_chain;
@@ -146,7 +95,7 @@ int config_load(const char *filename) {
                 goto err;
             }
         } else if (section == 'h') {
-            host_config *hc = &tmp_config->hosts[i - 1];
+            host_config_t *hc = &config.hosts[i - 1];
             if (len > 8 && strncmp(ptr, "webroot", 7) == 0 && (ptr[7] == ' ' || ptr[7] == '\t')) {
                 source = ptr + 7;
                 target = hc->local.webroot;
@@ -169,7 +118,7 @@ int config_load(const char *filename) {
                 }
             } else if (len > 9 && strncmp(ptr, "hostname", 8) == 0 && (ptr[8] == ' ' || ptr[8] == '\t')) {
                 source = ptr + 8;
-                target = hc->rev_proxy.hostname;
+                target = hc->proxy.hostname;
                 if (hc->type != 0 && hc->type != CONFIG_TYPE_REVERSE_PROXY) {
                     goto err;
                 } else {
@@ -189,7 +138,7 @@ int config_load(const char *filename) {
                     goto err;
                 } else {
                     hc->type = CONFIG_TYPE_REVERSE_PROXY;
-                    hc->rev_proxy.enc = 0;
+                    hc->proxy.enc = 0;
                 }
                 continue;
             } else if (strcmp(ptr, "https") == 0) {
@@ -197,7 +146,7 @@ int config_load(const char *filename) {
                     goto err;
                 } else {
                     hc->type = CONFIG_TYPE_REVERSE_PROXY;
-                    hc->rev_proxy.enc = 1;
+                    hc->proxy.enc = 1;
                 }
                 continue;
             } else {
@@ -210,8 +159,7 @@ int config_load(const char *filename) {
         while (source[0] == ' ' || source[0] == '\t') source++;
         if (strlen(source) == 0) {
             err:
-            free(tmp_config);
+            critical("Unable to parse config file (line %i)", line);
-            fprintf(stderr, ERR_STR "Unable to parse config file (line %i)" CLR_STR "\n", line);
             return -2;
         }
 
@@ -219,23 +167,25 @@ int config_load(const char *filename) {
             strcpy(target, source);
         } else if (mode == 1) {
             if (strcmp(source, "forbidden") == 0) {
-                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
+                config.hosts[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
             } else if (strcmp(source, "info") == 0) {
-                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
+                config.hosts[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
             } else if (strcmp(source, "list") == 0) {
-                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
+                config.hosts[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
             } else {
                 goto err;
             }
         } else if (mode == 2) {
-            tmp_config->hosts[i - 1].rev_proxy.port = (unsigned short) strtoul(source, NULL, 10);
+            config.hosts[i - 1].proxy.port = (unsigned short) strtoul(source, NULL, 10);
         }
     }
 
+    free(line);
+
     for (int k = 0; k < i; k++) {
-        host_config *hc = &tmp_config->hosts[k];
+        host_config_t *hc = &config.hosts[k];
         if (hc->type == CONFIG_TYPE_LOCAL) {
-            char *webroot = tmp_config->hosts[k].local.webroot;
+            char *webroot = config.hosts[k].local.webroot;
             if (webroot[strlen(webroot) - 1] == '/') {
                 webroot[strlen(webroot) - 1] = 0;
             }
@@ -243,7 +193,7 @@ int config_load(const char *filename) {
         if (hc->cert_name[0] == 0) goto err2;
         int found = 0;
         for (int m = 0; m < j; m++) {
-            if (strcmp(tmp_config->certs[m].name, hc->cert_name) == 0) {
+            if (strcmp(config.certs[m].name, hc->cert_name) == 0) {
                 hc->cert = m;
                 found = 1;
                 break;
@@ -251,27 +201,23 @@ int config_load(const char *filename) {
         }
         if (!found) {
             err2:
-            free(tmp_config);
+            critical("Unable to parse config file");
-            fprintf(stderr, ERR_STR "Unable to parse config file" CLR_STR "\n");
             return -2;
         }
     }
 
-    int shm_id = shmget(CONFIG_SHM_KEY, 0, 0);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to get config shared memory id: %s" CLR_STR "\n", strerror(errno));
-        shmdt(config);
-        return -3;
-    }
-
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        free(tmp_config);
-        fprintf(stderr, ERR_STR "Unable to attach config shared memory (rw): %s" CLR_STR "\n", strerror(errno));
-        return -4;
-    }
-    memcpy(shm_rw, tmp_config, sizeof(t_config));
-    free(tmp_config);
-    shmdt(shm_rw);
     return 0;
 }
+
+host_config_t *get_host_config(const char *host) {
+    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
+        host_config_t *hc = &config.hosts[i];
+        if (hc->type == CONFIG_TYPE_UNSET) break;
+        if (strcmp(hc->name, host) == 0) return hc;
+        if (hc->name[0] == '*' && hc->name[1] == '.') {
+            const char *pos = strstr(host, hc->name + 1);
+            if (pos != NULL && strlen(pos) == strlen(hc->name + 1)) return hc;
+        }
+    }
+    return NULL;
+}

src/lib/config.h

@@ -10,8 +10,8 @@
 #define SESIMOS_CONFIG_H
 
 #include "uri.h"
+#include "../cache_handler.h"
 
-#define CONFIG_SHM_KEY 255642
 #define CONFIG_MAX_HOST_CONFIG 64
 #define CONFIG_MAX_CERT_CONFIG 64
 
@@ -29,37 +29,37 @@ typedef struct {
     char name[256];
     char cert_name[256];
     int cert;
+    cache_t *cache;
     union {
         struct {
             char hostname[256];
             unsigned short port;
             unsigned char enc:1;
-        } rev_proxy;
+        } proxy;
         struct {
             char webroot[256];
             unsigned char dir_mode:2;
         } local;
     };
-} host_config;
+} host_config_t;
 
 typedef struct {
     char name[256];
     char full_chain[256];
     char priv_key[256];
-} cert_config;
+} cert_config_t;
 
 typedef struct {
-    host_config hosts[CONFIG_MAX_HOST_CONFIG];
+    host_config_t hosts[CONFIG_MAX_HOST_CONFIG];
-    cert_config certs[CONFIG_MAX_CERT_CONFIG];
+    cert_config_t certs[CONFIG_MAX_CERT_CONFIG];
-} t_config;
+    char geoip_dir[256];
+    char dns_server[256];
+} config_t;
 
-extern t_config *config;
+extern config_t config;
-extern char geoip_dir[256], dns_server[256];
-
-int config_init(void);
 
 int config_load(const char *filename);
 
-int config_unload(void);
+host_config_t *get_host_config(const char *host);
 
 #endif //SESIMOS_CONFIG_H

src/lib/fastcgi.c

@@ -10,6 +10,7 @@
 #include "utils.h"
 #include "compress.h"
 #include "../server.h"
+#include "../logger.h"
 
 #include <sys/un.h>
 #include <sys/socket.h>
@@ -52,8 +53,7 @@ char *fastcgi_add_param(char *buf, const char *key, const char *value) {
     return ptr;
 }
 
-int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client,
+int fastcgi_init(fastcgi_cnx_t *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client, const http_req *req, const http_uri *uri) {
-                 const http_req *req, const http_uri *uri) {
     unsigned short req_id = (client_num & 0xFFF) << 4;
     if (client_num == 0) {
         req_id |= (req_num + 1) & 0xF;
@@ -68,7 +68,7 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
 
     int fcgi_sock = socket(AF_UNIX, SOCK_STREAM, 0);
     if (fcgi_sock < 0) {
-        print(ERR_STR "Unable to create unix socket: %s" CLR_STR, strerror(errno));
+        error("Unable to create unix socket");
         return -1;
     }
     conn->socket = fcgi_sock;
@@ -81,7 +81,7 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
     }
 
     if (connect(conn->socket, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0) {
-        print(ERR_STR "Unable to connect to unix socket of FastCGI socket: %s" CLR_STR, strerror(errno));
+        error("Unable to connect to unix socket of FastCGI socket");
         return -1;
     }
 
@@ -101,7 +101,7 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
             {.roleB1 = (FCGI_RESPONDER >> 8) & 0xFF, .roleB0 = FCGI_RESPONDER & 0xFF, .flags = 0}
     };
     if (send(conn->socket, &begin, sizeof(begin), 0) != sizeof(begin)) {
-        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
@@ -132,8 +132,8 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
     addr = (struct sockaddr_in6 *) &addr_storage;
     sprintf(buf0, "%i", addr->sin6_port);
     param_ptr = fastcgi_add_param(param_ptr, "REMOTE_PORT", buf0);
-    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_ADDR", client_addr_str);
+    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_ADDR", conn->r_addr);
-    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_HOST", client_host_str != NULL ? client_host_str : client_addr_str);
+    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_HOST", conn->r_host != NULL ? conn->r_host : conn->r_addr);
     //param_ptr = fastcgi_add_param(param_ptr, "REMOTE_IDENT", "");
     //param_ptr = fastcgi_add_param(param_ptr, "REMOTE_USER", "");
 
@@ -156,9 +156,9 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
     param_ptr = fastcgi_add_param(param_ptr, "CONTENT_LENGTH", content_length != NULL ? content_length : "");
     const char *content_type = http_get_header_field(&req->hdr, "Content-Type");
     param_ptr = fastcgi_add_param(param_ptr, "CONTENT_TYPE", content_type != NULL ? content_type : "");
-    if (client_geoip != NULL) {
+    //if (conn->ctx->geoip[0] != 0) {
-        param_ptr = fastcgi_add_param(param_ptr, "REMOTE_INFO", client_geoip);
+    //    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_INFO", conn->ctx->geoip);
-    }
+    //}
 
     for (int i = 0; i < req->hdr.field_num; i++) {
         const http_field *f = &req->hdr.fields[i];
@@ -186,7 +186,7 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
     header.contentLengthB0 = param_len & 0xFF;
     memcpy(param_buf, &header, sizeof(header));
     if (send(conn->socket, param_buf, param_len + sizeof(header), 0) != param_len + sizeof(header)) {
-        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
@@ -194,14 +194,14 @@ int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned
     header.contentLengthB1 = 0;
     header.contentLengthB0 = 0;
     if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) {
-        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
     return 0;
 }
 
-int fastcgi_close_stdin(fastcgi_conn *conn) {
+int fastcgi_close_stdin(fastcgi_cnx_t *conn) {
     FCGI_Header header = {
             .version = FCGI_VERSION_1,
             .type = FCGI_STDIN,
@@ -214,14 +214,14 @@ int fastcgi_close_stdin(fastcgi_conn *conn) {
     };
 
     if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) {
-        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
     return 0;
 }
 
-int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, char *err_msg) {
+int fastcgi_php_error(const fastcgi_cnx_t *conn, const char *msg, int msg_len, char *err_msg) {
     char *msg_str = malloc(msg_len + 1);
     char *ptr0 = msg_str;
     memcpy(msg_str, msg, msg_len);
@@ -231,7 +231,7 @@ int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, ch
     int err = 0;
     // FIXME *msg is part of a stream, handle fragmented lines
     while (1) {
-        int msg_type = 0;
+        log_lvl_t msg_type = LOG_INFO;
         int msg_pre_len = 0;
         ptr1 = strstr(ptr0, "PHP message: ");
         if (ptr1 == NULL) {
@@ -245,16 +245,16 @@ int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, ch
         }
 
         if (len >= 14 && strncmp(ptr0, "PHP Warning:  ", 14) == 0) {
-            msg_type = 1;
+            msg_type = LOG_WARNING;
             msg_pre_len = 14;
         } else if (len >= 18 && strncmp(ptr0, "PHP Fatal error:  ", 18) == 0) {
-            msg_type = 2;
+            msg_type = LOG_ERROR;
             msg_pre_len = 18;
         } else if (len >= 18 && strncmp(ptr0, "PHP Parse error:  ", 18) == 0) {
-            msg_type = 2;
+            msg_type = LOG_ERROR;
             msg_pre_len = 18;
         } else if (len >= 18 && strncmp(ptr0, "PHP Notice:  ", 13) == 0) {
-            msg_type = 1;
+            msg_type = LOG_NOTICE;
             msg_pre_len = 13;
         }
 
@@ -267,7 +267,7 @@ int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, ch
             if (ptr3 != NULL && (ptr3 - ptr2) < len2) {
                 len2 = (int) (ptr3 - ptr2);
             }
-            print("%s%.*s%s", msg_type == 1 ? WRN_STR : msg_type == 2 ? ERR_STR : "", len2, ptr2, CLR_STR);
+            logmsgf(msg_type, "%.*s", len2, ptr2);
             if (msg_type == 2 && ptr2 == ptr0) {
                 strcpy_rem_webroot(err_msg, ptr2, len2, conn->webroot);
                 err = 1;
@@ -288,7 +288,7 @@ int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, ch
     return err;
 }
 
-int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
+int fastcgi_header(fastcgi_cnx_t *conn, http_res *res, char *err_msg) {
     FCGI_Header header;
     char *content;
     unsigned short content_len, req_id;
@@ -300,12 +300,12 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
         if (ret < 0) {
             res->status = http_get_status(500);
             sprintf(err_msg, "Unable to communicate with FastCGI socket.");
-            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+            error("Unable to receive from FastCGI socket");
             return 1;
         } else if (ret != sizeof(header)) {
             res->status = http_get_status(500);
             sprintf(err_msg, "Unable to communicate with FastCGI socket.");
-            print(ERR_STR "Unable to receive from FastCGI socket" CLR_STR);
+            error("Unable to receive from FastCGI socket");
             return 1;
         }
         req_id = (header.requestIdB1 << 8) | header.requestIdB0;
@@ -315,13 +315,13 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
         if (ret < 0) {
             res->status = http_get_status(500);
             sprintf(err_msg, "Unable to communicate with FastCGI socket.");
-            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+            error("Unable to receive from FastCGI socket");
             free(content);
             return 1;
         } else if (ret != (content_len + header.paddingLength)) {
             res->status = http_get_status(500);
             sprintf(err_msg, "Unable to communicate with FastCGI socket.");
-            print(ERR_STR "Unable to receive from FastCGI socket" CLR_STR);
+            error("Unable to receive from FastCGI socket");
             free(content);
             return 1;
         }
@@ -335,10 +335,10 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
             int app_status = (body->appStatusB3 << 24) | (body->appStatusB2 << 16) | (body->appStatusB1 << 8) |
                              body->appStatusB0;
             if (body->protocolStatus != FCGI_REQUEST_COMPLETE) {
-                print(ERR_STR "FastCGI protocol error: %i" CLR_STR, body->protocolStatus);
+                error("FastCGI protocol error: %i", body->protocolStatus);
             }
             if (app_status != 0) {
-                print(ERR_STR "FastCGI app terminated with exit code %i" CLR_STR, app_status);
+                error("FastCGI app terminated with exit code %i", app_status);
             }
             close(conn->socket);
             conn->socket = 0;
@@ -352,7 +352,7 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
         } else if (header.type == FCGI_STDOUT) {
             break;
         } else {
-            print(ERR_STR "Unknown FastCGI type: %i" CLR_STR, header.type);
+            error("Unknown FastCGI type: %i", header.type);
         }
 
         free(content);
@@ -369,13 +369,13 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
     char *buf = content;
     unsigned short header_len = conn->out_off;
     if (header_len <= 0) {
-        print(ERR_STR "Unable to parse header: End of header not found" CLR_STR);
+        error("Unable to parse header: End of header not found");
         return 1;
     }
 
     for (int i = 0; i < header_len; i++) {
         if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
-            print(ERR_STR "Unable to parse header: Header contains illegal characters" CLR_STR);
+            error("Unable to parse header: Header contains illegal characters");
             return 2;
         }
     }
@@ -384,7 +384,7 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
     while (header_len != (ptr - buf)) {
         char *pos0 = strstr(ptr, "\r\n");
         if (pos0 == NULL) {
-            print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
+            error("Unable to parse header: Invalid header format");
             return 1;
         }
 
@@ -399,7 +399,7 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
     return 0;
 }
 
-int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
+int fastcgi_send(fastcgi_cnx_t *conn, sock *client, int flags) {
     FCGI_Header header;
     long ret;
     char buf0[256];
@@ -413,13 +413,13 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
     if (flags & FASTCGI_COMPRESS_BR) {
         flags &= ~FASTCGI_COMPRESS_GZ;
         if (compress_init(&comp_ctx, COMPRESS_BR) != 0) {
-            print(ERR_STR "Unable to init brotli: %s" CLR_STR, strerror(errno));
+            error("Unable to init brotli");
             flags &= ~FASTCGI_COMPRESS_BR;
         }
     } else if (flags & FASTCGI_COMPRESS_GZ) {
         flags &= ~FASTCGI_COMPRESS_BR;
         if (compress_init(&comp_ctx, COMPRESS_GZ) != 0) {
-            print(ERR_STR "Unable to init gzip: %s" CLR_STR, strerror(errno));
+            error("Unable to init gzip");
             flags &= ~FASTCGI_COMPRESS_GZ;
         }
     }
@@ -434,11 +434,10 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
     while (1) {
         ret = recv(conn->socket, &header, sizeof(header), 0);
         if (ret < 0) {
-            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+            error("Unable to receive from FastCGI socket");
             return -1;
         } else if (ret != sizeof(header)) {
-            print(ERR_STR "Unable to receive from FastCGI socket: received len (%li) != header len (%li)" CLR_STR,
+            error("Unable to receive from FastCGI socket: received len (%li) != header len (%li)", ret, sizeof(header));
-                  ret, sizeof(header));
             return -1;
         }
 
@@ -451,7 +450,7 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
         while (rcv_len < content_len + header.paddingLength) {
             ret = recv(conn->socket, content + rcv_len, content_len + header.paddingLength - rcv_len, 0);
             if (ret < 0) {
-                print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+                error("Unable to receive from FastCGI socket");
                 free(content);
                 return -1;
             }
@@ -463,10 +462,10 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
             int app_status = (body->appStatusB3 << 24) | (body->appStatusB2 << 16) | (body->appStatusB1 << 8) |
                              body->appStatusB0;
             if (body->protocolStatus != FCGI_REQUEST_COMPLETE) {
-                print(ERR_STR "FastCGI protocol error: %i" CLR_STR, body->protocolStatus);
+                error("FastCGI protocol error: %i", body->protocolStatus);
             }
             if (app_status != 0) {
-                print(ERR_STR "FastCGI app terminated with exit code %i" CLR_STR, app_status);
+                error("FastCGI app terminated with exit code %i", app_status);
             }
             close(conn->socket);
             conn->socket = 0;
@@ -494,13 +493,12 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
             unsigned long avail_in, avail_out;
             out:
             avail_in = content_len;
-            void *next_in = ptr;
+            char *next_in = ptr;
             do {
                 int buf_len = content_len;
                 if (flags & FASTCGI_COMPRESS) {
                     avail_out = sizeof(comp_out);
-                    compress_compress(&comp_ctx, next_in + content_len - avail_in, &avail_in, comp_out, &avail_out,
+                    compress_compress(&comp_ctx, next_in + content_len - avail_in, &avail_in, comp_out, &avail_out, finish_comp);
-                                      finish_comp);
                     ptr = comp_out;
                     buf_len = (int) (sizeof(comp_out) - avail_out);
                 }
@@ -513,13 +511,13 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
             } while ((flags & FASTCGI_COMPRESS) && (avail_in != 0 || avail_out != sizeof(comp_out)));
             if (finish_comp) goto finish;
         } else {
-            print(ERR_STR "Unknown FastCGI type: %i" CLR_STR, header.type);
+            error("Unknown FastCGI type: %i", header.type);
         }
         free(content);
     }
 }
 
-int fastcgi_dump(fastcgi_conn *conn, char *buf, long len) {
+int fastcgi_dump(fastcgi_cnx_t *conn, char *buf, long len) {
     FCGI_Header header;
     long ret;
     char buf0[256];
@@ -533,11 +531,10 @@ int fastcgi_dump(fastcgi_conn *conn, char *buf, long len) {
     while (1) {
         ret = recv(conn->socket, &header, sizeof(header), 0);
         if (ret < 0) {
-            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+            error("Unable to receive from FastCGI socket");
             return -1;
         } else if (ret != sizeof(header)) {
-            print(ERR_STR "Unable to receive from FastCGI socket: received len (%li) != header len (%li)" CLR_STR,
+            error("Unable to receive from FastCGI socket: received len (%li) != header len (%li)", ret, sizeof(header));
-                  ret, sizeof(header));
             return -1;
         }
 
@@ -549,7 +546,7 @@ int fastcgi_dump(fastcgi_conn *conn, char *buf, long len) {
         while (rcv_len < content_len + header.paddingLength) {
             ret = recv(conn->socket, content + rcv_len, content_len + header.paddingLength - rcv_len, 0);
             if (ret < 0) {
-                print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+                error("Unable to receive from FastCGI socket");
                 free(content);
                 return -1;
             }
@@ -561,10 +558,10 @@ int fastcgi_dump(fastcgi_conn *conn, char *buf, long len) {
             int app_status = (body->appStatusB3 << 24) | (body->appStatusB2 << 16) | (body->appStatusB1 << 8) |
                              body->appStatusB0;
             if (body->protocolStatus != FCGI_REQUEST_COMPLETE) {
-                print(ERR_STR "FastCGI protocol error: %i" CLR_STR, body->protocolStatus);
+                error("FastCGI protocol error: %i", body->protocolStatus);
             }
             if (app_status != 0) {
-                print(ERR_STR "FastCGI app terminated with exit code %i" CLR_STR, app_status);
+                error("FastCGI app terminated with exit code %i", app_status);
             }
             close(conn->socket);
             conn->socket = 0;
@@ -579,13 +576,13 @@ int fastcgi_dump(fastcgi_conn *conn, char *buf, long len) {
         } else if (header.type == FCGI_STDOUT) {
             ptr += snprintf(ptr, len - (ptr - buf), "%.*s", content_len, content);
         } else {
-            print(ERR_STR "Unknown FastCGI type: %i" CLR_STR, header.type);
+            error("Unknown FastCGI type: %i", header.type);
         }
         free(content);
     }
 }
 
-int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len) {
+int fastcgi_receive(fastcgi_cnx_t *conn, sock *client, unsigned long len) {
     unsigned long rcv_len = 0;
     char *buf[16384];
     long ret;
@@ -603,7 +600,7 @@ int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len) {
     while (rcv_len < len) {
         ret = sock_recv(client, buf, sizeof(buf), 0);
         if (ret <= 0) {
-            print(ERR_STR "Unable to receive: %s" CLR_STR, sock_strerror(client));
+            error("Unable to receive: %s", sock_strerror(client));
             return -1;
         }
 
@@ -613,14 +610,14 @@ int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len) {
         if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) goto err;
         if (send(conn->socket, buf, ret, 0) != ret) {
             err:
-            print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
+            error("Unable to send to FastCGI socket");
             return -2;
         }
     }
     return 0;
 }
 
-int fastcgi_receive_chunked(fastcgi_conn *conn, sock *client) {
+int fastcgi_receive_chunked(fastcgi_cnx_t *conn, sock *client) {
     long ret;
     unsigned long next_len;
 

src/lib/fastcgi.h

@@ -36,25 +36,27 @@ typedef struct {
     const char *webroot;
     unsigned short out_len;
     unsigned short out_off;
-} fastcgi_conn;
+    char *r_addr;
+    char *r_host;
+} fastcgi_cnx_t;
 
 char *fastcgi_add_param(char *buf, const char *key, const char *value);
 
-int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client,
+int fastcgi_init(fastcgi_cnx_t *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client,
                  const http_req *req, const http_uri *uri);
 
-int fastcgi_close_stdin(fastcgi_conn *conn);
+int fastcgi_close_stdin(fastcgi_cnx_t *conn);
 
-int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, char *err_msg);
+int fastcgi_php_error(const fastcgi_cnx_t *conn, const char *msg, int msg_len, char *err_msg);
 
-int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg);
+int fastcgi_header(fastcgi_cnx_t *conn, http_res *res, char *err_msg);
 
-int fastcgi_send(fastcgi_conn *conn, sock *client, int flags);
+int fastcgi_send(fastcgi_cnx_t *conn, sock *client, int flags);
 
-int fastcgi_dump(fastcgi_conn *conn, char *buf, long len);
+int fastcgi_dump(fastcgi_cnx_t *conn, char *buf, long len);
 
-int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len);
+int fastcgi_receive(fastcgi_cnx_t *conn, sock *client, unsigned long len);
 
-int fastcgi_receive_chunked(fastcgi_conn *conn, sock *client);
+int fastcgi_receive_chunked(fastcgi_cnx_t *conn, sock *client);
 
 #endif //SESIMOS_FASTCGI_H

src/lib/geoip.c

@@ -7,9 +7,14 @@
  */
 
 #include "geoip.h"
+#include "../logger.h"
+#include <memory.h>
+#include <dirent.h>
 
 
-MMDB_entry_data_list_s *mmdb_json(MMDB_entry_data_list_s *list, char *str, long *str_off, long str_len) {
+static MMDB_s mmdbs[GEOIP_MAX_MMDB];
+
+static MMDB_entry_data_list_s *geoip_json(MMDB_entry_data_list_s *list, char *str, long *str_off, long str_len) {
     switch (list->entry_data.type) {
         case MMDB_DATA_TYPE_MAP:
             *str_off += sprintf(str + *str_off, "{");
@@ -33,7 +38,7 @@ MMDB_entry_data_list_s *mmdb_json(MMDB_entry_data_list_s *list, char *str, long
             *str_off += sprintf(str + *str_off, "%llu", (unsigned long long) list->entry_data.uint128);
             break;
         case MMDB_DATA_TYPE_INT32:
-            *str_off += sprintf(str + *str_off, "%i", list->entry_data.uint32);
+            *str_off += sprintf(str + *str_off, "%i", list->entry_data.int32);
             break;
         case MMDB_DATA_TYPE_BOOLEAN:
             *str_off += sprintf(str + *str_off, "%s", list->entry_data.boolean ? "true" : "false");
@@ -45,13 +50,14 @@ MMDB_entry_data_list_s *mmdb_json(MMDB_entry_data_list_s *list, char *str, long
             *str_off += sprintf(str + *str_off, "%f", list->entry_data.double_value);
             break;
     }
-    if (list->entry_data.type != MMDB_DATA_TYPE_MAP && list->entry_data.type != MMDB_DATA_TYPE_ARRAY) {
+
+    if (list->entry_data.type != MMDB_DATA_TYPE_MAP && list->entry_data.type != MMDB_DATA_TYPE_ARRAY)
         return list->next;
-    }
+
     MMDB_entry_data_list_s *next = list->next;
     int stat = 0;
     for (int i = 0; i < list->entry_data.data_size; i++) {
-        next = mmdb_json(next, str, str_off, str_len);
+        next = geoip_json(next, str, str_off, str_len);
         if (list->entry_data.type == MMDB_DATA_TYPE_MAP) {
             stat = !stat;
             if (stat) {
@@ -60,12 +66,127 @@ MMDB_entry_data_list_s *mmdb_json(MMDB_entry_data_list_s *list, char *str, long
                 continue;
             }
         }
-        if (i != list->entry_data.data_size - 1) *str_off += sprintf(str + *str_off, ",");
+        if (i != list->entry_data.data_size - 1)
-    }
+            *str_off += sprintf(str + *str_off, ",");
-    if (list->entry_data.type == MMDB_DATA_TYPE_MAP) {
-        *str_off += sprintf(str + *str_off, "}");
-    } else {
-        *str_off += sprintf(str + *str_off, "]");
     }
+
+    *str_off += sprintf(str + *str_off, (list->entry_data.type == MMDB_DATA_TYPE_MAP) ? "}" : "]");
+
     return next;
 }
+
+int geoip_init(const char *directory) {
+    char buf[512];
+
+    memset(mmdbs, 0, sizeof(mmdbs));
+
+    if (directory[0] == 0)
+        return 0;
+
+    DIR *geoip_dir;
+    if ((geoip_dir = opendir(directory)) == NULL)
+        return -1;
+
+    struct dirent *entry;
+    int i = 0, status;
+    while ((entry = readdir(geoip_dir)) != NULL) {
+        if (strcmp(entry->d_name + strlen(entry->d_name) - 5, ".mmdb") != 0)
+            continue;
+
+        if (i >= GEOIP_MAX_MMDB) {
+            critical("Unable to initialize geoip: Too many .mmdb files");
+            closedir(geoip_dir);
+            return 1;
+        }
+
+        sprintf(buf, "%s/%s", directory, entry->d_name);
+        if ((status = MMDB_open(buf, 0, &mmdbs[i])) != MMDB_SUCCESS) {
+            critical("Unable to initialize geoip: Unable to open .mmdb file: %s", MMDB_strerror(status));
+            closedir(geoip_dir);
+            return 1;
+        }
+        i++;
+    }
+
+    closedir(geoip_dir);
+
+    if (i == 0) {
+        critical("Unable to initialize geoip: No .mmdb files found in %s", directory);
+        return 1;
+    }
+
+    return 0;
+}
+
+void geoip_free() {
+    for (int i = 0; i < GEOIP_MAX_MMDB && mmdbs[i].file_content != NULL; i++) {
+        MMDB_close(&mmdbs[i]);
+    }
+}
+
+int geoip_lookup_country(struct sockaddr *addr, char *str) {
+    for (int i = 0; i < GEOIP_MAX_MMDB && mmdbs[i].file_content != NULL; i++) {
+        // lookup
+        int mmdb_res;
+        MMDB_lookup_result_s result = MMDB_lookup_sockaddr(&mmdbs[i], addr, &mmdb_res);
+        if (mmdb_res != MMDB_SUCCESS) {
+            return -1;
+        } else if (!result.found_entry) {
+            continue;
+        }
+
+        // get country iso code
+        MMDB_entry_data_s data;
+        int status;
+        if ((status = MMDB_get_value(&result.entry, &data, "country", "iso_code", NULL)) != MMDB_SUCCESS) {
+            if (status == MMDB_IO_ERROR) {
+
+            }
+            return -1;
+        }
+
+        // no, or invalid data
+        if (!data.has_data || data.type != MMDB_DATA_TYPE_UTF8_STRING)
+            continue;
+
+        // return country code
+        sprintf(str, "%.2s", data.utf8_string);
+        return 0;
+    }
+
+    // not found
+    return 1;
+}
+
+int geoip_lookup_json(struct sockaddr *addr, char *json, long len) {
+    long str_off = 0;
+    for (int i = 0; i < GEOIP_MAX_MMDB && mmdbs[i].filename != NULL; i++) {
+        int mmdb_res;
+        MMDB_lookup_result_s result = MMDB_lookup_sockaddr(&mmdbs[i], addr, &mmdb_res);
+        if (mmdb_res != MMDB_SUCCESS) {
+            error("Unable to lookup geoip info: %s", MMDB_strerror(mmdb_res));
+            continue;
+        } else if (!result.found_entry) {
+            continue;
+        }
+
+        MMDB_entry_data_list_s *list;
+        if ((mmdb_res = MMDB_get_entry_data_list(&result.entry, &list)) != MMDB_SUCCESS) {
+            error("Unable to lookup geoip info: %s", MMDB_strerror(mmdb_res));
+            continue;
+        }
+
+        long prev = str_off;
+        if (str_off != 0) {
+            str_off--;
+        }
+        geoip_json(list, json, &str_off, len);
+        if (prev != 0) {
+            json[prev - 1] = ',';
+        }
+
+        MMDB_free_entry_data_list(list);
+    }
+
+    return 0;
+}

src/lib/geoip.h

@@ -12,8 +12,13 @@
 
 #include <maxminddb.h>
 
-#define GEOIP_MAX_SIZE 8192
+#define GEOIP_MAX_JSON_SIZE 8192
+#define GEOIP_MAX_MMDB 3
 
-MMDB_entry_data_list_s *mmdb_json(MMDB_entry_data_list_s *list, char *str, long *str_off, long str_len);
+int geoip_init(const char *directory);
+
+void geoip_free();
+
+int geoip_lookup_country(struct sockaddr *addr, char *str);
 
 #endif //SESIMOS_GEOIP_H

src/lib/http.c

@@ -6,6 +6,7 @@
  * @date 2020-12-09
  */
 
+#include "../logger.h"
 #include "http.h"
 #include "utils.h"
 #include "compress.h"
@@ -87,14 +88,14 @@ void http_free_res(http_res *res) {
 
 int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags) {
     if (hdr->last_field_num > hdr->field_num) {
-        print(ERR_STR "Unable to parse header: Invalid state" CLR_STR);
+        error("Unable to parse header: Invalid state");
         return 3;
     }
 
     char *pos1 = (char *) buf, *pos2 = (char *) end_ptr;
     if (buf[0] == ' ' || buf[0] == '\t') {
         if (hdr->last_field_num == -1) {
-            print(ERR_STR "Unable to parse header" CLR_STR);
+            error("Unable to parse header");
             return 3;
         }
         http_field *f = &hdr->fields[(int) hdr->last_field_num];
@@ -107,7 +108,7 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,
 
     pos1 = memchr(buf, ':', end_ptr - buf);
     if (pos1 == NULL) {
-        print(ERR_STR "Unable to parse header" CLR_STR);
+        error("Unable to parse header");
         return 3;
     }
     long len1 = pos1 - buf;
@@ -120,7 +121,7 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,
     int found = http_get_header_field_num_len(hdr, buf, len1);
     if (!(flags & HTTP_MERGE_FIELDS) || found == -1) {
         if (http_add_header_field_len(hdr, buf, len1, pos1, len2 < 0 ? 0 : len2) != 0) {
-            print(ERR_STR "Unable to parse header: Too many header fields" CLR_STR);
+            error("Unable to parse header: Too many header fields");
             return 3;
         }
     } else {
@@ -147,13 +148,13 @@ int http_receive_request(sock *client, http_req *req) {
     while (1) {
         rcv_len = sock_recv(client, buf, CLIENT_MAX_HEADER_SIZE, MSG_PEEK);
         if (rcv_len <= 0) {
-            print("Unable to receive http header: %s", sock_strerror(client));
+            error("Unable to receive http header: %s", sock_strerror(client));
             return -1;
         }
 
         unsigned long header_len = strstr(buf, "\r\n\r\n") - buf + 4;
         if (header_len <= 0) {
-            print(ERR_STR "Unable to parse http header: End of header not found" CLR_STR);
+            error("Unable to parse http header: End of header not found");
             return 5;
         } else {
             rcv_len = sock_recv(client, buf, header_len, 0);
@@ -161,7 +162,7 @@ int http_receive_request(sock *client, http_req *req) {
 
         for (int i = 0; i < header_len; i++) {
             if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
-                print(ERR_STR "Unable to parse http header: Header contains illegal characters" CLR_STR);
+                error("Unable to parse http header: Header contains illegal characters");
                 return 4;
             }
         }
@@ -170,36 +171,36 @@ int http_receive_request(sock *client, http_req *req) {
         while (header_len > (ptr - buf + 2)) {
             pos0 = strstr(ptr, "\r\n");
             if (pos0 == NULL) {
-                print(ERR_STR "Unable to parse http header: Invalid header format" CLR_STR);
+                error("Unable to parse http header: Invalid header format");
                 return 1;
             }
 
             if (req->version[0] == 0) {
-                pos1 = memchr(ptr, ' ', rcv_len - (ptr - buf)) + 1;
+                pos1 = (char *) memchr(ptr, ' ', rcv_len - (ptr - buf)) + 1;
                 if (pos1 == NULL) goto err_hdr_fmt;
 
                 if (pos1 - ptr - 1 >= sizeof(req->method)) {
-                    print(ERR_STR "Unable to parse http header: Method name too long" CLR_STR);
+                    error("Unable to parse http header: Method name too long");
                     return 2;
                 }
 
                 for (int i = 0; i < (pos1 - ptr - 1); i++) {
                     if (ptr[i] < 'A' || ptr[i] > 'Z') {
-                        print(ERR_STR "Unable to parse http header: Invalid method" CLR_STR);
+                        error("Unable to parse http header: Invalid method");
                         return 2;
                     }
                 }
                 snprintf(req->method, sizeof(req->method), "%.*s", (int) (pos1 - ptr - 1), ptr);
 
-                pos2 = memchr(pos1, ' ', rcv_len - (pos1 - buf)) + 1;
+                pos2 = (char *) memchr(pos1, ' ', rcv_len - (pos1 - buf)) + 1;
                 if (pos2 == NULL) {
                     err_hdr_fmt:
-                    print(ERR_STR "Unable to parse http header: Invalid header format" CLR_STR);
+                    error("Unable to parse http header: Invalid header format");
                     return 1;
                 }
 
                 if (memcmp(pos2, "HTTP/", 5) != 0 || memcmp(pos2 + 8, "\r\n", 2) != 0) {
-                    print(ERR_STR "Unable to parse http header: Invalid version" CLR_STR);
+                    error("Unable to parse http header: Invalid version");
                     return 3;
                 }
 
@@ -369,7 +370,7 @@ int http_send_request(sock *server, http_req *req) {
 }
 
 const http_status *http_get_status(unsigned short status_code) {
-    for (int i = 0; i < http_statuses_size / sizeof(http_status); i++) {
+    for (int i = 0; i < http_statuses_size; i++) {
         if (http_statuses[i].code == status_code) {
             return &http_statuses[i];
         }
@@ -379,7 +380,7 @@ const http_status *http_get_status(unsigned short status_code) {
 
 const http_status_msg *http_get_error_msg(const http_status *status) {
     unsigned short code = status->code;
-    for (int i = 0; i < http_status_messages_size / sizeof(http_status_msg); i++) {
+    for (int i = 0; i < http_status_messages_size; i++) {
         if (http_status_messages[i].code == code) {
             return &http_status_messages[i];
         }
@@ -404,8 +405,8 @@ const char *http_get_status_color(const http_status *status) {
 }
 
 char *http_format_date(time_t time, char *buf, size_t size) {
-    struct tm *timeinfo = gmtime(&time);
+    struct tm timeinfo;
-    strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", timeinfo);
+    strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", gmtime_r(&time, &timeinfo));
     return buf;
 }
 
@@ -418,10 +419,10 @@ char *http_get_date(char *buf, size_t size) {
 const http_doc_info *http_get_status_info(const http_status *status) {
     unsigned short code = status->code;
     static http_doc_info info[] = {
-            {"info", HTTP_COLOR_INFO, http_info_icon, http_info_document},
+            {"info",    HTTP_COLOR_INFO,    http_info_icon,    http_info_doc},
-            {"success", HTTP_COLOR_SUCCESS, http_success_icon, http_success_document},
+            {"success", HTTP_COLOR_SUCCESS, http_success_icon, http_success_doc},
-            {"warning", HTTP_COLOR_WARNING, http_warning_icon, http_warning_document},
+            {"warning", HTTP_COLOR_WARNING, http_warning_icon, http_warning_doc},
-            {"error", HTTP_COLOR_ERROR, http_error_icon, http_error_document}
+            {"error",   HTTP_COLOR_ERROR,   http_error_icon,   http_error_doc}
     };
     if (code >= 100 && code < 200) {
         return &info[0];

src/lib/http.h

@@ -32,19 +32,19 @@
 #define HTTP_5XX_STR "\x1B[1;31m"
 
 #define HTTP_COLOR_SUCCESS "#008000"
-#define HTTP_COLOR_INFO "#606060"
+#define HTTP_COLOR_INFO    "#606060"
 #define HTTP_COLOR_WARNING "#E0C000"
-#define HTTP_COLOR_ERROR "#C00000"
+#define HTTP_COLOR_ERROR   "#C00000"
 
 #define CLIENT_MAX_HEADER_SIZE 8192
-#define HTTP_MAX_HEADER_FIELD_NUM 64
+#define HTTP_MAX_HEADER_FIELD_NUM 32
 
 #ifndef SERVER_STR
-#   define SERVER_STR "Sesimos"
+#   define SERVER_STR "sesimos"
 #endif
 
 #ifndef SERVER_STR_HTML
-#   define SERVER_STR_HTML "Sesimos web server"
+#   define SERVER_STR_HTML "sesimos web server"
 #endif
 
 typedef struct {
@@ -69,11 +69,11 @@ typedef struct {
     char type;
     union {
         struct {
-            char name[64];
+            char name[32];
-            char value[192];
+            char value[32];
         } normal;
         struct {
-            char name[192];
+            char name[64 - sizeof(char *)];
             char *value;
         } ex_value;
         struct {
@@ -117,16 +117,10 @@ extern const http_status_msg http_status_messages[];
 extern const int http_statuses_size;
 extern const int http_status_messages_size;
 
-extern const char http_default_document[];
+extern const char http_error_doc[],   http_error_icon[];
-extern const char http_rev_proxy_document[];
+extern const char http_warning_doc[], http_warning_icon[];
-extern const char http_error_document[];
+extern const char http_success_doc[], http_success_icon[];
-extern const char http_error_icon[];
+extern const char http_info_doc[],    http_info_icon[];
-extern const char http_warning_document[];
-extern const char http_warning_icon[];
-extern const char http_success_document[];
-extern const char http_success_icon[];
-extern const char http_info_document[];
-extern const char http_info_icon[];
 
 void http_to_camel_case(char *str, int mode);
 

src/lib/http_static.c

@@ -6,10 +6,8 @@
  * @date 2021-05-03
  */
 
-#include "../defs.h"
 #include "http.h"
 
-
 const http_status http_statuses[] = {
         {100, "Informational", "Continue"},
         {101, "Informational", "Switching Protocols"},
@@ -105,201 +103,56 @@ const http_status_msg http_status_messages[] = {
         {505, "The server does not support, or refuses to support, the HTTP protocol version that was used in the request message."}
 };
 
-const char http_default_document[] =
+const int http_statuses_size = sizeof(http_statuses) / sizeof(http_status);
-        "<!DOCTYPE html>\n"
+const int http_status_messages_size = sizeof(http_status_messages) / sizeof(http_status_msg);
-        "<html lang=\"en\">\n"
-        "<head>\n"
-        "\t<title>%1$i %2$s - %7$s</title>\n"
-        "\t<meta charset=\"UTF-8\"/>\n"
-        "\t<meta name=\"theme-color\" content=\"%6$s\"/>\n"
-        "\t<meta name=\"color-scheme\" content=\"light dark\"/>\n"
-        "\t<meta name=\"apple-mobile-web-app-status-bar-style\" content=\"black-translucent\"/>\n"
-        "\t<meta name=\"viewport\" content=\"width=device-width,initial-scale=1.0\"/>\n"
-        "\t<link rel=\"shortcut icon\" type=\"image/x-icon\" href=\"/favicon.ico\"/>\n"
-        "%5$s"
-        "\t<style>\n"
-        "\t\thtml{font-family:\"Arial\",sans-serif;--error:" HTTP_COLOR_ERROR ";--warning:" HTTP_COLOR_WARNING ";--success:" HTTP_COLOR_SUCCESS ";--info:" HTTP_COLOR_INFO ";--soft:#808080;--color:var(--%4$s);}\n"
-        "\t\tbody{background-color:#F0F0F0;margin:0;}\n"
-        "\t\tmain{max-width:650px;margin:2em auto;}\n"
-        "\t\tsection{margin:2em 1em;background-color:#FFFFFF;border: 1px solid var(--color);border-radius:4px;padding:1em;}\n"
-        "\t\th1,h2,h3,h4,h5,h6{text-align:center;color:var(--color);font-weight:normal;}\n"
-        "\t\th1{font-size:3em;margin:0.125em 0;}\n"
-        "\t\th2{font-size:1.5em;margin:0.25em 0 1em 0;}\n"
-        "\t\tp{text-align:center;font-size:0.875em;}\n"
-        "\t\tdiv.footer{color:var(--soft);font-size:0.75em;text-align:center;margin:2em 0 0.5em 0;}\n"
-        "\t\tdiv.footer a{color:var(--soft);}\n"
-        "\t\tul,ol{width:fit-content;margin:auto;}\n"
-        "\t\tpre{width:fit-content;margin:2em auto 0 auto;}\n"
-        "\n"
-        "\t\tsection.error-ctx{display:flex;padding:0;border:none;}\n"
-        "\t\tdiv.box{flex:100%% 1 1;border:1px solid var(--info);color:var(--info);position:relative;padding:1em;box-sizing:border-box;text-align:center;}\n"
-        "\t\tdiv.box.error{border-color:var(--error);color:var(--error);}\n"
-        "\t\tdiv.box.success{border-color:var(--success);color:var(--success);}\n"
-        "\t\tdiv.arrow{position:absolute;height:20px;width:30px;z-index:10;background-repeat:no-repeat;background-size:contain;}\n"
-        "\t\tdiv.arrow.response{left:-17.5px;bottom:calc(33.3333%% - 10px);}\n"
-        "\t\tdiv.arrow.request{right:-17.5px;top:calc(33.3333%% - 10px);}\n"
-        "\t\tdiv.border{flex:1px 0 0;background-color:var(--info);}\n"
-        "\t\tdiv.border.error{background-color:var(--error);}\n"
-        "\t\tdiv.border.success{background-color:var(--success);}\n"
-        "\t\tdiv.content>span{display:block;color:var(--soft);font-size:0.75em;}\n"
-        "\t\tdiv.content>img{height:3.75rem;margin:0.75rem auto;display:block;}\n"
-        "\t\th3{font-size:2.25em;margin:0.75rem 0 0 0;color:unset;height:2.5rem;}\n"
-        "\t\th4{font-size:1em;margin:0 0 0.75rem 0;color:unset;height:1.25rem;}\n"
-        "\n"
-        "\t\tdiv.arrow.request.success{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjRkZG"
-        "RkZGIiBzdHJva2U9IiMwMDgwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
-        "\t\tdiv.arrow.request.error{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjRkZG"
-        "RkZGIiBzdHJva2U9IiNDMDAwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
-        "\t\tdiv.arrow.response.success{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiNGRkZG"
-        "RkYiIHN0cm9rZT0iIzAwODAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
-        "\t\tdiv.arrow.response.error{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiNGRkZG"
-        "RkYiIHN0cm9rZT0iI0MwMDAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
-        "\n"
-        "\t\t@media(prefers-color-scheme:dark){\n"
-        "\t\t\thtml{color:#FFFFFF;--soft:#404040;}\n"
-        "\t\t\tbody{background-color:#101010;}\n"
-        "\t\t\tsection{background-color:#181818;}\n"
-        "\n"
-        "\t\t\tdiv.arrow.request.success{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjMTgx"
-        "ODE4IiBzdHJva2U9IiMwMDgwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
-        "\t\t\tdiv.arrow.request.error{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjMTgx"
-        "ODE4IiBzdHJva2U9IiNDMDAwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
-        "\t\t\tdiv.arrow.response.success{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiMxODE4"
-        "MTgiIHN0cm9rZT0iIzAwODAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
-        "\t\t\tdiv.arrow.response.error{background-image:url('data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiMxODE4"
-        "MTgiIHN0cm9rZT0iI0MwMDAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
-        "\t\t}\n"
-        "\t\t@media(min-width:650px){\n"
-        "\t\t\tdiv.box:first-child{border-top-left-radius:4px;border-bottom-left-radius:4px;border-right:none;}\n"
-        "\t\t\tdiv.box:last-child{border-top-right-radius:4px;border-bottom-right-radius:4px;border-left:none;}\n"
-        "\t\t\tdiv.box:not(:last-child):not(:first-child){border-left:none;border-right:none;}\n"
-        "\t\t}\n"
-        "\t\t@media(max-width:650px){\n"
-        "\t\t\tsection.error-ctx{flex-direction:column;height:unset;}\n"
-        "\t\t\tdiv.box:first-child{border-top-left-radius:4px;border-top-right-radius:4px;border-bottom:none;padding-top:1em;}\n"
-        "\t\t\tdiv.box:last-child{border-bottom-right-radius:4px;border-bottom-left-radius:4px;border-top:none;padding-bottom:1em;}\n"
-        "\t\t\tdiv.box:not(:last-child):not(:first-child){border-top:none;border-bottom:none;}\n"
-        "\t\t\tdiv.arrow.response{transform:rotate(90deg);top:-10px;left:calc(33.3333%% - 22.5px);right:unset;}\n"
-        "\t\t\tdiv.arrow.request{transform:rotate(90deg);bottom:-10px;right:calc(33.3333%% - 22.5px);top:unset;}\n"
-        "\t\t}\n"
-        "\t</style>\n"
-        "</head>\n"
-        "<body>\n"
-        "\t<main>\n"
-        "\t\t<section>\n"
-        "%3$s"
-        "%9$s"
-        "\t\t\t<div class=\"footer\"><a href=\"https://%7$s/\">%7$s</a> - " SERVER_STR_HTML "</div>\n"
-        "\t\t</section>\n"
-        "%8$s"
-        "\t</main>\n"
-        "</body>\n"
-        "</html>\n";
 
-const char http_rev_proxy_document[] =
+const char http_error_doc[] =
-        "\t\t<section class=\"error-ctx\">\n"
+        "      <h1>%1$i</h1>\n"
-        "\t\t\t<div class=\"box%1$s\">\n"
+        "      <h2>%2$s :&#xFEFF;(</h2>\n"
-        "\t\t\t\t<div class=\"content\">\n"
+        "      <p>%3$s</p>\n"
-        "\t\t\t\t\t<span>Client</span>\n"
+        "      <p>%4$s</p>\n";
-        "\t\t\t\t\t<img src=\"data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iNjQiIGhlaWdodD0iNjQiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHBhdGggZD0iTTIsMzIgYTMwLDMwLDAsMSwwLDYwLDAgYTMwLDMwLDAsMSwwLC02MCww"
-        "IEw2MiwzMiBNNiwxNiBMNTgsMTYgTTYsNDggTDU4LDQ4IE0zMiwyIEwzMiw2MiBhMTUsMzAsMCwx"
-        "LDAsMCwtNjAgYTE1LDMwLDAsMSwwLDAsNjAgWiIgc3Ryb2tlPSIjMDA4MDAwIiBzdHJva2Utd2lk"
-        "dGg9IjIiIGZpbGw9IiMwMDAwMDAwMCIvPjwvc3ZnPgo=\"/>\n"
-        "\t\t\t\t\t<span>Your Browser</span>\n"
-        "\t\t\t\t</div>\n"
-        "\t\t\t\t<div class=\"arrow request%2$s\"></div>\n"
-        "\t\t\t</div>\n"
-        "\t\t\t<div class=\"border%8$s\"></div>\n"
-        "\t\t\t<div class=\"box%3$s\">\n"
-        "\t\t\t\t<div class=\"content\">\n"
-        "\t\t\t\t\t<span>Reverse Proxy</span>\n"
-        "\t\t\t\t\t<h3>%10$03i</h3>\n"
-        "\t\t\t\t\t<h4>%11$s</h4>\n"
-        "\t\t\t\t\t<span>" SERVER_NAME "</span>\n"
-        "\t\t\t\t</div>\n"
-        "\t\t\t\t<div class=\"arrow request%4$s\"></div>\n"
-        "\t\t\t\t<div class=\"arrow response%5$s\"></div>\n"
-        "\t\t\t</div>\n"
-        "\t\t\t<div class=\"border%9$s\"></div>\n"
-        "\t\t\t<div class=\"box%6$s\">\n"
-        "\t\t\t\t<div class=\"content\">\n"
-        "\t\t\t\t\t<span>Server</span>\n"
-        "\t\t\t\t\t<h3>%12$s</h3>\n"
-        "\t\t\t\t\t<h4>%13$s</h4>\n"
-        "\t\t\t\t\t<span>%14$s</span>\n"
-        "\t\t\t\t</div>\n"
-        "\t\t\t\t<div class=\"arrow response%7$s\"></div>\n"
-        "\t\t\t</div>\n"
-        "\t\t</section>\n";
-
-const char http_error_document[] =
-        "\t\t\t<h1>%1$i</h1>\n"
-        "\t\t\t<h2>%2$s :&#xFEFF;(</h2>\n"
-        "\t\t\t<p>%3$s</p>\n"
-        "\t\t\t<p>%4$s</p>\n";
 
 const char http_error_icon[] =
-        "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
+        "  <link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiNDMDAwMDAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjooPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
 
-const char http_warning_document[] =
+const char http_warning_doc[] =
-        "\t\t\t<h1>%1$i</h1>\n"
+        "      <h1>%1$i</h1>\n"
-        "\t\t\t<h2>%2$s :&#xFEFF;)</h2>\n"
+        "      <h2>%2$s :&#xFEFF;)</h2>\n"
-        "\t\t\t<p>%3$s</p>\n"
+        "      <p>%3$s</p>\n"
-        "\t\t\t<p>%4$s</p>\n";
+        "      <p>%4$s</p>\n";
 
 const char http_warning_icon[] =
-        "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
+        "  <link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiNFMEMwMDAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjopPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
 
-const char http_success_document[] =
+const char http_success_doc[] =
-        "\t\t\t<h1>%1$i</h1>\n"
+        "      <h1>%1$i</h1>\n"
-        "\t\t\t<h2>%2$s :&#xFEFF;)</h2>\n"
+        "      <h2>%2$s :&#xFEFF;)</h2>\n"
-        "\t\t\t<p>%3$s</p>\n"
+        "      <p>%3$s</p>\n"
-        "\t\t\t<p>%4$s</p>\n";
+        "      <p>%4$s</p>\n";
 
 const char http_success_icon[] =
-        "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
+        "  <link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiMwMDgwMDAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjopPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
 
-const char http_info_document[] =
+const char http_info_doc[] =
-        "\t\t\t<h1>%1$i</h1>\n"
+        "      <h1>%1$i</h1>\n"
-        "\t\t\t<h2>%2$s :&#xFEFF;)</h2>\n"
+        "      <h2>%2$s :&#xFEFF;)</h2>\n"
-        "\t\t\t<p>%3$s</p>\n"
+        "      <p>%3$s</p>\n"
-        "\t\t\t<p>%4$s</p>\n";
+        "      <p>%4$s</p>\n";
 
 const char http_info_icon[] =
-        "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
+        "  <link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiM2MDYwNjAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjopPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
-
-const int http_statuses_size = sizeof(http_statuses);
-const int http_status_messages_size = sizeof(http_status_messages);

src/lib/mpmc.c

@@ -0,0 +1,175 @@
+
+#include "mpmc.h"
+#include "../logger.h"
+
+#include <errno.h>
+#include <malloc.h>
+#include <memory.h>
+#include <pthread.h>
+#include <signal.h>
+
+typedef struct {
+    mpmc_t *ctx;
+    int worker_id;
+} mpmc_arg_t;
+
+static void *mpmc_worker(void *arg);
+
+int mpmc_init(mpmc_t *ctx, int n_workers, int buf_size, void (*consumer)(void *obj), const char *name) {
+    ctx->alive = 1;
+    ctx->n_workers = n_workers;
+    ctx->size = buf_size, ctx->max_size = buf_size;
+    ctx->rd = 0, ctx->wr = 0;
+    ctx->buffer = NULL, ctx->workers = NULL;
+    ctx->consumer = consumer;
+    ctx->name = name;
+
+    if (sem_init(&ctx->free, 0, ctx->size) != 0 ||
+        sem_init(&ctx->used, 0, 0)         != 0 ||
+        sem_init(&ctx->lck_rd, 0, 1)       != 0 ||
+        sem_init(&ctx->lck_wr, 0, 1)       != 0)
+    {
+        mpmc_destroy(ctx);
+        return -1;
+    }
+
+    if ((ctx->buffer  = malloc(ctx->size      * sizeof(void *)))    == NULL ||
+        (ctx->workers = malloc(ctx->n_workers * sizeof(pthread_t))) == NULL)
+    {
+        mpmc_destroy(ctx);
+        return -1;
+    }
+
+    memset(ctx->buffer,  0, ctx->size      * sizeof(void *));
+    memset(ctx->workers, 0, ctx->n_workers * sizeof(pthread_t));
+
+    for (int i = 0; i < ctx->n_workers; i++) {
+        int ret;
+        if ((ret = pthread_create(&ctx->workers[i], NULL, mpmc_worker, ctx)) != 0) {
+            mpmc_destroy(ctx);
+            errno = ret;
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+int mpmc_queue(mpmc_t *ctx, void *obj) {
+    // wait for buffer to be emptied
+    try_again_1:
+    if (sem_wait(&ctx->free) != 0) {
+        if (errno == EINTR) {
+            errno = 0;
+            goto try_again_1;
+        } else {
+            return -1;
+        }
+    }
+
+    // lock wr field
+    try_again_2:
+    if (sem_wait(&ctx->lck_wr) != 0) {
+        if (errno == EINTR) {
+            errno = 0;
+            goto try_again_2;
+        } else {
+            sem_post(&ctx->free);
+            return -1;
+        }
+    }
+
+    int p = ctx->wr;
+    ctx->wr = (ctx->wr + 1) % ctx->size;
+
+    // unlock wr field
+    sem_post(&ctx->lck_wr);
+
+    // fill buffer with object
+    ctx->buffer[p] = obj;
+
+    // inform worker
+    sem_post(&ctx->used);
+
+    return 0;
+}
+
+static void *mpmc_worker(void *arg) {
+    mpmc_t *ctx = arg;
+
+    int id;
+    for (id = 0; id < ctx->n_workers && ctx->workers[id] != pthread_self(); id++);
+    logger_set_name("%s/%i", ctx->name, id);
+
+    while (ctx->alive) {
+        // wait for buffer to be filled
+        if (sem_wait(&ctx->used) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                continue;
+            } else {
+                critical("Unable to lock semaphore");
+                errno = 0;
+                break;
+            }
+        }
+
+        // lock rd field
+        if (sem_wait(&ctx->lck_rd) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                sem_post(&ctx->used);
+                continue;
+            } else {
+                critical("Unable to lock semaphore");
+                errno = 0;
+                sem_post(&ctx->used);
+                break;
+            }
+        }
+
+        int p = ctx->rd;
+        ctx->rd = (ctx->rd + 1) % ctx->size;
+
+        // unlock rd field
+        sem_post(&ctx->lck_rd);
+
+        // consume object
+        ctx->consumer(ctx->buffer[p]);
+        logger_set_prefix("");
+
+        // unlock slot in buffer
+        sem_post(&ctx->free);
+    }
+
+    return NULL;
+}
+
+void mpmc_stop(mpmc_t *ctx) {
+    ctx->alive = 0;
+}
+
+void mpmc_destroy(mpmc_t *ctx) {
+    int e = errno;
+
+    // stop threads, if running
+    mpmc_stop(ctx);
+    for (int i = 0; i < ctx->n_workers; i++) {
+        if (ctx->workers[i] == 0) break;
+        // FIXME
+        pthread_kill(ctx->workers[i], SIGUSR1);
+        //pthread_join(ctx->workers[i], NULL);
+        pthread_cancel(ctx->workers[i]);
+    }
+
+    sem_destroy(&ctx->free);
+    sem_destroy(&ctx->used);
+    sem_destroy(&ctx->lck_rd);
+    sem_destroy(&ctx->lck_wr);
+    free(ctx->buffer);
+    free(ctx->workers);
+
+    // reset errno
+    errno = e;
+}
+

src/lib/mpmc.h

@@ -0,0 +1,27 @@
+
+#ifndef SESIMOS_MPMC_H
+#define SESIMOS_MPMC_H
+
+#include <semaphore.h>
+
+typedef struct {
+    unsigned char alive;
+    int n_workers;
+    int rd, wr;
+    sem_t free, used, lck_rd, lck_wr;
+    int size, max_size;
+    void **buffer;
+    pthread_t *workers;
+    void (*consumer)(void *obj);
+    const char* name;
+} mpmc_t;
+
+int mpmc_init(mpmc_t *ctx, int n_workers, int buf_size, void (*consumer)(void *obj), const char *name);
+
+int mpmc_queue(mpmc_t *ctx, void *obj);
+
+void mpmc_stop(mpmc_t *ctx);
+
+void mpmc_destroy(mpmc_t *ctx);
+
+#endif //SESIMOS_MPMC_H

src/lib/proxy.c

@@ -1,35 +1,73 @@
 /**
  * sesimos - secure, simple, modern web server
  * @brief Reverse proxy
- * @file src/lib/rev_proxy.c
+ * @file src/lib/proxy.c
  * @author Lorenz Stechauner
  * @date 2021-01-07
  */
 
 #include "../defs.h"
 #include "../server.h"
-#include "rev_proxy.h"
+#include "../logger.h"
+#include "proxy.h"
 #include "utils.h"
 #include "compress.h"
+#include "config.h"
 
 #include <openssl/ssl.h>
 #include <string.h>
 #include <errno.h>
 #include <openssl/err.h>
 #include <arpa/inet.h>
-#include <sys/time.h>
+#include <netdb.h>
 
+static SSL_CTX *proxy_ctx = NULL;
+static proxy_ctx_t *proxies = NULL;
 
-sock rev_proxy;
+int proxy_preload(void) {
-char *rev_proxy_host = NULL;
+    int n = 0;
-struct timeval server_timeout = {.tv_sec = SERVER_TIMEOUT, .tv_usec = 0};
+    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
+        host_config_t *hc = &config.hosts[i];
+        if (hc->type == CONFIG_TYPE_UNSET) break;
+        if (hc->type != CONFIG_TYPE_REVERSE_PROXY) continue;
+        n++;
+    }
+
+    // FIXME return value check
+    proxy_ctx = SSL_CTX_new(TLS_client_method());
+    proxies = malloc(n * MAX_PROXY_CNX_PER_HOST * sizeof(proxy_ctx_t));
+    memset(proxies, 0, n * MAX_PROXY_CNX_PER_HOST * sizeof(proxy_ctx_t));
 
-int rev_proxy_preload(void) {
-    rev_proxy.ctx = SSL_CTX_new(TLS_client_method());
     return 0;
 }
 
-int rev_proxy_request_header(http_req *req, int enc) {
+void proxy_unload(void) {
+    SSL_CTX_free(proxy_ctx);
+    free(proxies);
+}
+
+static proxy_ctx_t *proxy_get_by_conf(host_config_t *conf) {
+    // TODO locking void *proxies
+    int n = 0;
+    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
+        host_config_t *hc = &config.hosts[i];
+        if (hc->type == CONFIG_TYPE_UNSET) break;
+        if (hc->type != CONFIG_TYPE_REVERSE_PROXY) continue;
+        if (hc == conf) break;
+        n++;
+    }
+
+    proxy_ctx_t *ptr = proxies + n * MAX_PROXY_CNX_PER_HOST;
+    for (int i = 0; i < MAX_PROXY_CNX_PER_HOST; i++, ptr++) {
+        if (!ptr->in_use) {
+            return ptr;
+        }
+    }
+
+    return NULL;
+}
+
+int proxy_request_header(http_req *req, sock *sock) {
     char buf1[256], buf2[256];
     int p_len;
 
@@ -40,7 +78,7 @@ int rev_proxy_request_header(http_req *req, int enc) {
     } else {
         p_len = snprintf(buf2, sizeof(buf2), "%s, %s", via, buf1);
         if (p_len < 0 || p_len >= sizeof(buf2)) {
-            print(ERR_STR "Header field 'Via' too long" CLR_STR);
+            error("Header field 'Via' too long");
             return -1;
         }
         http_remove_header_field(&req->hdr, "Via", HTTP_REMOVE_ALL);
@@ -49,15 +87,15 @@ int rev_proxy_request_header(http_req *req, int enc) {
 
     const char *host = http_get_header_field(&req->hdr, "Host");
     const char *forwarded = http_get_header_field(&req->hdr, "Forwarded");
-    int client_ipv6 = strchr(client_addr_str, ':') != NULL;
+    int client_ipv6 = strchr(sock->addr, ':') != NULL;
-    int server_ipv6 = strchr(server_addr_str, ':') != NULL;
+    int server_ipv6 = strchr(sock->s_addr, ':') != NULL;
 
     p_len = snprintf(buf1, sizeof(buf1), "by=%s%s%s;for=%s%s%s;host=%s;proto=%s",
-                     server_ipv6 ? "\"[" : "", server_addr_str, server_ipv6 ? "]\"" : "",
+                     server_ipv6 ? "\"[" : "", sock->s_addr, server_ipv6 ? "]\"" : "",
-                     client_ipv6 ? "\"[" : "", client_addr_str, client_ipv6 ? "]\"" : "",
+                     client_ipv6 ? "\"[" : "", sock->addr, client_ipv6 ? "]\"" : "",
-                     host, enc ? "https" : "http");
+                     host, sock->enc ? "https" : "http");
     if (p_len < 0 || p_len >= sizeof(buf1)) {
-        print(ERR_STR "Appended part of header field 'Forwarded' too long" CLR_STR);
+        error("Appended part of header field 'Forwarded' too long");
         return -1;
     }
 
@@ -66,7 +104,7 @@ int rev_proxy_request_header(http_req *req, int enc) {
     } else {
         p_len = snprintf(buf2, sizeof(buf2), "%s, %s", forwarded, buf1);
         if (p_len < 0 || p_len >= sizeof(buf2)) {
-            print(ERR_STR "Header field 'Forwarded' too long" CLR_STR);
+            error("Header field 'Forwarded' too long");
             return -1;
         }
         http_remove_header_field(&req->hdr, "Forwarded", HTTP_REMOVE_ALL);
@@ -75,9 +113,9 @@ int rev_proxy_request_header(http_req *req, int enc) {
 
     const char *xff = http_get_header_field(&req->hdr, "X-Forwarded-For");
     if (xff == NULL) {
-        http_add_header_field(&req->hdr, "X-Forwarded-For", client_addr_str);
+        http_add_header_field(&req->hdr, "X-Forwarded-For", sock->addr);
     } else {
-        sprintf(buf1, "%s, %s", xff, client_addr_str);
+        sprintf(buf1, "%s, %s", xff, sock->addr);
         http_remove_header_field(&req->hdr, "X-Forwarded-For", HTTP_REMOVE_ALL);
         http_add_header_field(&req->hdr, "X-Forwarded-For", buf1);
     }
@@ -106,7 +144,7 @@ int rev_proxy_request_header(http_req *req, int enc) {
     const char *xfp = http_get_header_field(&req->hdr, "X-Forwarded-Proto");
     if (xfp == NULL) {
         if (forwarded == NULL) {
-            http_add_header_field(&req->hdr, "X-Forwarded-Proto", enc ? "https" : "http");
+            http_add_header_field(&req->hdr, "X-Forwarded-Proto", sock->enc ? "https" : "http");
         } else {
             char *ptr = strchr(forwarded, ',');
             unsigned long len;
@@ -127,14 +165,14 @@ int rev_proxy_request_header(http_req *req, int enc) {
     return 0;
 }
 
-int rev_proxy_response_header(http_req *req, http_res *res, host_config *conf) {
+int proxy_response_header(http_req *req, http_res *res, host_config_t *conf) {
     char buf1[256], buf2[256];
     int p_len;
 
     const char *via = http_get_header_field(&res->hdr, "Via");
     p_len = snprintf(buf1, sizeof(buf1), "HTTP/%s %s", req->version, SERVER_NAME);
     if (p_len < 0 || p_len >= sizeof(buf1)) {
-        print(ERR_STR "Appended part of header field 'Via' too long" CLR_STR);
+        error("Appended part of header field 'Via' too long");
         return -1;
     }
     if (via == NULL) {
@@ -142,7 +180,7 @@ int rev_proxy_response_header(http_req *req, http_res *res, host_config *conf) {
     } else {
         p_len = snprintf(buf2, sizeof(buf2), "%s, %s", via, buf1);
         if (p_len < 0 || p_len >= sizeof(buf2)) {
-            print(ERR_STR "Header field 'Via' too long" CLR_STR);
+            error("Header field 'Via' too long");
             return -1;
         }
         http_remove_header_field(&res->hdr, "Via", HTTP_REMOVE_ALL);
@@ -151,7 +189,7 @@ int rev_proxy_response_header(http_req *req, http_res *res, host_config *conf) {
 
     const char *location = http_get_header_field(&res->hdr, "Location");
     if (location != NULL) {
-        char *hostnames[] = {conf->name, conf->rev_proxy.hostname};
+        char *hostnames[] = {conf->name, conf->proxy.hostname};
         for (int i = 0; i < sizeof(hostnames) / sizeof(hostnames[0]); i++) {
             char *hostname = hostnames[i];
 
@@ -161,10 +199,10 @@ int rev_proxy_response_header(http_req *req, http_res *res, host_config *conf) {
             p_len = snprintf(buf1, sizeof(buf1), "https://%s/", hostname);
             if (strncmp(location, buf1, p_len) == 0) goto match;
 
-            p_len = snprintf(buf1, sizeof(buf1), "http://%s:%i/", hostname, conf->rev_proxy.port);
+            p_len = snprintf(buf1, sizeof(buf1), "http://%s:%i/", hostname, conf->proxy.port);
             if (strncmp(location, buf1, p_len) == 0) goto match;
 
-            p_len = snprintf(buf1, sizeof(buf1), "https://%s:%i/", hostname, conf->rev_proxy.port);
+            p_len = snprintf(buf1, sizeof(buf1), "https://%s:%i/", hostname, conf->proxy.port);
             if (strncmp(location, buf1, p_len) == 0) goto match;
         }
 
@@ -179,51 +217,51 @@ int rev_proxy_response_header(http_req *req, http_res *res, host_config *conf) {
     return 0;
 }
 
-int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config *conf, sock *client, http_status *custom_status, char *err_msg) {
+proxy_ctx_t *proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t *conf, sock *client, http_status *custom_status, char *err_msg) {
     char buffer[CHUNK_SIZE];
     const char *connection, *upgrade, *ws_version;
     long ret;
     int tries = 0, retry = 0;
 
-    if (rev_proxy.socket != 0 && strcmp(rev_proxy_host, conf->name) == 0 && sock_check(&rev_proxy) == 0)
+    proxy_ctx_t *proxy = proxy_get_by_conf(conf);
-        goto rev_proxy;
+    proxy->in_use = 1;
+
+    if (proxy->initialized && sock_check(&proxy->proxy) == 0)
+        goto proxy;
 
     retry:
-    if (rev_proxy.socket != 0) {
+    if (proxy->initialized) {
-        print(BLUE_STR "Closing proxy connection" CLR_STR);
+        info(BLUE_STR "Closing proxy connection");
-        sock_close(&rev_proxy);
+        sock_close(&proxy->proxy);
+        proxy->initialized = 0;
     }
     retry = 0;
     tries++;
 
-    rev_proxy.socket = socket(AF_INET6, SOCK_STREAM, 0);
+    proxy->proxy.socket = socket(AF_INET6, SOCK_STREAM, 0);
-    if (rev_proxy.socket  < 0) {
+    if (proxy->proxy.socket < 0) {
-        print(ERR_STR "Unable to create socket: %s" CLR_STR, strerror(errno));
+        error("Unable to create socket");
         res->status = http_get_status(500);
         ctx->origin = INTERNAL;
-        return -1;
+        return NULL;
     }
 
-    server_timeout.tv_sec = SERVER_TIMEOUT_INIT;
+    if (sock_set_timeout(&proxy->proxy, SERVER_TIMEOUT_INIT) != 0)
-    server_timeout.tv_usec = 0;
+        goto proxy_timeout_err;
-    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
-        goto rev_proxy_timeout_err;
-    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
-        goto rev_proxy_timeout_err;
 
-    struct hostent *host_ent = gethostbyname2(conf->rev_proxy.hostname, AF_INET6);
+    struct hostent *host_ent = gethostbyname2(conf->proxy.hostname, AF_INET6);
     if (host_ent == NULL) {
-        host_ent = gethostbyname2(conf->rev_proxy.hostname, AF_INET);
+        host_ent = gethostbyname2(conf->proxy.hostname, AF_INET);
         if (host_ent == NULL) {
             res->status = http_get_status(503);
             ctx->origin = SERVER_REQ;
-            print(ERR_STR "Unable to connect to server: Name or service not known" CLR_STR);
+            error("Unable to connect to server: Name or service not known");
             sprintf(err_msg, "Unable to connect to server: Name or service not known.");
             goto proxy_err;
         }
     }
 
-    struct sockaddr_in6 address = {.sin6_family = AF_INET6, .sin6_port = htons(conf->rev_proxy.port)};
+    struct sockaddr_in6 address = {.sin6_family = AF_INET6, .sin6_port = htons(conf->proxy.port)};
     if (host_ent->h_addrtype == AF_INET6) {
         memcpy(&address.sin6_addr, host_ent->h_addr_list[0], host_ent->h_length);
     } else if (host_ent->h_addrtype == AF_INET) {
@@ -234,8 +272,8 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
 
     inet_ntop(address.sin6_family, (void *) &address.sin6_addr, buffer, sizeof(buffer));
 
-    print(BLUE_STR "Connecting to " BLD_STR "[%s]:%i" CLR_STR BLUE_STR "..." CLR_STR, buffer, conf->rev_proxy.port);
+    info(BLUE_STR "Connecting to " BLD_STR "[%s]:%i" CLR_STR BLUE_STR "...", buffer, conf->proxy.port);
-    if (connect(rev_proxy.socket, (struct sockaddr *) &address, sizeof(address)) < 0) {
+    if (connect(proxy->proxy.socket, (struct sockaddr *) &address, sizeof(address)) < 0) {
         if (errno == ETIMEDOUT || errno == EINPROGRESS) {
             res->status = http_get_status(504);
             ctx->origin = SERVER_REQ;
@@ -246,47 +284,44 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
             res->status = http_get_status(500);
             ctx->origin = INTERNAL;
         }
-        print(ERR_STR "Unable to connect to [%s]:%i: %s" CLR_STR, buffer, conf->rev_proxy.port, strerror(errno));
+        error("Unable to connect to [%s]:%i: %s", buffer, conf->proxy.port, strerror(errno));
         sprintf(err_msg, "Unable to connect to server: %s.", strerror(errno));
         goto proxy_err;
     }
 
-    server_timeout.tv_sec = SERVER_TIMEOUT;
+    if (sock_set_timeout(&proxy->proxy, SERVER_TIMEOUT) != 0) {
-    server_timeout.tv_usec = 0;
+        proxy_timeout_err:
-    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
-        goto rev_proxy_timeout_err;
-    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) {
-        rev_proxy_timeout_err:
         res->status = http_get_status(500);
         ctx->origin = INTERNAL;
-        print(ERR_STR "Unable to set timeout for reverse proxy socket: %s" CLR_STR, strerror(errno));
+        error("Unable to set timeout for reverse proxy socket");
         sprintf(err_msg, "Unable to set timeout for reverse proxy socket: %s", strerror(errno));
         goto proxy_err;
     }
 
-    if (conf->rev_proxy.enc) {
+    if (conf->proxy.enc) {
-        rev_proxy.ssl = SSL_new(rev_proxy.ctx);
+        proxy->proxy.ssl = SSL_new(proxy_ctx);
-        SSL_set_fd(rev_proxy.ssl, rev_proxy.socket);
+        SSL_set_fd(proxy->proxy.ssl, proxy->proxy.socket);
-        SSL_set_connect_state(rev_proxy.ssl);
+        SSL_set_connect_state(proxy->proxy.ssl);
 
-        ret = SSL_do_handshake(rev_proxy.ssl);
+        ret = SSL_do_handshake(proxy->proxy.ssl);
-        rev_proxy._last_ret = ret;
+        proxy->proxy._last_ret = ret;
-        rev_proxy._errno = errno;
+        proxy->proxy._errno = errno;
-        rev_proxy._ssl_error = ERR_get_error();
+        proxy->proxy._ssl_error = ERR_get_error();
-        rev_proxy.enc = 1;
+        proxy->proxy.enc = 1;
         if (ret < 0) {
             res->status = http_get_status(502);
             ctx->origin = SERVER_REQ;
-            print(ERR_STR "Unable to perform handshake: %s" CLR_STR, sock_strerror(&rev_proxy));
+            error("Unable to perform handshake: %s", sock_strerror(&proxy->proxy));
-            sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&rev_proxy));
+            sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&proxy->proxy));
             goto proxy_err;
         }
     }
 
-    rev_proxy_host = conf->name;
+    proxy->initialized = 1;
-    print(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i" CLR_STR, buffer, conf->rev_proxy.port);
+    proxy->host = conf->name;
+    info(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i", buffer, conf->proxy.port);
 
-    rev_proxy:
+    proxy:
     connection = http_get_header_field(&req->hdr, "Connection");
     if (connection != NULL && (strstr(connection, "upgrade") != NULL || strstr(connection, "Upgrade") != NULL)) {
         upgrade = http_get_header_field(&req->hdr, "Upgrade");
@@ -296,26 +331,26 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
         } else {
             res->status = http_get_status(501);
             ctx->origin = INTERNAL;
-            return -1;
+            return NULL;
         }
     } else {
         http_remove_header_field(&req->hdr, "Connection", HTTP_REMOVE_ALL);
         http_add_header_field(&req->hdr, "Connection", "keep-alive");
     }
 
-    ret = rev_proxy_request_header(req, (int) client->enc);
+    ret = proxy_request_header(req, client);
     if (ret != 0) {
         res->status = http_get_status(500);
         ctx->origin = INTERNAL;
-        return -1;
+        return NULL;
     }
 
-    ret = http_send_request(&rev_proxy, req);
+    ret = http_send_request(&proxy->proxy, req);
     if (ret < 0) {
         res->status = http_get_status(502);
         ctx->origin = SERVER_REQ;
-        print(ERR_STR "Unable to send request to server (1): %s" CLR_STR, sock_strerror(&rev_proxy));
+        error("Unable to send request to server (1): %s", sock_strerror(&proxy->proxy));
-        sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
+        sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&proxy->proxy));
         retry = tries < 4;
         goto proxy_err;
     }
@@ -326,35 +361,35 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
 
     ret = 0;
     if (content_len > 0) {
-        ret = sock_splice(&rev_proxy, client, buffer, sizeof(buffer), content_len);
+        ret = sock_splice(&proxy->proxy, client, buffer, sizeof(buffer), content_len);
     } else if (transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL) {
-        ret = sock_splice_chunked(&rev_proxy, client, buffer, sizeof(buffer));
+        ret = sock_splice_chunked(&proxy->proxy, client, buffer, sizeof(buffer));
     }
 
     if (ret < 0 || (content_len != 0 && ret != content_len)) {
         if (ret == -1) {
             res->status = http_get_status(502);
             ctx->origin = SERVER_REQ;
-            print(ERR_STR "Unable to send request to server (2): %s" CLR_STR, sock_strerror(&rev_proxy));
+            error("Unable to send request to server (2): %s", sock_strerror(&proxy->proxy));
-            sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
+            sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&proxy->proxy));
             retry = tries < 4;
             goto proxy_err;
         } else if (ret == -2) {
             res->status = http_get_status(400);
             ctx->origin = CLIENT_REQ;
-            print(ERR_STR "Unable to receive request from client: %s" CLR_STR, sock_strerror(client));
+            error("Unable to receive request from client: %s", sock_strerror(client));
             sprintf(err_msg, "Unable to receive request from client: %s.", sock_strerror(client));
-            return -1;
+            return NULL;
         }
         res->status = http_get_status(500);
         ctx->origin = INTERNAL;
-        print(ERR_STR "Unknown Error" CLR_STR);
+        error("Unknown Error");
-        return -1;
+        return NULL;
     }
 
-    ret = sock_recv(&rev_proxy, buffer, sizeof(buffer), MSG_PEEK);
+    ret = sock_recv(&proxy->proxy, buffer, sizeof(buffer), MSG_PEEK);
     if (ret <= 0) {
-        int enc_err = sock_enc_error(&rev_proxy);
+        int enc_err = sock_enc_error(&proxy->proxy);
         if (errno == EAGAIN || errno == EINPROGRESS || enc_err == SSL_ERROR_WANT_READ ||
             enc_err == SSL_ERROR_WANT_WRITE)
         {
@@ -364,8 +399,8 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
             res->status = http_get_status(502);
             ctx->origin = SERVER_RES;
         }
-        print(ERR_STR "Unable to receive response from server: %s" CLR_STR, sock_strerror(&rev_proxy));
+        error("Unable to receive response from server: %s", sock_strerror(&proxy->proxy));
-        sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&rev_proxy));
+        sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&proxy->proxy));
         retry = tries < 4;
         goto proxy_err;
     }
@@ -376,7 +411,7 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
     if (header_len <= 0) {
         res->status = http_get_status(502);
         ctx->origin = SERVER_RES;
-        print(ERR_STR "Unable to parse header: End of header not found" CLR_STR);
+        error("Unable to parse header: End of header not found");
         sprintf(err_msg, "Unable to parser header: End of header not found.");
         goto proxy_err;
     }
@@ -385,7 +420,7 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
         if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
             res->status = http_get_status(502);
             ctx->origin = SERVER_RES;
-            print(ERR_STR "Unable to parse header: Header contains illegal characters" CLR_STR);
+            error("Unable to parse header: Header contains illegal characters");
             sprintf(err_msg, "Unable to parse header: Header contains illegal characters.");
             goto proxy_err;
         }
@@ -397,7 +432,7 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
         if (pos0 == NULL) {
             res->status = http_get_status(502);
             ctx->origin = SERVER_RES;
-            print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
+            error("Unable to parse header: Invalid header format");
             sprintf(err_msg, "Unable to parse header: Invalid header format.");
             goto proxy_err;
         }
@@ -405,7 +440,7 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
             if (strncmp(ptr, "HTTP/", 5) != 0) {
                 res->status = http_get_status(502);
                 ctx->origin = SERVER_RES;
-                print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
+                error("Unable to parse header: Invalid header format");
                 sprintf(err_msg, "Unable to parse header: Invalid header format.");
                 goto proxy_err;
             }
@@ -420,7 +455,7 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
             } else if (res->status == NULL) {
                 res->status = http_get_status(502);
                 ctx->origin = SERVER_RES;
-                print(ERR_STR "Unable to parse header: Invalid or unknown status code" CLR_STR);
+                error("Unable to parse header: Invalid or unknown status code");
                 sprintf(err_msg, "Unable to parse header: Invalid or unknown status code.");
                 goto proxy_err;
             }
@@ -429,7 +464,7 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
             if (ret != 0) {
                 res->status = http_get_status(502);
                 ctx->origin = SERVER_RES;
-                print(ERR_STR "Unable to parse header" CLR_STR);
+                error("Unable to parse header");
                 sprintf(err_msg, "Unable to parse header.");
                 goto proxy_err;
             }
@@ -439,58 +474,59 @@ int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_conf
         }
         ptr = pos0 + 2;
     }
-    sock_recv(&rev_proxy, buffer, header_len, 0);
+    sock_recv(&proxy->proxy, buffer, header_len, 0);
 
-    ret = rev_proxy_response_header(req, res, conf);
+    ret = proxy_response_header(req, res, conf);
     if (ret != 0) {
         res->status = http_get_status(500);
         ctx->origin = INTERNAL;
-        return -1;
+        return NULL;
     }
 
-    return 0;
+    return proxy;
 
     proxy_err:
+    errno = 0;
     if (retry) goto retry;
-    return -1;
+    return NULL;
 }
 
-int rev_proxy_send(sock *client, unsigned long len_to_send, int flags) {
+int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags) {
     char buffer[CHUNK_SIZE], comp_out[CHUNK_SIZE], buf[256], *ptr;
     long ret = 0, len, snd_len;
     int finish_comp = 0;
 
     compress_ctx comp_ctx;
-    if (flags & REV_PROXY_COMPRESS_BR) {
+    if (flags & PROXY_COMPRESS_BR) {
-        flags &= ~REV_PROXY_COMPRESS_GZ;
+        flags &= ~PROXY_COMPRESS_GZ;
         if (compress_init(&comp_ctx, COMPRESS_BR) != 0) {
-            print(ERR_STR "Unable to init brotli: %s" CLR_STR, strerror(errno));
+            error("Unable to init brotli");
-            flags &= ~REV_PROXY_COMPRESS_BR;
+            flags &= ~PROXY_COMPRESS_BR;
         }
-    } else if (flags & REV_PROXY_COMPRESS_GZ) {
+    } else if (flags & PROXY_COMPRESS_GZ) {
-        flags &= ~REV_PROXY_COMPRESS_BR;
+        flags &= ~PROXY_COMPRESS_BR;
         if (compress_init(&comp_ctx, COMPRESS_GZ) != 0) {
-            print(ERR_STR "Unable to init gzip: %s" CLR_STR, strerror(errno));
+            error("Unable to init gzip");
-            flags &= ~REV_PROXY_COMPRESS_GZ;
+            flags &= ~PROXY_COMPRESS_GZ;
         }
     }
 
     do {
         snd_len = 0;
-        if (flags & REV_PROXY_CHUNKED) {
+        if (flags & PROXY_CHUNKED) {
-            ret = sock_get_chunk_header(&rev_proxy);
+            ret = sock_get_chunk_header(&proxy->proxy);
             if (ret < 0) {
                 if (ret == -1) {
-                    print("Unable to receive from server: Malformed chunk header");
+                    error("Unable to receive from server: Malformed chunk header");
                 } else {
-                    print("Unable to receive from server: %s", sock_strerror(&rev_proxy));
+                    error("Unable to receive from server: %s", sock_strerror(&proxy->proxy));
                 }
                 break;
             }
 
             len_to_send = ret;
             ret = 1;
-            if (len_to_send == 0 && (flags & REV_PROXY_COMPRESS)) {
+            if (len_to_send == 0 && (flags & PROXY_COMPRESS)) {
                 finish_comp = 1;
                 len = 0;
                 ptr = NULL;
@@ -501,19 +537,19 @@ int rev_proxy_send(sock *client, unsigned long len_to_send, int flags) {
         }
         while (snd_len < len_to_send) {
             unsigned long avail_in, avail_out;
-            ret = sock_recv(&rev_proxy, buffer, CHUNK_SIZE < (len_to_send - snd_len) ? CHUNK_SIZE : len_to_send - snd_len, 0);
+            ret = sock_recv(&proxy->proxy, buffer, CHUNK_SIZE < (len_to_send - snd_len) ? CHUNK_SIZE : len_to_send - snd_len, 0);
             if (ret <= 0) {
-                print("Unable to receive from server: %s", sock_strerror(&rev_proxy));
+                error("Unable to receive from server: %s", sock_strerror(&proxy->proxy));
                 break;
             }
             len = ret;
             ptr = buffer;
             out:
             avail_in = len;
-            void *next_in = ptr;
+            char *next_in = ptr;
             do {
                 long buf_len = len;
-                if (flags & REV_PROXY_COMPRESS) {
+                if (flags & PROXY_COMPRESS) {
                     avail_out = sizeof(comp_out);
                     compress_compress(&comp_ctx, next_in + len - avail_in, &avail_in, comp_out, &avail_out, finish_comp);
                     ptr = comp_out;
@@ -524,34 +560,34 @@ int rev_proxy_send(sock *client, unsigned long len_to_send, int flags) {
                     len = sprintf(buf, "%lX\r\n", buf_len);
                     ret = 1;
 
-                    if (flags & REV_PROXY_CHUNKED) ret = sock_send(client, buf, len, 0);
+                    if (flags & PROXY_CHUNKED) ret = sock_send(client, buf, len, 0);
                     if (ret <= 0) goto err;
 
                     ret = sock_send(client, ptr, buf_len, 0);
                     if (ret <= 0) goto err;
-                    if (!(flags & REV_PROXY_COMPRESS)) snd_len += ret;
+                    if (!(flags & PROXY_COMPRESS)) snd_len += ret;
 
-                    if (flags & REV_PROXY_CHUNKED) ret = sock_send(client, "\r\n", 2, 0);
+                    if (flags & PROXY_CHUNKED) ret = sock_send(client, "\r\n", 2, 0);
                     if (ret <= 0) {
                         err:
-                        print(ERR_STR "Unable to send: %s" CLR_STR, sock_strerror(client));
+                        error("Unable to send: %s", sock_strerror(client));
                         break;
                     }
                 }
-            } while ((flags & REV_PROXY_COMPRESS) && (avail_in != 0 || avail_out != sizeof(comp_out)));
+            } while ((flags & PROXY_COMPRESS) && (avail_in != 0 || avail_out != sizeof(comp_out)));
             if (ret <= 0) break;
             if (finish_comp) goto finish;
         }
         if (ret <= 0) break;
-        if (flags & REV_PROXY_CHUNKED) sock_recv(&rev_proxy, buffer, 2, 0);
+        if (flags & PROXY_CHUNKED) sock_recv(&proxy->proxy, buffer, 2, 0);
-    } while ((flags & REV_PROXY_CHUNKED) && len_to_send > 0);
+    } while ((flags & PROXY_CHUNKED) && len_to_send > 0);
 
     if (ret <= 0) return -1;
 
-    if (flags & REV_PROXY_CHUNKED) {
+    if (flags & PROXY_CHUNKED) {
         ret = sock_send(client, "0\r\n\r\n", 5, 0);
         if (ret <= 0) {
-            print(ERR_STR "Unable to send: %s" CLR_STR, sock_strerror(client));
+            error("Unable to send: %s", sock_strerror(client));
             return -1;
         }
     }
@@ -559,8 +595,7 @@ int rev_proxy_send(sock *client, unsigned long len_to_send, int flags) {
     return 0;
 }
 
-int rev_proxy_dump(char *buf, long len) {
+int proxy_dump(proxy_ctx_t *proxy, char *buf, long len) {
-    sock_recv(&rev_proxy, buf, len, 0);
+    sock_recv(&proxy->proxy, buf, len, 0);
-    sock_close(&rev_proxy);
     return 0;
 }

src/lib/proxy.h

@@ -0,0 +1,45 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Reverse proxy (header file)
+ * @file src/lib/proxy.h
+ * @author Lorenz Stechauner
+ * @date 2021-01-07
+ */
+
+#ifndef SESIMOS_PROXY_H
+#define SESIMOS_PROXY_H
+
+#define PROXY_CHUNKED 1
+#define PROXY_COMPRESS_GZ 2
+#define PROXY_COMPRESS_BR 4
+#define PROXY_COMPRESS 6
+
+#ifndef SERVER_NAME
+#   define SERVER_NAME "reverse proxy"
+#endif
+
+#include "http.h"
+#include "config.h"
+
+typedef struct {
+    unsigned char initialized:1;
+    unsigned char in_use:1;
+    sock proxy;
+    char *host;
+} proxy_ctx_t;
+
+int proxy_preload(void);
+
+void proxy_unload(void);
+
+int proxy_request_header(http_req *req, sock *sock);
+
+int proxy_response_header(http_req *req, http_res *res, host_config_t *conf);
+
+proxy_ctx_t *proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t *conf, sock *client, http_status *custom_status, char *err_msg);
+
+int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags);
+
+int proxy_dump(proxy_ctx_t *proxy, char *buf, long len);
+
+#endif //SESIMOS_PROXY_H

src/lib/res.h

@@ -0,0 +1,28 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief HTTP resources (header file)
+ * @file src/lib/res.h
+ * @author Lorenz Stechauner
+ * @date 2022-12-31
+ */
+
+#ifndef SESIMOS_RES_H
+#define SESIMOS_RES_H
+
+#define http_default_doc        _binary_bin_res_default_txt_start
+#define http_default_doc_size   ((unsigned int) (_binary_bin_res_default_txt_end - _binary_bin_res_default_txt_start) - 1)
+#define http_proxy_doc          _binary_bin_res_proxy_txt_start
+#define http_proxy_doc_size     ((unsigned int) (_binary_bin_res_proxy_txt_end - _binary_bin_res_proxy_txt_start) - 1)
+#define http_style_doc          _binary_bin_res_style_txt_start
+#define http_style_doc_size     ((unsigned int) (_binary_bin_res_style_txt_end - _binary_bin_res_style_txt_start) - 1)
+
+extern const char _binary_bin_res_default_txt_start[];
+extern const char _binary_bin_res_default_txt_end[];
+
+extern const char _binary_bin_res_proxy_txt_start[];
+extern const char _binary_bin_res_proxy_txt_end[];
+
+extern const char _binary_bin_res_style_txt_start[];
+extern const char _binary_bin_res_style_txt_end[];
+
+#endif //SESIMOS_RES_H

src/lib/rev_proxy.h

@@ -1,39 +0,0 @@
-/**
- * sesimos - secure, simple, modern web server
- * @brief Reverse proxy (header file)
- * @file src/lib/rev_proxy.h
- * @author Lorenz Stechauner
- * @date 2021-01-07
- */
-
-#ifndef SESIMOS_REV_PROXY_H
-#define SESIMOS_REV_PROXY_H
-
-#define REV_PROXY_CHUNKED 1
-#define REV_PROXY_COMPRESS_GZ 2
-#define REV_PROXY_COMPRESS_BR 4
-#define REV_PROXY_COMPRESS 6
-
-#ifndef SERVER_NAME
-#   define SERVER_NAME "revproxy"
-#endif
-
-#include "http.h"
-#include "config.h"
-
-extern sock rev_proxy;
-
-int rev_proxy_preload(void);
-
-int rev_proxy_request_header(http_req *req, int enc);
-
-int rev_proxy_response_header(http_req *req, http_res *res, host_config *conf);
-
-int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config *conf, sock *client,
-                   http_status *custom_status, char *err_msg);
-
-int rev_proxy_send(sock *client, unsigned long len_to_send, int flags);
-
-int rev_proxy_dump(char *buf, long len);
-
-#endif //SESIMOS_REV_PROXY_H

src/lib/sock.c

@@ -57,6 +57,23 @@ const char *sock_strerror(sock *s) {
     }
 }
 
+int sock_set_timeout_micros(sock *s, long recv_micros, long send_micros) {
+    struct timeval recv_to = {.tv_sec = recv_micros / 1000000, .tv_usec = recv_micros % 1000000},
+                   send_to = {.tv_sec = send_micros / 1000000, .tv_usec = send_micros % 1000000};
+
+    if (setsockopt(s->socket, SOL_SOCKET, SO_RCVTIMEO, &recv_to, sizeof(recv_to)) != 0)
+        return -1;
+
+    if (setsockopt(s->socket, SOL_SOCKET, SO_SNDTIMEO, &send_to, sizeof(send_to)) != 0)
+        return -1;
+
+    return 0;
+}
+
+int sock_set_timeout(sock *s, int sec) {
+    return sock_set_timeout_micros(s, sec * 1000000L, sec * 1000000L);
+}
+
 long sock_send(sock *s, void *buf, unsigned long len, int flags) {
     long ret;
     if (s->enc) {
@@ -121,21 +138,25 @@ long sock_splice_chunked(sock *dst, sock *src, void *buf, unsigned long buf_len)
 }
 
 int sock_close(sock *s) {
+    int e = errno;
     if ((int) s->enc && s->ssl != NULL) {
         if (s->_last_ret >= 0) SSL_shutdown(s->ssl);
         SSL_free(s->ssl);
         s->ssl = NULL;
     }
-    shutdown(s->socket, SHUT_RDWR);
     close(s->socket);
     s->socket = 0;
     s->enc = 0;
+    errno = e;
     return 0;
 }
 
 int sock_check(sock *s) {
     char buf;
-    return recv(s->socket, &buf, 1, MSG_PEEK | MSG_DONTWAIT) == 1;
+    int e = errno;
+    long ret = sock_recv(s, &buf, 1, MSG_PEEK | MSG_DONTWAIT);
+    errno = e;
+    return ret == 1;
 }
 
 int sock_poll(sock *sockets[], sock *ready[], sock *error[], int n_sock, int *n_ready, int *n_error, short events, int timeout_ms) {
@@ -188,7 +209,6 @@ long sock_get_chunk_header(sock *s) {
     char buf[16];
 
     do {
-        print("debug1");  // TODO remove
         ret = sock_recv(s, buf, sizeof(buf), MSG_PEEK);
         if (ret <= 0) return -2;
         else if (ret < 2) continue;

src/lib/sock.h

@@ -11,10 +11,16 @@
 
 #include <openssl/crypto.h>
 #include <sys/socket.h>
+#include <arpa/inet.h>
 
 typedef struct {
     unsigned int enc:1;
     int socket;
+    union {
+        struct sockaddr sock;
+        struct sockaddr_in6 ipv6;
+    } _addr;
+    char *addr, *s_addr;
     SSL_CTX *ctx;
     SSL *ssl;
     long _last_ret;
@@ -26,6 +32,10 @@ int sock_enc_error(sock *s);
 
 const char *sock_strerror(sock *s);
 
+int sock_set_timeout_micros(sock *s, long recv_micros, long send_micros);
+
+int sock_set_timeout(sock *s, int sec);
+
 long sock_send(sock *s, void *buf, unsigned long len, int flags);
 
 long sock_recv(sock *s, void *buf, unsigned long len, int flags);

src/lib/uri.c

@@ -9,6 +9,7 @@
 #include "uri.h"
 #include "utils.h"
 
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -20,12 +21,16 @@ int path_is_directory(const char *path) {
 
 int path_is_file(const char *path) {
     struct stat statbuf;
-    return stat(path, &statbuf) == 0 && S_ISDIR(statbuf.st_mode) == 0;
+    int ret = stat(path, &statbuf);
+    errno = 0;
+    return ret == 0 && S_ISDIR(statbuf.st_mode) == 0;
 }
 
 int path_exists(const char *path) {
     struct stat statbuf;
-    return stat(path, &statbuf) == 0;
+    int ret = stat(path, &statbuf);
+    errno = 0;
+    return ret == 0;
 }
 
 int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mode) {

src/lib/uri.h

@@ -16,14 +16,18 @@
 #define URI_DIR_MODE_LIST 2
 #define URI_DIR_MODE_INFO 3
 
+#define URI_ETAG_SIZE 65  // SHA256 size (hex)
+#define URI_TYPE_SIZE 64
+#define URI_CHARSET_SIZE 16
+
 typedef struct {
-    char etag[64];
+    char etag[URI_ETAG_SIZE];
-    char type[24];
+    char type[URI_TYPE_SIZE];
-    char charset[16];
+    char charset[URI_CHARSET_SIZE];
     char filename_comp_gz[256];
     char filename_comp_br[256];
     struct stat stat;
-} meta_data;
+} metadata_t;
 
 typedef struct {
     char *webroot;        // "/srv/www/www.test.org"
@@ -33,9 +37,9 @@ typedef struct {
     char *query;          // "username=test"
     char *filename;       // "/account/index.php"
     char *uri;            // "/account/login?username=test"
-    meta_data *meta;
+    metadata_t *meta;
-    unsigned char is_static:1;
+    unsigned int is_static:1;
-    unsigned char is_dir:1;
+    unsigned int is_dir:1;
 } http_uri;
 
 

src/lib/utils.c

@@ -11,10 +11,9 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <time.h>
 
 
-char *log_prefix;
-
 static const char base64_encode_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const int base64_mod_table[3] = {0, 2, 1};
 
@@ -205,3 +204,9 @@ int base64_encode(void *data, unsigned long data_len, char *output, unsigned lon
 
     return 0;
 }
+
+long clock_micros(void) {
+    struct timespec time;
+    clock_gettime(CLOCK_MONOTONIC, &time);
+    return time.tv_sec * 1000000 + time.tv_nsec / 1000;
+}

src/lib/utils.h

@@ -19,19 +19,6 @@
 #define HTTP_STR "\x1B[1;31m"
 #define HTTPS_STR "\x1B[1;32m"
 
-extern char *log_prefix;
-
-
-#define out_1(fmt) fprintf(stdout, "%s" fmt "\n", log_prefix)
-#define out_2(fmt, args...) fprintf(stdout, "%s" fmt "\n", log_prefix, args)
-
-#define out_x(x, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, FUNC, ...) FUNC
-
-#define print(...) out_x(, ##__VA_ARGS__, out_2(__VA_ARGS__), out_2(__VA_ARGS__), out_2(__VA_ARGS__), \
-                         out_2(__VA_ARGS__), out_2(__VA_ARGS__), out_2(__VA_ARGS__), out_2(__VA_ARGS__), \
-                         out_2(__VA_ARGS__), out_1(__VA_ARGS__))
-
-
 char *format_duration(unsigned long micros, char *buf);
 
 int url_encode_component(const void *in, size_t size_in, char *out, size_t size_out);
@@ -50,4 +37,6 @@ int str_trim_lws(char **start, char **end);
 
 int base64_encode(void *data, unsigned long data_len, char *output, unsigned long *output_len);
 
+long clock_micros(void);
+
 #endif //SESIMOS_UTILS_H

src/lib/websocket.c

@@ -7,6 +7,7 @@
  */
 
 #include "../defs.h"
+#include "../logger.h"
 #include "websocket.h"
 #include "utils.h"
 
@@ -45,10 +46,10 @@ int ws_recv_frame_header(sock *s, ws_frame *frame) {
 
     long ret = sock_recv(s, buf, 2, 0);
     if (ret < 0) {
-        print(ERR_STR "Unable to receive from socket: %s" CLR_STR, strerror(errno));
+        error("Unable to receive from socket");
         return -1;
     } else if (ret != 2) {
-        print(ERR_STR "Unable to receive 2 bytes from socket" CLR_STR);
+        error("Unable to receive 2 bytes from socket");
         return -2;
     }
 
@@ -70,10 +71,10 @@ int ws_recv_frame_header(sock *s, ws_frame *frame) {
 
     ret = sock_recv(s, buf, remaining, 0);
     if (ret < 0) {
-        print(ERR_STR "Unable to receive from socket: %s" CLR_STR, strerror(errno));
+        error("Unable to receive from socket");
         return -1;
     } else if (ret != remaining) {
-        print(ERR_STR "Unable to receive correct number of bytes from socket" CLR_STR);
+        error("Unable to receive correct number of bytes from socket");
         return -2;
     }
 
@@ -134,10 +135,10 @@ int ws_send_frame_header(sock *s, ws_frame *frame) {
 
     long ret = sock_send(s, buf, ptr - buf, frame->len != 0 ? MSG_MORE : 0);
     if (ret < 0) {
-        print(ERR_STR "Unable to send to socket: %s" CLR_STR, strerror(errno));
+        error("Unable to send to socket");
         return -1;
     } else if (ret != ptr - buf) {
-        print(ERR_STR "Unable to send to socket" CLR_STR);
+        error("Unable to send to socket");
         return -2;
     }
 
@@ -161,13 +162,13 @@ int ws_handle_connection(sock *s1, sock *s2) {
         if (terminate) {
             break;
         } else if (ret < 0) {
-            print(ERR_STR "Unable to poll sockets: %s" CLR_STR, strerror(errno));
+            error("Unable to poll sockets");
             return -1;
         } else if (n_readable == 0) {
-            print(ERR_STR "Connection timed out" CLR_STR);
+            error("Connection timed out");
             return -2;
         } else if (n_error > 0) {
-            print(ERR_STR "Peer closed connection" CLR_STR);
+            error("Peer closed connection");
             return -3;
         }
 
@@ -176,7 +177,7 @@ int ws_handle_connection(sock *s1, sock *s2) {
             sock *o = (s == s1) ? s2 : s1;
             if (ws_recv_frame_header(s, &frame) != 0) return -3;
 
-            // print("WebSocket: Peer %s, Opcode=0x%X, Len=%li", (s == s1) ? "1" : "2", frame.opcode, frame.len);
+            // debug("WebSocket: Peer %s, Opcode=0x%X, Len=%li", (s == s1) ? "1" : "2", frame.opcode, frame.len);
 
             if (frame.opcode == 0x8) {
                 n_sock--;
@@ -193,10 +194,10 @@ int ws_handle_connection(sock *s1, sock *s2) {
             if (frame.len > 0) {
                 ret = sock_splice(o, s, buf, sizeof(buf), frame.len);
                 if (ret < 0) {
-                    print(ERR_STR "Unable to forward data in WebSocket: %s" CLR_STR, strerror(errno));
+                    error("Unable to forward data in WebSocket");
                     return -4;
                 } else if (ret != frame.len) {
-                    print(ERR_STR "Unable to forward correct number of bytes in WebSocket" CLR_STR);
+                    error("Unable to forward correct number of bytes in WebSocket");
                     return -4;
                 }
             }

src/logger.c

@@ -0,0 +1,281 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Logger
+ * @file src/logger.h
+ * @author Lorenz Stechauner
+ * @date 2022-12-10
+ */
+
+#include "logger.h"
+#include "lib/utils.h"
+
+#include <stdio.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <errno.h>
+#include <string.h>
+#include <stdarg.h>
+#include <signal.h>
+#include <malloc.h>
+
+#define LOG_MAX_MSG_SIZE 2048
+#define LOG_BUF_SIZE 16
+#define LOG_NAME_LEN 12
+#define LOG_PREFIX_LEN 256
+
+#define LOG_PREFIX "[%-8s][%-6s]"
+
+typedef struct {
+    log_lvl_t lvl;
+    char name[LOG_NAME_LEN];
+    char prefix[LOG_PREFIX_LEN];
+    char txt[LOG_MAX_MSG_SIZE];
+} log_msg_t;
+
+typedef struct {
+    int rd;
+    int wr;
+    log_msg_t msgs[LOG_BUF_SIZE];
+} buf_t;
+
+static pthread_t thread;
+static volatile sig_atomic_t alive = 0;
+static sem_t sem_buf, sem_buf_free, sem_buf_used;
+static buf_t buffer;
+
+static pthread_key_t key_name = -1, key_prefix = -1;
+static char global_name[LOG_NAME_LEN] = "", global_prefix[LOG_PREFIX_LEN] = "";
+
+static const char *level_keywords[] = {
+        "EMERG",
+        "ALERT",
+        "CRIT",
+        "ERROR",
+        "WARN",
+        "NOTICE",
+        "INFO",
+        "DEBUG"
+};
+
+static void err(const char *restrict msg) {
+    char err_buf[64];
+    strerror_r(errno, err_buf, sizeof(err_buf));
+    fprintf(stderr, ERR_STR LOG_PREFIX " %s: %s" CLR_STR "\n", "logger", level_keywords[LOG_CRITICAL], msg, err_buf);
+}
+
+void logmsgf(log_lvl_t level, const char *restrict format, ...) {
+    char buf[256];
+    char err_buf[64];
+    va_list args;
+    va_start(args, format);
+
+    const char *color = (level <= LOG_ERROR) ? ERR_STR : ((level <= LOG_WARNING) ? WRN_STR : "");
+    if (errno != 0) {
+        strerror_r(errno, err_buf, sizeof(err_buf));
+        snprintf(buf, sizeof(buf), "%s%s: %s" CLR_STR, color, format, err_buf);
+    } else {
+        snprintf(buf, sizeof(buf), "%s%s" CLR_STR, color, format);
+    }
+
+    void *name = pthread_getspecific(key_name);
+    if (name == NULL && global_name[0] != 0) name = global_name;
+    void *prefix = pthread_getspecific(key_prefix);
+    if (prefix == NULL && global_prefix[0] != 0) prefix = global_prefix;
+
+    if (!alive) {
+        // no logger thread running
+        // simply write to stdout without synchronization
+        printf("%s" LOG_PREFIX "%s%s ", color, (name != NULL) ? (char *) name : "", level_keywords[level], CLR_STR, (prefix != NULL) ? (char *) prefix : "");
+        vprintf(buf, args);
+        printf("\n");
+    } else {
+        // wait for free slot in buffer
+        try_again_free:
+        if (sem_wait(&sem_buf_free) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                goto try_again_free;
+            } else {
+                err("Unable to lock semaphore");
+                errno = 0;
+            }
+            // cleanup
+            va_end(args);
+            return;
+        }
+
+        // try to lock buffer
+        try_again_buf:
+        if (sem_wait(&sem_buf) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                goto try_again_buf;
+            } else {
+                err("Unable to lock semaphore");
+                errno = 0;
+            }
+            // cleanup
+            sem_post(&sem_buf_free);
+            va_end(args);
+            return;
+        }
+
+        // write message to buffer
+        log_msg_t *msg = &buffer.msgs[buffer.rd];
+        buffer.rd = (buffer.rd + 1) % LOG_BUF_SIZE;
+
+        vsnprintf(msg->txt, sizeof(msg->txt), buf, args);
+        msg->lvl = level;
+
+        if (name != NULL) {
+            snprintf(msg->name, sizeof(msg->name), "%s", (char *) name);
+        } else {
+            msg->name[0] = 0;
+        }
+
+        if (prefix != NULL) {
+            snprintf(msg->prefix, sizeof(msg->prefix), "%s", (char *) prefix);
+        } else {
+            msg->prefix[0] = 0;
+        }
+
+        // unlock buffer
+        sem_post(&sem_buf);
+
+        // unlock slot in buffer for logger
+        sem_post(&sem_buf_used);
+    }
+
+    // cleanup
+    va_end(args);
+}
+
+static void logger_destroy(void) {
+    sem_destroy(&sem_buf);
+    sem_destroy(&sem_buf_free);
+    sem_destroy(&sem_buf_used);
+}
+
+static int logger_remaining(void) {
+    int val = 0;
+    sem_getvalue(&sem_buf_used, &val);
+    return val;
+}
+
+void logger_set_name(const char *restrict format, ...) {
+    va_list args;
+
+    if (key_name == -1) {
+        // not initialized
+        va_start(args, format);
+        vsnprintf(global_name, sizeof(global_name), format, args);
+    } else {
+        int ret;
+        void *ptr = pthread_getspecific(key_name);
+        if (!ptr) {
+            ptr = malloc(LOG_NAME_LEN);
+            if ((ret = pthread_setspecific(key_name, ptr)) != 0) {
+                errno = ret;
+                err("Unable to set thread specific values");
+                return;
+            }
+        }
+
+        va_start(args, format);
+        vsnprintf(ptr, LOG_NAME_LEN, format, args);
+    }
+
+    // cleanup
+    va_end(args);
+}
+
+void logger_set_prefix(const char *restrict format, ...) {
+    va_list args;
+
+    if (key_prefix == -1) {
+        // not initialized
+        va_start(args, format);
+        vsnprintf(global_prefix, sizeof(global_prefix), format, args);
+    } else {
+        int ret;
+        void *ptr = pthread_getspecific(key_prefix);
+        if (!ptr) {
+            ptr = malloc(LOG_PREFIX_LEN);
+            if ((ret = pthread_setspecific(key_prefix, ptr)) != 0) {
+                errno = ret;
+                err("Unable to set thread specific values");
+                return;
+            }
+        }
+        va_start(args, format);
+        vsnprintf(ptr, LOG_PREFIX_LEN, format, args);
+    }
+
+    // cleanup
+    va_end(args);
+}
+
+static void *logger_thread(void *arg) {
+    logger_set_name("logger");
+    alive = 1;
+
+    while (alive || logger_remaining() > 0) {
+        // wait for buffer to be filled
+        if (sem_wait(&sem_buf_used) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                continue;
+            } else {
+                err("Unable to lock semaphore");
+                errno = 0;
+                break;
+            }
+        }
+
+        log_msg_t *msg = &buffer.msgs[buffer.wr];
+        buffer.wr = (buffer.wr + 1) % LOG_BUF_SIZE;
+
+        printf("%s" LOG_PREFIX "%s%s %s\n",
+               (msg->lvl <= LOG_ERROR) ? ERR_STR : ((msg->lvl <= LOG_WARNING) ? WRN_STR : ""),
+               (msg->name[0] != 0) ? (char *) msg->name : "", level_keywords[msg->lvl], CLR_STR,
+               (msg->prefix[0] != 0) ? (char *) msg->prefix : "",  msg->txt);
+
+        // unlock slot in buffer
+        sem_post(&sem_buf_free);
+    }
+
+    logger_destroy();
+
+    return NULL;
+}
+
+int logger_init(void) {
+    int ret;
+
+    // try to initialize all three semaphores
+    if (sem_init(&sem_buf, 0, 1) != 0 || sem_init(&sem_buf_free, 0, LOG_BUF_SIZE) != 0 || sem_init(&sem_buf_used, 0, 0) != 0) {
+        err("Unable to initialize semaphore");
+        logger_destroy();
+        return -1;
+    }
+
+    // initialize read/write heads
+    buffer.rd = 0;
+    buffer.wr = 0;
+
+    // initialize thread specific values (keys)
+    if ((ret = pthread_key_create(&key_name, free)) != 0 || (ret = pthread_key_create(&key_prefix, free)) != 0) {
+        errno = ret;
+        err("Unable to initialize thread specific values");
+        logger_destroy();
+        return -1;
+    }
+
+    pthread_create(&thread, NULL, logger_thread, NULL);
+
+    return 0;
+}
+
+void logger_stop(void) {
+    alive = 0;
+}

src/logger.h

@@ -0,0 +1,40 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Logger (header file)
+ * @file src/logger.h
+ * @author Lorenz Stechauner
+ * @date 2022-12-10
+ */
+
+#ifndef SESIMOS_LOGGER_H
+#define SESIMOS_LOGGER_H
+
+#define LOG_DEBUG 7
+#define LOG_INFO 6
+#define LOG_NOTICE 5
+#define LOG_WARNING 4
+#define LOG_ERROR 3
+#define LOG_CRITICAL 2
+#define LOG_ALERT 1
+
+typedef unsigned char log_lvl_t;
+
+#define debug(...) logmsgf(LOG_DEBUG, __VA_ARGS__)
+#define info(...) logmsgf(LOG_INFO, __VA_ARGS__)
+#define notice(...) logmsgf(LOG_NOTICE, __VA_ARGS__)
+#define warning(...) logmsgf(LOG_WARNING, __VA_ARGS__)
+#define error(...) logmsgf(LOG_ERROR, __VA_ARGS__)
+#define critical(...) logmsgf(LOG_CRITICAL, __VA_ARGS__)
+#define alert(...) logmsgf(LOG_ALERT, __VA_ARGS__)
+
+void logmsgf(log_lvl_t level, const char *restrict format, ...);
+
+void logger_set_name(const char *restrict format, ...);
+
+void logger_set_prefix(const char *restrict format, ...);
+
+int logger_init(void);
+
+void logger_stop(void);
+
+#endif //SESIMOS_LOGGER_H

src/server.c

@@ -8,289 +8,218 @@
 
 #include "defs.h"
 #include "server.h"
-#include "client.h"
+#include "logger.h"
+#include "async.h"
 
-#include "lib/cache.h"
+#include "cache_handler.h"
 #include "lib/config.h"
-#include "lib/sock.h"
+#include "lib/proxy.h"
-#include "lib/rev_proxy.h"
 #include "lib/geoip.h"
-#include "lib/utils.h"
+#include "workers.h"
+#include "worker/func.h"
 
 #include <stdio.h>
+#include <getopt.h>
 #include <sys/socket.h>
 #include <signal.h>
 #include <unistd.h>
 #include <poll.h>
 #include <string.h>
-#include <errno.h>
 #include <arpa/inet.h>
-#include <wait.h>
 #include <sys/types.h>
 #include <openssl/err.h>
 #include <openssl/pem.h>
 #include <openssl/ssl.h>
 #include <openssl/conf.h>
-#include <dirent.h>
 
 
-volatile sig_atomic_t active = 1;
+volatile sig_atomic_t server_alive = 1;
 const char *config_file;
-int sockets[NUM_SOCKETS];
-pid_t children[MAX_CHILDREN];
-MMDB_s mmdbs[MAX_MMDB];
-SSL_CTX *contexts[CONFIG_MAX_CERT_CONFIG];
 
-void openssl_init(void) {
+static int sockets[NUM_SOCKETS];
-    SSL_library_init();
+static SSL_CTX *contexts[CONFIG_MAX_CERT_CONFIG];
-    SSL_load_error_strings();
+
-    ERR_load_BIO_strings();
+static client_ctx_t clients[MAX_CLIENTS];  // TODO dynamic
-    OpenSSL_add_all_algorithms();
+
+static const char *color_table[] = {"\x1B[31m", "\x1B[32m", "\x1B[33m", "\x1B[34m", "\x1B[35m", "\x1B[36m"};
+
+static int clean() {
+    remove("/var/sesimos/server/cache");
+    rmdir("/var/sesimos/server/");
+    return 0;
 }
 
 static int ssl_servername_cb(SSL *ssl, int *ad, void *arg) {
     const char *servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
     if (servername != NULL) {
-        const host_config *conf = get_host_config(servername);
+        const host_config_t *conf = get_host_config(servername);
         if (conf != NULL) SSL_set_SSL_CTX(ssl, contexts[conf->cert]);
     }
     return SSL_TLSEXT_ERR_OK;
 }
 
-void destroy(int _) {
+static void accept_cb(void *arg) {
-    fprintf(stderr, "\n" ERR_STR "Terminating forcefully!" CLR_STR "\n");
+    int i = (int) (((int *) arg) - sockets);
-    int status = 0;
+    int fd = sockets[i];
-    int ret;
+
-    int kills = 0;
+    int j;
-    for (int i = 0; i < MAX_CHILDREN; i++) {
+    for (j = 0; j < MAX_CLIENTS; j++) {
-        if (children[i] != 0) {
+        if (clients[j].in_use == 0) break;
-            ret = waitpid(children[i], &status, WNOHANG);
-            if (ret < 0) {
-                fprintf(stderr, ERR_STR "Unable to wait for child process (PID %i): %s" CLR_STR "\n", children[i], strerror(errno));
-            } else if (ret == children[i]) {
-                children[i] = 0;
-                if (status != 0) {
-                    fprintf(stderr, ERR_STR "Child process with PID %i terminated with exit code %i" CLR_STR "\n", ret, status);
-                }
-            } else {
-                kill(children[i], SIGKILL);
-                kills++;
-            }
-        }
     }
-    if (kills > 0) {
+    client_ctx_t *client_ctx = &clients[j];
-        fprintf(stderr, ERR_STR "Killed %i child process(es)" CLR_STR "\n", kills);
+    client_ctx->in_use = 1;
+    sock *client = &client_ctx->socket;
+
+    client->ctx = contexts[0];
+    socklen_t addr_len = sizeof(client->_addr);
+    int client_fd = accept(fd, &client->_addr.sock, &addr_len);
+    if (client_fd < 0) {
+        critical("Unable to accept connection");
+        return;
     }
-    cache_unload();
+
-    config_unload();
+    client->socket = client_fd;
+    client->enc = (i == 1);
+
+    tcp_accept(client_ctx);
+}
+
+static void accept_err_cb(void *arg) {
+    int i = (int) (((int *) arg) - sockets);
+    int fd = sockets[i];
+    // TODO accept error callback
+}
+
+static void terminate_forcefully(int sig) {
+    fprintf(stderr, "\n");
+    notice("Terminating forcefully!");
+
+    geoip_free();
+
+    notice("Goodbye");
     exit(2);
 }
 
-void terminate(int _) {
+static void terminate_gracefully(int sig) {
-    fprintf(stderr, "\nTerminating gracefully...\n");
+    fprintf(stderr, "\n");
-    active = 0;
+    notice("Terminating gracefully...");
 
-    signal(SIGINT, destroy);
+    server_alive = 0;
-    signal(SIGTERM, destroy);
+    signal(SIGINT, terminate_forcefully);
+    signal(SIGTERM, terminate_forcefully);
+
+    workers_stop();
+    workers_destroy();
 
     for (int i = 0; i < NUM_SOCKETS; i++) {
-        shutdown(sockets[i], SHUT_RDWR);
         close(sockets[i]);
     }
 
-    int status = 0;
+    notice("Goodbye");
-    int wait_num = 0;
+    geoip_free();
-    int ret;
-    for (int i = 0; i < MAX_CHILDREN; i++) {
-        if (children[i] != 0) {
-            ret = waitpid(children[i], &status, WNOHANG);
-            if (ret < 0) {
-                fprintf(stderr, ERR_STR "Unable to wait for child process (PID %i): %s" CLR_STR "\n", children[i], strerror(errno));
-            } else if (ret == children[i]) {
-                children[i] = 0;
-                if (status != 0) {
-                    fprintf(stderr, ERR_STR "Child process with PID %i terminated with exit code %i" CLR_STR "\n", ret, status);
-                }
-            } else {
-                kill(children[i], SIGTERM);
-                wait_num++;
-            }
-        }
-    }
-
-    if (wait_num > 0) {
-        fprintf(stderr, "Waiting for %i child process(es)...\n", wait_num);
-    }
-
-    for (int i = 0; i < MAX_CHILDREN; i++) {
-        if (children[i] != 0) {
-            ret = waitpid(children[i], &status, 0);
-            if (ret < 0) {
-                fprintf(stderr, ERR_STR "Unable to wait for child process (PID %i): %s" CLR_STR "\n", children[i], strerror(errno));
-            } else if (ret == children[i]) {
-                children[i] = 0;
-                if (status != 0) {
-                    fprintf(stderr, ERR_STR "Child process with PID %i terminated with exit code %i" CLR_STR "\n", ret, status);
-                }
-            }
-        }
-    }
-
-    if (wait_num > 0) {
-        // Wait another 50 ms to let child processes write to stdout/stderr
-        signal(SIGINT, SIG_IGN);
-        signal(SIGTERM, SIG_IGN);
-        struct timespec ts = {.tv_sec = 0, .tv_nsec = 50000000};
-        nanosleep(&ts, &ts);
-        fprintf(stderr, "\nGoodbye\n");
-    } else {
-        fprintf(stderr, "Goodbye\n");
-    }
-    cache_unload();
-    config_unload();
     exit(0);
 }
 
-int main(int argc, const char *argv[]) {
+static void nothing(int sig) {}
+
+int main(int argc, char *const argv[]) {
     const int YES = 1;
-    struct pollfd poll_fds[NUM_SOCKETS];
-    int ready_sockets_num;
-    long client_num = 0;
-    char buf[1024];
     int ret;
 
-    int client_fd;
-    sock client;
-    struct sockaddr_in6 client_addr;
-    unsigned int client_addr_len = sizeof(client_addr);
-
     memset(sockets, 0, sizeof(sockets));
-    memset(children, 0, sizeof(children));
+    memset(clients, 0, sizeof(clients));
-    memset(mmdbs, 0, sizeof(mmdbs));
 
     const struct sockaddr_in6 addresses[2] = {
             {.sin6_family = AF_INET6, .sin6_addr = IN6ADDR_ANY_INIT, .sin6_port = htons(80)},
             {.sin6_family = AF_INET6, .sin6_addr = IN6ADDR_ANY_INIT, .sin6_port = htons(443)}
     };
 
-    if (setvbuf(stdout, NULL, _IOLBF, 0) != 0) {
+    logger_init();
-        fprintf(stderr, ERR_STR "Unable to set stdout to line-buffered mode: %s" CLR_STR, strerror(errno));
-        return 1;
-    }
-    printf("Sesimos web server " SERVER_VERSION "\n");
 
-    ret = config_init();
+    logger_set_name("server");
-    if (ret != 0) {
+
+    if (setvbuf(stdout, NULL, _IOLBF, 0) != 0 || setvbuf(stderr, NULL, _IOLBF, 0) != 0) {
+        critical("Unable to set stdout/stderr to line-buffered mode");
         return 1;
     }
+    printf("sesimos web server " SERVER_VERSION "\n");
+
+    static const struct option long_opts[] = {
+            {"help",    no_argument,        0, 'h'},
+            {"config",  required_argument,  0, 'c'},
+            { 0,        0,                  0,  0 }
+    };
 
     config_file = NULL;
-    for (int i = 1; i < argc; i++) {
+    int c, opt_idx;
-        const char *arg = argv[i];
+    while ((c = getopt_long(argc, argv, "hc:", long_opts, &opt_idx)) != -1) {
-        if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
+        switch (c) {
-            printf("Usage: sesimos [-h] [-c <CONFIG-FILE>]\n"
+            case 'h':
-                   "\n"
+                fprintf(stderr,
-                   "Options:\n"
+                        "Usage: sesimos [-h] [-c <CONFIG FILE>]\n"
-                   "  -c, --config <CONFIG-FILE>  path to the config file. If not provided, default will be used\n"
+                        "\n"
-                   "  -h, --help                  print this dialogue\n");
+                        "Options:\n"
-            config_unload();
+                        "  -c, --config <CONFIG-FILE>  path to the config file. If not provided, default will be used\n"
-            return 0;
+                        "  -h, --help                  print this dialogue\n");
-        } else if (strcmp(arg, "-c") == 0 || strcmp(arg, "--config") == 0) {
+                return 0;
-            if (i == argc - 1) {
+            case 'c':
-                fprintf(stderr, ERR_STR "Unable to parse argument %s, usage: --config <CONFIG-FILE>" CLR_STR "\n", arg);
+                config_file = optarg;
-                config_unload();
+                break;
+            case '?':
+            default:
+                critical("Unable to parse arguments");
                 return 1;
-            }
-            config_file = argv[++i];
-        } else {
-            fprintf(stderr, ERR_STR "Unable to parse argument '%s'" CLR_STR "\n", arg);
-            config_unload();
-            return 1;
         }
     }
 
-    ret = config_load(config_file == NULL ? DEFAULT_CONFIG_FILE : config_file);
+    if (optind != argc) {
-    if (ret != 0) {
+        critical("No positional arguments expected");
-        config_unload();
         return 1;
     }
 
-    sockets[0] = socket(AF_INET6, SOCK_STREAM, 0);
+    if (config_load(config_file == NULL ? DEFAULT_CONFIG_FILE : config_file) != 0)
-    if (sockets[0] < 0) goto socket_err;
+        return 1;
-    sockets[1] = socket(AF_INET6, SOCK_STREAM, 0);
+
-    if (sockets[1] < 0) {
+    if ((sockets[0] = socket(AF_INET6, SOCK_STREAM, 0)) == -1 ||
-        socket_err:
+        (sockets[1] = socket(AF_INET6, SOCK_STREAM, 0)) == -1)
-        fprintf(stderr, ERR_STR "Unable to create socket: %s" CLR_STR "\n", strerror(errno));
+    {
-        config_unload();
+        critical("Unable to create socket");
         return 1;
     }
 
     for (int i = 0; i < NUM_SOCKETS; i++) {
         if (setsockopt(sockets[i], SOL_SOCKET, SO_REUSEADDR, &YES, sizeof(YES)) < 0) {
-            fprintf(stderr, ERR_STR "Unable to set options for socket %i: %s" CLR_STR "\n", i, strerror(errno));
+            critical("Unable to set options for socket %i", i);
-            config_unload();
             return 1;
         }
     }
 
-    if (bind(sockets[0], (struct sockaddr *) &addresses[0], sizeof(addresses[0])) < 0) goto bind_err;
+    if (bind(sockets[0], (struct sockaddr *) &addresses[0], sizeof(addresses[0])) == -1 ||
-    if (bind(sockets[1], (struct sockaddr *) &addresses[1], sizeof(addresses[1])) < 0) {
+        bind(sockets[1], (struct sockaddr *) &addresses[1], sizeof(addresses[1])) == -1)
-        bind_err:
+    {
-        fprintf(stderr, ERR_STR "Unable to bind socket to address: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to bind socket to address");
-        config_unload();
         return 1;
     }
 
-    signal(SIGINT, terminate);
+    signal(SIGINT, terminate_gracefully);
-    signal(SIGTERM, terminate);
+    signal(SIGTERM, terminate_gracefully);
+    signal(SIGUSR1, nothing);
 
-    if (geoip_dir[0] != 0) {
+    if ((ret = geoip_init(config.geoip_dir)) != 0) {
-        DIR *geoip = opendir(geoip_dir);
+        if (ret == -1) {
-        if (geoip == NULL) {
+            critical("Unable to initialize geoip");
-            fprintf(stderr, ERR_STR "Unable to open GeoIP dir: %s" CLR_STR "\n", strerror(errno));
-            config_unload();
-            return 1;
         }
-        struct dirent *dir;
-        int i = 0;
-        while ((dir = readdir(geoip)) != NULL) {
-            if (strcmp(dir->d_name + strlen(dir->d_name) - 5, ".mmdb") != 0) continue;
-            if (i >= MAX_MMDB) {
-                fprintf(stderr, ERR_STR "Too many .mmdb files" CLR_STR "\n");
-                config_unload();
-                return 1;
-            }
-            sprintf(buf, "%s/%s", geoip_dir, dir->d_name);
-            ret = MMDB_open(buf, 0, &mmdbs[i]);
-            if (ret != MMDB_SUCCESS) {
-                fprintf(stderr, ERR_STR "Unable to open .mmdb file: %s" CLR_STR "\n", MMDB_strerror(ret));
-                config_unload();
-                return 1;
-            }
-            i++;
-        }
-        if (i == 0) {
-            fprintf(stderr, ERR_STR "No .mmdb files found in %s" CLR_STR "\n", geoip_dir);
-            config_unload();
-            return 1;
-        }
-        closedir(geoip);
-    }
-
-    ret = cache_init();
-    if (ret < 0) {
-        config_unload();
         return 1;
-    } else if (ret != 0) {
-        children[0] = ret;  // pid
-    } else {
-        return 0;
     }
 
-    openssl_init();
+    if ((ret = cache_init()) != 0) {
+        geoip_free();
+        if (ret == -1) critical("Unable to initialize cache");
+        return 1;
+    }
 
     for (int i = 0; i < CONFIG_MAX_CERT_CONFIG; i++) {
-        const cert_config *conf = &config->certs[i];
+        const cert_config_t *conf = &config.certs[i];
         if (conf->name[0] == 0) break;
 
         contexts[i] = SSL_CTX_new(TLS_server_method());
@@ -304,99 +233,38 @@ int main(int argc, const char *argv[]) {
         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
 
         if (SSL_CTX_use_certificate_chain_file(ctx, conf->full_chain) != 1) {
-            fprintf(stderr, ERR_STR "Unable to load certificate chain file: %s: %s" CLR_STR "\n", ERR_reason_error_string(ERR_get_error()), conf->full_chain);
+            critical("Unable to load certificate chain file: %s: %s", ERR_reason_error_string(ERR_get_error()), conf->full_chain);
-            config_unload();
+            geoip_free();
-            cache_unload();
             return 1;
         }
         if (SSL_CTX_use_PrivateKey_file(ctx, conf->priv_key, SSL_FILETYPE_PEM) != 1) {
-            fprintf(stderr, ERR_STR "Unable to load private key file: %s: %s" CLR_STR "\n", ERR_reason_error_string(ERR_get_error()), conf->priv_key);
+            critical("Unable to load private key file: %s: %s", ERR_reason_error_string(ERR_get_error()), conf->priv_key);
-            config_unload();
+            geoip_free();
-            cache_unload();
             return 1;
         }
     }
 
-    client.ctx = contexts[0];
+    proxy_preload();
-
-
-    rev_proxy_preload();
 
     for (int i = 0; i < NUM_SOCKETS; i++) {
         if (listen(sockets[i], LISTEN_BACKLOG) < 0) {
-            fprintf(stderr, ERR_STR "Unable to listen on socket %i: %s" CLR_STR "\n", i, strerror(errno));
+            critical("Unable to listen on socket %i", i);
-            config_unload();
+            geoip_free();
-            cache_unload();
             return 1;
         }
     }
 
+    workers_init();
+
     for (int i = 0; i < NUM_SOCKETS; i++) {
-        poll_fds[i].fd = sockets[i];
+        async_fd(sockets[i], POLLIN, ASYNC_KEEP, accept_cb, &sockets[i], accept_err_cb, &sockets[i]);
-        poll_fds[i].events = POLLIN;
     }
 
-    fprintf(stderr, "Ready to accept connections\n");
+    notice("Ready to accept connections");
 
-    while (active) {
+    async_thread();
-        ready_sockets_num = poll(poll_fds, NUM_SOCKETS, 1000);
-        if (ready_sockets_num < 0) {
-            fprintf(stderr, ERR_STR "Unable to poll sockets: %s" CLR_STR "\n", strerror(errno));
-            terminate(0);
-            return 1;
-        }
 
-        for (int i = 0; i < NUM_SOCKETS; i++) {
+    // cleanup
-            if (poll_fds[i].revents & POLLIN) {
+    geoip_free();
-                client_fd = accept(sockets[i], (struct sockaddr *) &client_addr, &client_addr_len);
-                if (client_fd < 0) {
-                    fprintf(stderr, ERR_STR "Unable to accept connection: %s" CLR_STR "\n", strerror(errno));
-                    continue;
-                }
-
-                pid_t pid = fork();
-                if (pid == 0) {
-                    // child
-                    signal(SIGINT, SIG_IGN);
-                    signal(SIGTERM, SIG_IGN);
-
-                    client.socket = client_fd;
-                    client.enc = (i == 1);
-                    return client_handler(&client, client_num, &client_addr);
-                } else if (pid > 0) {
-                    // parent
-                    client_num++;
-                    close(client_fd);
-                    for (int j = 0; j < MAX_CHILDREN; j++) {
-                        if (children[j] == 0) {
-                            children[j] = pid;
-                            break;
-                        }
-                    }
-                } else {
-                    fprintf(stderr, ERR_STR "Unable to create child process: %s" CLR_STR "\n", strerror(errno));
-                }
-            }
-        }
-
-        // TODO outsource in thread
-        int status = 0;
-        for (int i = 0; i < MAX_CHILDREN; i++) {
-            if (children[i] != 0) {
-                ret = waitpid(children[i], &status, WNOHANG);
-                if (ret < 0) {
-                    fprintf(stderr, ERR_STR "Unable to wait for child process (PID %i): %s" CLR_STR "\n", children[i], strerror(errno));
-                } else if (ret == children[i]) {
-                    children[i] = 0;
-                    if (status != 0) {
-                        fprintf(stderr, ERR_STR "Child process with PID %i terminated with exit code %i" CLR_STR "\n", ret, status);
-                    }
-                }
-            }
-        }
-    }
-
-    config_unload();
-    cache_unload();
     return 0;
 }

src/server.h

@@ -9,27 +9,19 @@
 #ifndef SESIMOS_SERVER_H
 #define SESIMOS_SERVER_H
 
-#include <sys/time.h>
-#include <maxminddb.h>
 #include <signal.h>
 
 #define NUM_SOCKETS 2
-#define MAX_CHILDREN 1024
-#define MAX_MMDB 3
 #define LISTEN_BACKLOG 16
 #define REQ_PER_CONNECTION 200
 #define CLIENT_TIMEOUT 3600
 #define SERVER_TIMEOUT_INIT 4
 #define SERVER_TIMEOUT 3600
+#define MAX_CLIENTS 4096
 
+#define CNX_HANDLER_WORKERS 8
+#define REQ_HANDLER_WORKERS 16
 
-extern int sockets[NUM_SOCKETS];
+extern volatile sig_atomic_t server_alive;
-extern pid_t children[MAX_CHILDREN];
-extern MMDB_s mmdbs[MAX_MMDB];
-
-extern volatile sig_atomic_t server_keep_alive;
-extern char *log_client_prefix, *log_conn_prefix, *log_req_prefix, *client_geoip;
-extern char *client_addr_str, *client_addr_str_ptr, *server_addr_str, *server_addr_str_ptr, *client_host_str;
-extern struct timeval client_timeout;
 
 #endif //SESIMOS_SERVER_H

src/worker/fastcgi_handler.c

@@ -0,0 +1,175 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief FastCGI handler
+ * @file src/worker/fastcgi_handler.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-28
+ */
+
+#include "func.h"
+#include "../logger.h"
+#include "../lib/utils.h"
+#include "../lib/compress.h"
+#include "../workers.h"
+#include "../lib/fastcgi.h"
+
+#include <string.h>
+#include <errno.h>
+
+static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx);
+static int fastcgi_handler_2(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx);
+
+void fastcgi_handler_func(client_ctx_t *ctx) {
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+
+    fastcgi_cnx_t fcgi_cnx;
+    int ret = fastcgi_handler_1(ctx, &fcgi_cnx);
+    respond(ctx);
+    if (ret == 0) fastcgi_handler_2(ctx, &fcgi_cnx);
+    request_complete(ctx);
+
+    handle_request(ctx);
+}
+
+static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
+    http_res *res = &ctx->res;
+    http_req *req = &ctx->req;
+    http_uri *uri = &ctx->uri;
+    sock *client = &ctx->socket;
+    char *err_msg = ctx->err_msg;
+
+    fcgi_cnx->socket = 0;
+    fcgi_cnx->req_id = 0;
+    fcgi_cnx->r_addr = ctx->socket.addr;
+    fcgi_cnx->r_host = (ctx->host[0] != 0) ? ctx->host : NULL;
+
+    char buf[1024];
+
+    int mode, ret;
+    if (strcmp(uri->filename + strlen(uri->filename) - 4, ".ncr") == 0) {
+        mode = FASTCGI_SESIMOS;
+    } else if (strcmp(uri->filename + strlen(uri->filename) - 4, ".php") == 0) {
+        mode = FASTCGI_PHP;
+    } else {
+        res->status = http_get_status(500);
+        error("Invalid FastCGI extension: %s", uri->filename);
+        return 0;
+    }
+
+    struct stat statbuf;
+    stat(uri->filename, &statbuf);
+    char *last_modified = http_format_date(statbuf.st_mtime, buf, sizeof(buf));
+    http_add_header_field(&res->hdr, "Last-Modified", last_modified);
+
+    res->status = http_get_status(200);
+    if (fastcgi_init(fcgi_cnx, mode, 0 /* TODO */, ctx->req_num, client, req, uri) != 0) {
+        res->status = http_get_status(503);
+        sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+        return 2;
+    }
+
+    const char *client_content_length = http_get_header_field(&req->hdr, "Content-Length");
+    const char *client_transfer_encoding = http_get_header_field(&req->hdr, "Transfer-Encoding");
+    if (client_content_length != NULL) {
+        unsigned long client_content_len = strtoul(client_content_length, NULL, 10);
+        ret = fastcgi_receive(fcgi_cnx, client, client_content_len);
+    } else if (client_transfer_encoding != NULL && strstr(client_transfer_encoding, "chunked") != NULL) {
+        ret = fastcgi_receive_chunked(fcgi_cnx, client);
+    } else {
+        ret = 0;
+    }
+    if (ret != 0) {
+        if (ret < 0) {
+            return -1;
+        } else {
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+        }
+        res->status = http_get_status(502);
+        return 2;
+    }
+    fastcgi_close_stdin(fcgi_cnx);
+
+    ret = fastcgi_header(fcgi_cnx, res, err_msg);
+    if (ret != 0) {
+        return (ret < 0) ? -1 : 1;
+    }
+
+    const char *status_hdr = http_get_header_field(&res->hdr, "Status");
+    if (status_hdr != NULL) {
+        int status_code = (int) strtoul(status_hdr, NULL, 10);
+        res->status = http_get_status(status_code);
+        http_remove_header_field(&res->hdr, "Status", HTTP_REMOVE_ALL);
+        if (res->status == NULL && status_code >= 100 && status_code <= 999) {
+            ctx->custom_status.code = status_code;
+            strcpy(ctx->custom_status.type, "");
+            strcpy(ctx->custom_status.msg, status_hdr + 4);
+            res->status = &ctx->custom_status;
+        } else if (res->status == NULL) {
+            res->status = http_get_status(500);
+            sprintf(err_msg, "The status_hdr code was set to an invalid or unknown value.");
+            return 2;
+        }
+    }
+
+    const char *content_length_f = http_get_header_field(&res->hdr, "Content-Length");
+    ctx->content_length = (content_length_f == NULL) ? -1 : strtol(content_length_f, NULL, 10);
+
+    const char *content_type = http_get_header_field(&res->hdr, "Content-Type");
+    const char *content_encoding = http_get_header_field(&res->hdr, "Content-Encoding");
+    if (content_encoding == NULL &&
+        content_type != NULL &&
+        strncmp(content_type, "text/html", 9) == 0 &&
+        ctx->content_length != -1 &&
+        ctx->content_length <= sizeof(ctx->msg_content) - 1)
+    {
+        fastcgi_dump(fcgi_cnx, ctx->msg_content, sizeof(ctx->msg_content));
+        return 1;
+    }
+
+    ctx->use_fastcgi = 1;
+
+    if (ctx->content_length != -1 && ctx->content_length < 1024000) {
+        ctx->use_fastcgi |= FASTCGI_COMPRESS_HOLD;
+    }
+
+    ctx->content_length = -1;
+
+    int http_comp = http_get_compression(req, res);
+    if (http_comp & COMPRESS) {
+        if (http_comp & COMPRESS_BR) {
+            ctx->use_fastcgi |= FASTCGI_COMPRESS_BR;
+            sprintf(buf, "br");
+        } else if (http_comp & COMPRESS_GZ) {
+            ctx->use_fastcgi |= FASTCGI_COMPRESS_GZ;
+            sprintf(buf, "gzip");
+        }
+        http_add_header_field(&res->hdr, "Vary", "Accept-Encoding");
+        http_add_header_field(&res->hdr, "Content-Encoding", buf);
+        http_remove_header_field(&res->hdr, "Content-Length", HTTP_REMOVE_ALL);
+    }
+
+    if (http_get_header_field(&res->hdr, "Content-Length") == NULL) {
+        http_add_header_field(&res->hdr, "Transfer-Encoding", "chunked");
+    }
+
+    return 0;
+}
+
+static int fastcgi_handler_2(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
+    const char *transfer_encoding = http_get_header_field(&ctx->res.hdr, "Transfer-Encoding");
+    int chunked = (transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL);
+
+    int flags = (chunked ? FASTCGI_CHUNKED : 0) | (ctx->use_fastcgi & (FASTCGI_COMPRESS | FASTCGI_COMPRESS_HOLD));
+    int ret = fastcgi_send(fcgi_cnx, &ctx->socket, flags);
+    if (ret < 0) {
+        ctx->c_keep_alive = 0;
+        errno = 0;
+    }
+
+    if (fcgi_cnx->socket != 0) {
+        close(fcgi_cnx->socket);
+        fcgi_cnx->socket = 0;
+    }
+
+    return ret;
+}

src/worker/func.h

@@ -0,0 +1,63 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Worker function header file
+ * @file src/worker/func.h
+ * @author Lorenz Stechauner
+ * @date 2022-12-29
+ */
+
+#ifndef SESIMOS_FUNC_H
+#define SESIMOS_FUNC_H
+
+#include "../lib/sock.h"
+#include "../lib/http.h"
+#include "../lib/uri.h"
+#include "../lib/config.h"
+#include "../lib/proxy.h"
+
+typedef struct {
+    sock socket;
+    int req_num;
+    unsigned char in_use: 1, s_keep_alive:1, c_keep_alive:1;
+    char cc[3], host[256];
+    char req_host[256], err_msg[256];
+    char log_prefix[128];
+    char _c_addr[INET6_ADDRSTRLEN + 1], _s_addr[INET6_ADDRSTRLEN + 1];
+    long cnx_s, cnx_e, req_s, res_ts, req_e;
+    http_req req;
+    http_res res;
+    http_uri uri;
+    http_status_ctx status;
+    http_status custom_status;
+    int use_fastcgi, use_proxy;
+    host_config_t *conf;
+    FILE *file;
+    long content_length;
+    char *msg_buf, *msg_buf_ptr, msg_content[1024];
+    proxy_ctx_t *proxy;
+} client_ctx_t;
+
+typedef struct {
+    client_ctx_t *client;
+    sock *s1, *s2, *s, *r;
+} ws_ctx_t;
+
+void tcp_acceptor_func(client_ctx_t *ctx);
+
+void request_handler_func(client_ctx_t *ctx);
+
+void local_handler_func(client_ctx_t *ctx);
+
+void fastcgi_handler_func(client_ctx_t *ctx);
+
+void proxy_handler_func(client_ctx_t *ctx);
+
+void ws_frame_handler_func(ws_ctx_t *ctx);
+
+int respond(client_ctx_t *ctx);
+
+void request_complete(client_ctx_t *ctx);
+
+void tcp_close(client_ctx_t *ctx);
+
+#endif //SESIMOS_FUNC_H

src/worker/local_handler.c

@@ -0,0 +1,216 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Local filesystem handler
+ * @file src/worker/local_handler.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-29
+ */
+
+#include "func.h"
+#include "../logger.h"
+#include "../lib/utils.h"
+#include "../lib/compress.h"
+#include "../workers.h"
+
+#include <string.h>
+#include <errno.h>
+
+static int local_handler(client_ctx_t *ctx);
+
+void local_handler_func(client_ctx_t *ctx) {
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+
+    switch (local_handler(ctx)) {
+        case 0:
+            respond(ctx);
+            request_complete(ctx);
+            handle_request(ctx);
+            break;
+        case 1:
+            fastcgi_handle(ctx);
+            break;
+        default:
+            tcp_close(ctx);
+            break;
+    }
+}
+
+static int local_handler(client_ctx_t *ctx) {
+    http_res *res = &ctx->res;
+    http_req *req = &ctx->req;
+    http_uri *uri = &ctx->uri;
+    char *err_msg = ctx->err_msg;
+
+    char buf1[1024], buf2[1024];
+    int accept_if_modified_since = 0;
+
+    if (strcmp(req->method, "TRACE") == 0) {
+        res->status = http_get_status(200);
+        http_add_header_field(&res->hdr, "Content-Type", "message/http");
+
+        ctx->msg_buf_ptr = malloc(4096);
+        ctx->msg_buf = ctx->msg_buf_ptr;
+        ctx->content_length = snprintf(ctx->msg_buf, 4096 - ctx->content_length, "%s %s HTTP/%s\r\n", req->method, req->uri, req->version);
+        for (int i = 0; i < req->hdr.field_num; i++) {
+            const http_field *f = &req->hdr.fields[i];
+            ctx->content_length += snprintf(ctx->msg_buf + ctx->content_length, 4096 - ctx->content_length, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
+        }
+
+        return 0;
+    }
+
+    if (strncmp(uri->req_path, "/.well-known/", 13) == 0) {
+        http_add_header_field(&res->hdr, "Access-Control-Allow-Origin", "*");
+    }
+
+    if (strncmp(uri->req_path, "/.well-known/", 13) != 0 && strstr(uri->path, "/.") != NULL) {
+        res->status = http_get_status(403);
+        sprintf(err_msg, "Parts of this URI are hidden.");
+        return 0;
+    } else if (uri->filename == NULL && (int) uri->is_static && (int) uri->is_dir && strlen(uri->pathinfo) == 0) {
+        res->status = http_get_status(403);
+        sprintf(err_msg, "It is not allowed to list the contents of this directory.");
+        return 0;
+    } else if (uri->filename == NULL && (int) !uri->is_static && (int) uri->is_dir && strlen(uri->pathinfo) == 0) {
+        // TODO list directory contents
+        res->status = http_get_status(501);
+        sprintf(err_msg, "Listing contents of an directory is currently not implemented.");
+        return 0;
+    } else if (uri->filename == NULL || (strlen(uri->pathinfo) > 0 && (int) uri->is_static)) {
+        res->status = http_get_status(404);
+        return 0;
+    } else if (strlen(uri->pathinfo) != 0 && ctx->conf->local.dir_mode != URI_DIR_MODE_INFO) {
+        res->status = http_get_status(404);
+        return 0;
+    }
+
+    if (uri->is_static) {
+        res->status = http_get_status(200);
+        http_add_header_field(&res->hdr, "Accept-Ranges", "bytes");
+        if (strcmp(req->method, "GET") != 0 && strcmp(req->method, "HEAD") != 0) {
+            res->status = http_get_status(405);
+            return 0;
+        }
+
+        if (http_get_header_field(&req->hdr, "Content-Length") != NULL || http_get_header_field(&req->hdr, "Transfer-Encoding") != NULL) {
+            res->status = http_get_status(400);
+            sprintf(err_msg, "A GET request must not contain a payload");
+            return 0;
+        }
+
+        cache_init_uri(ctx->conf->cache, uri);
+
+        const char *last_modified = http_format_date(uri->meta->stat.st_mtime, buf1, sizeof(buf1));
+        http_add_header_field(&res->hdr, "Last-Modified", last_modified);
+        sprintf(buf2, "%s; charset=%s", uri->meta->type, uri->meta->charset);
+        http_add_header_field(&res->hdr, "Content-Type", buf2);
+
+
+        const char *accept_encoding = http_get_header_field(&req->hdr, "Accept-Encoding");
+        int enc = 0;
+        if (accept_encoding != NULL) {
+            if (uri->meta->filename_comp_br[0] != 0 && strstr(accept_encoding, "br") != NULL) {
+                ctx->file = fopen(uri->meta->filename_comp_br, "rb");
+                if (ctx->file == NULL) {
+                    cache_mark_dirty(ctx->conf->cache, uri->filename);
+                    errno = 0;
+                } else {
+                    http_add_header_field(&res->hdr, "Content-Encoding", "br");
+                    enc = COMPRESS_BR;
+                }
+            } else if (uri->meta->filename_comp_gz[0] != 0 && strstr(accept_encoding, "gzip") != NULL) {
+                ctx->file = fopen(uri->meta->filename_comp_gz, "rb");
+                if (ctx->file == NULL) {
+                    cache_mark_dirty(ctx->conf->cache, uri->filename);
+                    errno = 0;
+                } else {
+                    http_add_header_field(&res->hdr, "Content-Encoding", "gzip");
+                    enc = COMPRESS_GZ;
+                }
+            }
+            if (enc != 0) {
+                http_add_header_field(&res->hdr, "Vary", "Accept-Encoding");
+            }
+        }
+
+        if (uri->meta->etag[0] != 0) {
+            if (enc) {
+                sprintf(buf1, "%s-%s", uri->meta->etag, (enc & COMPRESS_BR) ? "br" : (enc & COMPRESS_GZ) ? "gzip" : "");
+                http_add_header_field(&res->hdr, "ETag", buf1);
+            } else {
+                http_add_header_field(&res->hdr, "ETag", uri->meta->etag);
+            }
+        }
+
+        if (strncmp(uri->meta->type, "text/", 5) == 0) {
+            http_add_header_field(&res->hdr, "Cache-Control", "public, max-age=3600");
+        } else {
+            http_add_header_field(&res->hdr, "Cache-Control", "public, max-age=86400");
+        }
+
+        const char *if_modified_since = http_get_header_field(&req->hdr, "If-Modified-Since");
+        const char *if_none_match = http_get_header_field(&req->hdr, "If-None-Match");
+        if ((if_none_match != NULL && strstr(if_none_match, uri->meta->etag) == NULL) ||
+            (accept_if_modified_since && if_modified_since != NULL && strcmp(if_modified_since, last_modified) == 0))
+        {
+            res->status = http_get_status(304);
+            return 0;
+        }
+
+        const char *range = http_get_header_field(&req->hdr, "Range");
+        if (range != NULL) {
+            if (strlen(range) <= 6 || strncmp(range, "bytes=", 6) != 0) {
+                res->status = http_get_status(416);
+                http_remove_header_field(&res->hdr, "Content-Type", HTTP_REMOVE_ALL);
+                http_remove_header_field(&res->hdr, "Last-Modified", HTTP_REMOVE_ALL);
+                http_remove_header_field(&res->hdr, "ETag", HTTP_REMOVE_ALL);
+                http_remove_header_field(&res->hdr, "Cache-Control", HTTP_REMOVE_ALL);
+                return 0;
+            }
+            range += 6;
+            char *ptr = strchr(range, '-');
+            if (ptr == NULL) {
+                res->status = http_get_status(416);
+                return 0;
+            }
+            ctx->file = fopen(uri->filename, "rb");
+            fseek(ctx->file, 0, SEEK_END);
+            unsigned long file_len = ftell(ctx->file);
+            fseek(ctx->file, 0, SEEK_SET);
+            if (file_len == 0) {
+                ctx->content_length = 0;
+                return 0;
+            }
+            long num1 = 0;
+            long num2 = (long) file_len - 1;
+
+            if (ptr != range) num1 = (long) strtoul(range, NULL, 10);
+            if (ptr[1] != 0) num2 = (long) strtoul(ptr + 1, NULL, 10);
+
+            if (num1 >= file_len || num2 >= file_len || num1 > num2) {
+                res->status = http_get_status(416);
+                return 0;
+            }
+            sprintf(buf1, "bytes %li-%li/%li", num1, num2, file_len);
+            http_add_header_field(&res->hdr, "Content-Range", buf1);
+
+            res->status = http_get_status(206);
+            fseek(ctx->file, num1, SEEK_SET);
+            ctx->content_length = num2 - num1 + 1;
+
+            return 0;
+        }
+
+        if (ctx->file == NULL) {
+            ctx->file = fopen(uri->filename, "rb");
+        }
+
+        fseek(ctx->file, 0, SEEK_END);
+        ctx->content_length = ftell(ctx->file);
+        fseek(ctx->file, 0, SEEK_SET);
+    } else {
+        return 1;
+    }
+
+    return 0;
+}

src/worker/proxy_handler.c

@@ -0,0 +1,128 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Proxy handler
+ * @file src/worker/proxy_handler_1.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-29
+ */
+
+#include "func.h"
+#include "../logger.h"
+#include "../lib/utils.h"
+#include "../lib/proxy.h"
+#include "../lib/websocket.h"
+#include "../workers.h"
+
+#include <string.h>
+
+static int proxy_handler_1(client_ctx_t *ctx);
+static int proxy_handler_2(client_ctx_t *ctx);
+
+void proxy_handler_func(client_ctx_t *ctx) {
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+
+    proxy_handler_1(ctx);
+    respond(ctx);
+    proxy_handler_2(ctx);
+    request_complete(ctx);
+
+    handle_request(ctx);
+}
+
+static int proxy_handler_1(client_ctx_t *ctx) {
+    http_res *res = &ctx->res;
+    http_status_ctx *status = &ctx->status;
+
+    char buf[1024];
+
+    info("Reverse proxy for " BLD_STR "%s:%i" CLR_STR, ctx->conf->proxy.hostname, ctx->conf->proxy.port);
+    http_remove_header_field(&res->hdr, "Date", HTTP_REMOVE_ALL);
+    http_remove_header_field(&res->hdr, "Server", HTTP_REMOVE_ALL);
+
+    ctx->proxy = proxy_init(&ctx->req, res, status, ctx->conf, &ctx->socket, &ctx->custom_status, ctx->err_msg);
+    ctx->use_proxy = (ctx->proxy != NULL);
+
+    if (res->status->code == 101) {
+        const char *connection = http_get_header_field(&res->hdr, "Connection");
+        const char *upgrade = http_get_header_field(&res->hdr, "Upgrade");
+        if (connection != NULL && upgrade != NULL &&
+            (strstr(connection, "upgrade") != NULL || strstr(connection, "Upgrade") != NULL) &&
+             strcmp(upgrade, "websocket") == 0)
+        {
+            const char *ws_accept = http_get_header_field(&res->hdr, "Sec-WebSocket-Accept");
+            if (ws_calc_accept_key(status->ws_key, buf) == 0) {
+                ctx->use_proxy = (strcmp(buf, ws_accept) == 0) ? 2 : 1;
+            }
+        } else {
+            status->status = 101;
+            status->origin = INTERNAL;
+            res->status = http_get_status(501);
+        }
+    }
+
+    // Let 300 be formatted by origin server
+    if (ctx->use_proxy && res->status->code >= 301 && res->status->code < 600) {
+        const char *content_type = http_get_header_field(&res->hdr, "Content-Type");
+        const char *content_length_f = http_get_header_field(&res->hdr, "Content-Length");
+        const char *content_encoding = http_get_header_field(&res->hdr, "Content-Encoding");
+        if (content_encoding == NULL && content_type != NULL && content_length_f != NULL && strncmp(content_type, "text/html", 9) == 0) {
+            long content_len = strtol(content_length_f, NULL, 10);
+            if (content_len <= sizeof(ctx->msg_content) - 1) {
+                if (status->status != 101) {
+                    status->status = res->status->code;
+                    status->origin = res->status->code >= 400 ? SERVER : NONE;
+                }
+                ctx->use_proxy = 0;
+                proxy_dump(ctx->proxy, ctx->msg_content, content_len);
+            }
+        }
+    }
+
+    /*
+    char *content_encoding = http_get_header_field(&res->hdr, "Content-Encoding");
+    if (use_proxy && content_encoding == NULL) {
+        int http_comp = http_get_compression(&req, &res);
+        if (http_comp & COMPRESS_BR) {
+            use_proxy |= PROXY_COMPRESS_BR;
+        } else if (http_comp & COMPRESS_GZ) {
+            use_proxy |= PROXY_COMPRESS_GZ;
+        }
+    }
+
+    char *transfer_encoding = http_get_header_field(&res->hdr, "Transfer-Encoding");
+    int chunked = transfer_encoding != NULL && strcmp(transfer_encoding, "chunked") == 0;
+    http_remove_header_field(&res->hdr, "Transfer-Encoding", HTTP_REMOVE_ALL);
+    ret = sprintf(buf, "%s%s%s",
+                  (use_proxy & PROXY_COMPRESS_BR) ? "br" :
+                  ((use_proxy & PROXY_COMPRESS_GZ) ? "gzip" : ""),
+                  ((use_proxy & PROXY_COMPRESS) && chunked) ? ", " : "",
+                  chunked ? "chunked" : "");
+    if (ret > 0) {
+        http_add_header_field(&res->hdr, "Transfer-Encoding", buf);
+    }
+    */
+
+    return 0;
+}
+
+static int proxy_handler_2(client_ctx_t *ctx) {
+    const char *transfer_encoding = http_get_header_field(&ctx->res.hdr, "Transfer-Encoding");
+    int chunked = transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL;
+
+    const char *content_len = http_get_header_field(&ctx->res.hdr, "Content-Length");
+    unsigned long len_to_send = 0;
+    if (content_len != NULL) {
+        len_to_send = strtol(content_len, NULL, 10);
+    }
+
+    int flags = (chunked ? PROXY_CHUNKED : 0) | (ctx->use_proxy & PROXY_COMPRESS);
+    int ret = proxy_send(ctx->proxy, &ctx->socket, len_to_send, flags);
+    ctx->proxy->in_use = 0;
+    ctx->proxy = NULL;
+
+    if (ret < 0) {
+        ctx->c_keep_alive = 0;
+    }
+
+    return ret;
+}

src/worker/request_handler.c

@@ -0,0 +1,383 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Client request handler
+ * @file src/worker/request_handler.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-28
+ */
+
+#include "../defs.h"
+#include "func.h"
+#include "../workers.h"
+#include "../lib/mpmc.h"
+#include "../logger.h"
+#include "../lib/utils.h"
+#include "../lib/websocket.h"
+#include "../server.h"
+#include "../lib/res.h"
+
+#include <string.h>
+#include <arpa/inet.h>
+
+static int request_handler(client_ctx_t *ctx);
+
+void request_handler_func(client_ctx_t *ctx) {
+    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+
+    switch (request_handler(ctx)) {
+        case 0:
+            respond(ctx);
+            request_complete(ctx);
+            handle_request(ctx);
+            break;
+        case 1:
+            local_handle(ctx);
+            break;
+        case 2:
+            proxy_handle(ctx);
+            break;
+        default:
+            tcp_close(ctx);
+            break;
+    }
+}
+
+static int request_handler(client_ctx_t *ctx) {
+    sock *client = &ctx->socket;
+    char *err_msg = ctx->err_msg;
+
+    long ret;
+    char buf0[1024], buf1[1024];
+
+    err_msg[0] = 0;
+
+    ctx->file = NULL;
+    ctx->proxy = NULL;
+    ctx->use_fastcgi = 0;
+    ctx->use_proxy = 0;
+    ctx->proxy = NULL;
+    ctx->msg_content[0] = 0;
+    ctx->msg_buf = NULL;
+    ctx->msg_buf_ptr = NULL;
+    ctx->req_host[0] = 0;
+    ctx->err_msg[0] = 0;
+
+    http_res *res = &ctx->res;
+    res->status = http_get_status(501);
+    res->hdr.field_num = 0;
+    res->hdr.last_field_num = -1;
+    sprintf(res->version, "1.1");
+
+    http_status_ctx *status = &ctx->status;
+    status->status = 0;
+    status->origin = NONE;
+    status->ws_key = NULL;
+
+    ctx->req_s = clock_micros();
+
+    http_add_header_field(&res->hdr, "Date", http_get_date(buf0, sizeof(buf0)));
+    http_add_header_field(&res->hdr, "Server", SERVER_STR);
+    /*if (ret <= 0) {
+        if (errno != 0) return 0;
+
+        ctx->c_keep_alive = 0;
+        res->status = http_get_status(408);
+        return 0;
+    }*/
+
+    http_req *req = &ctx->req;
+    ret = http_receive_request(client, req);
+    if (ret != 0) {
+        ctx->c_keep_alive = 0;
+        if (ret < 0) {
+            return -1;
+        } else if (ret == 1) {
+            sprintf(err_msg, "Unable to parse http header: Invalid header format.");
+        } else if (ret == 2) {
+            sprintf(err_msg, "Unable to parse http header: Invalid method.");
+        } else if (ret == 3) {
+            sprintf(err_msg, "Unable to parse http header: Invalid version.");
+        } else if (ret == 4) {
+            sprintf(err_msg, "Unable to parse http header: Header contains illegal characters.");
+        } else if (ret == 5) {
+            sprintf(err_msg, "Unable to parse http header: End of header not found.");
+        }
+        res->status = http_get_status(400);
+        return 0;
+    }
+
+    const char *hdr_connection = http_get_header_field(&req->hdr, "Connection");
+    ctx->c_keep_alive = (hdr_connection != NULL && (strstr(hdr_connection, "keep-alive") != NULL || strstr(hdr_connection, "Keep-Alive") != NULL));
+    const char *host_ptr = http_get_header_field(&req->hdr, "Host");
+    if (host_ptr != NULL && strlen(host_ptr) > 255) {
+        ctx->req_host[0] = 0;
+        res->status = http_get_status(400);
+        sprintf(err_msg, "Host header field is too long.");
+        return 0;
+    } else if (host_ptr == NULL || strchr(host_ptr, '/') != NULL) {
+        if (strchr(ctx->socket.addr, ':') == NULL) {
+            strcpy(ctx->req_host, ctx->socket.addr);
+        } else {
+            sprintf(ctx->req_host, "[%s]", ctx->socket.addr);
+        }
+        res->status = http_get_status(400);
+        sprintf(err_msg, "The client provided no or an invalid Host header field.");
+        return 0;
+    } else {
+        strcpy(ctx->req_host, host_ptr);
+    }
+
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+    info(BLD_STR "%s %s", req->method, req->uri);
+
+    if (strcmp(req->uri, "/.sesimos/style.css") == 0 && (strcmp(req->method, "GET") == 0 || strcmp(req->method, "HEAD") == 0)) {
+        ctx->msg_buf = (char *) http_style_doc;
+        ctx->content_length = http_style_doc_size;
+        res->status= http_get_status(200);
+        http_add_header_field(&res->hdr, "Content-Type", "text/css; charset=UTF-8");
+        http_add_header_field(&res->hdr, "Cache-Control", "public, max-age=3600");
+        return 0;
+    }
+
+    ctx->conf = get_host_config(ctx->req_host);
+    if (ctx->conf == NULL) {
+        info("Unknown host, redirecting to default");
+        res->status = http_get_status(307);
+        sprintf(buf0, "https://%s%s", DEFAULT_HOST, req->uri);
+        http_add_header_field(&res->hdr, "Location", buf0);
+        return 0;
+    }
+
+    http_uri *uri = &ctx->uri;
+    unsigned char dir_mode = (ctx->conf->type == CONFIG_TYPE_LOCAL ? ctx->conf->local.dir_mode : URI_DIR_MODE_NO_VALIDATION);
+    ret = uri_init(uri, ctx->conf->local.webroot, req->uri, dir_mode);
+    if (ret != 0) {
+        if (ret == 1) {
+            sprintf(err_msg, "Invalid URI: has to start with slash.");
+            res->status = http_get_status(400);
+        } else if (ret == 2) {
+            sprintf(err_msg, "Invalid URI: contains relative path change (/../).");
+            res->status = http_get_status(400);
+        } else if (ret == 3) {
+            sprintf(err_msg, "The specified webroot directory does not exist.");
+            res->status = http_get_status(404);
+        } else {
+            res->status = http_get_status(500);
+        }
+        return 0;
+    }
+
+    if (ctx->conf->type == CONFIG_TYPE_LOCAL && strcmp(req->method, "TRACE") == 0) {
+        return 1;
+    } else if (dir_mode != URI_DIR_MODE_NO_VALIDATION) {
+        ssize_t size = sizeof(buf0);
+        url_decode(req->uri, buf0, &size);
+        int change_proto = (!client->enc && strncmp(uri->uri, "/.well-known/", 13) != 0);
+        if (strcmp(uri->uri, buf0) != 0 || change_proto) {
+            res->status = http_get_status(308);
+            size = url_encode(uri->uri, strlen(uri->uri), buf0, sizeof(buf0));
+            if (change_proto) {
+                int p_len = snprintf(buf1, sizeof(buf1), "https://%s%s", ctx->req_host, buf0);
+                if (p_len < 0 || p_len >= sizeof(buf1)) {
+                    res->status = http_get_status(500);
+                    error("Header field 'Location' too long");
+                    return 0;
+                }
+                http_add_header_field(&res->hdr, "Location", buf1);
+            } else {
+                http_add_header_field(&res->hdr, "Location", buf0);
+            }
+            return 0;
+        }
+    } else if (!client->enc) {
+        res->status = http_get_status(308);
+        sprintf(buf0, "https://%s%s", ctx->req_host, req->uri);
+        http_add_header_field(&res->hdr, "Location", buf0);
+        return 0;
+    }
+
+    if (ctx->conf->type == CONFIG_TYPE_LOCAL) {
+        return 1;
+    } else if (ctx->conf->type == CONFIG_TYPE_REVERSE_PROXY) {
+        return 2;
+    } else {
+        error("Unknown host type: %i", ctx->conf->type);
+        res->status = http_get_status(501);
+    }
+
+    return 0;
+}
+
+int respond(client_ctx_t *ctx) {
+    http_req *req = &ctx->req;
+    http_res *res = &ctx->res;
+    sock *client = &ctx->socket;
+    http_status_ctx *status = &ctx->status;
+    char *err_msg = ctx->err_msg;
+
+    long ret = 0;
+    char buf0[1024];
+    char msg_pre_buf_1[4096], msg_pre_buf_2[4096];
+    char buffer[CHUNK_SIZE];
+
+    if (!ctx->use_proxy) {
+        if (ctx->conf != NULL && ctx->conf->type == CONFIG_TYPE_LOCAL && ctx->uri.is_static && res->status->code == 405) {
+            http_add_header_field(&res->hdr, "Allow", "GET, HEAD, TRACE");
+        }
+        if (http_get_header_field(&res->hdr, "Accept-Ranges") == NULL) {
+            http_add_header_field(&res->hdr, "Accept-Ranges", "none");
+        }
+        if (!ctx->use_fastcgi && ctx->file == NULL && ctx->msg_buf == NULL) {
+            http_remove_header_field(&res->hdr, "Date", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res->hdr, "Server", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res->hdr, "Cache-Control", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res->hdr, "Content-Type", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res->hdr, "Content-Encoding", HTTP_REMOVE_ALL);
+            http_add_header_field(&res->hdr, "Date", http_get_date(buf0, sizeof(buf0)));
+            http_add_header_field(&res->hdr, "Server", SERVER_STR);
+            http_add_header_field(&res->hdr, "Cache-Control", "no-cache");
+            http_add_header_field(&res->hdr, "Content-Type", "text/html; charset=UTF-8");
+
+            // TODO list Locations on 3xx Redirects
+            const http_doc_info *http_info = http_get_status_info(res->status);
+            const http_status_msg *http_msg = http_get_error_msg(res->status);
+
+            if (ctx->msg_content[0] == 0) {
+                if (res->status->code >= 300 && res->status->code < 400) {
+                    const char *location = http_get_header_field(&res->hdr, "Location");
+                    if (location != NULL) {
+                        snprintf(ctx->msg_content, sizeof(ctx->msg_content), "      <ul>\n        <li><a href=\"%s\">%s</a></li>\n      </ul>\n", location, location);
+                    }
+                }
+            } else if (strncmp(ctx->msg_content, "<!DOCTYPE html>", 15) == 0 || strncmp(ctx->msg_content, "<html", 5) == 0) {
+                ctx->msg_content[0] = 0;
+                // TODO let relevant information pass?
+            }
+
+            char *proxy_doc = "";
+            if (ctx->conf != NULL && ctx->conf->type == CONFIG_TYPE_REVERSE_PROXY) {
+                const http_status *status_hdr = http_get_status(status->status);
+                char stat_str[8];
+                sprintf(stat_str, "%03i", status->status);
+                snprintf(msg_pre_buf_2, sizeof(msg_pre_buf_2), http_proxy_doc,
+                        " success",
+                        (status->origin == CLIENT_REQ) ? " error" : " success",
+                        (status->origin == INTERNAL) ?   " error" : " success",
+                        (status->origin == SERVER_REQ) ? " error" : (status->status == 0 ? "" : " success"),
+                        (status->origin == CLIENT_RES) ? " error" : " success",
+                        (status->origin == SERVER) ?     " error" : (status->status == 0 ? "" : " success"),
+                        (status->origin == SERVER_RES) ? " error" : (status->status == 0 ? "" : " success"),
+                        (status->origin == INTERNAL) ?   " error" : " success",
+                        (status->origin == INTERNAL || status->origin == SERVER) ? " error" : " success",
+                        res->status->code,
+                        res->status->msg,
+                        (status->status == 0) ? "???" : stat_str,
+                        (status_hdr != NULL) ? status_hdr->msg : "",
+                        ctx->req_host, SERVER_NAME);
+                proxy_doc = msg_pre_buf_2;
+            }
+
+            ctx->msg_buf_ptr = malloc(4096);
+            ctx->msg_buf = ctx->msg_buf_ptr;
+            snprintf(msg_pre_buf_1, sizeof(msg_pre_buf_1), http_info->doc,
+                     res->status->code, res->status->msg, http_msg != NULL ? http_msg->msg : "", err_msg[0] != 0 ? err_msg : "");
+            ctx->content_length = snprintf(ctx->msg_buf, 4096, http_default_doc, res->status->code,
+                                           res->status->msg, msg_pre_buf_1, http_info->mode, http_info->icon, http_info->color, ctx->req_host,
+                                           proxy_doc, ctx->msg_content[0] != 0 ? ctx->msg_content : "", SERVER_STR_HTML);
+        }
+        if (ctx->content_length >= 0) {
+            sprintf(buf0, "%li", ctx->content_length);
+            http_remove_header_field(&res->hdr, "Content-Length", HTTP_REMOVE_ALL);
+            http_add_header_field(&res->hdr, "Content-Length", buf0);
+        } else if (http_get_header_field(&res->hdr, "Transfer-Encoding") == NULL) {
+            ctx->s_keep_alive = 0;
+        }
+    }
+
+    int close_proxy = 0;
+    if (ctx->use_proxy != 2) {
+        const char *conn = http_get_header_field(&res->hdr, "Connection");
+        close_proxy = (conn == NULL || (strstr(conn, "keep-alive") == NULL && strstr(conn, "Keep-Alive") == NULL));
+        http_remove_header_field(&res->hdr, "Connection", HTTP_REMOVE_ALL);
+        http_remove_header_field(&res->hdr, "Keep-Alive", HTTP_REMOVE_ALL);
+        if (ctx->s_keep_alive && ctx->c_keep_alive) {
+            http_add_header_field(&res->hdr, "Connection", "keep-alive");
+            sprintf(buf0, "timeout=%i, max=%i", CLIENT_TIMEOUT, REQ_PER_CONNECTION);
+            http_add_header_field(&res->hdr, "Keep-Alive", buf0);
+        } else {
+            http_add_header_field(&res->hdr, "Connection", "close");
+        }
+    }
+
+    http_send_response(client, res);
+    ctx->res_ts = clock_micros();
+    const char *location = http_get_header_field(&res->hdr, "Location");
+    info("%s%s%03i %s%s%s (%s)%s", http_get_status_color(res->status), ctx->use_proxy ? "-> " : "", res->status->code,
+         res->status->msg, location != NULL ? " -> " : "", location != NULL ? location : "",
+         format_duration(ctx->res_ts - ctx->req_s, buf0), CLR_STR);
+
+    // TODO access/error log file
+
+    if (ctx->use_proxy == 2) {
+        // WebSocket
+        info("Upgrading connection to WebSocket connection");
+        ret = ws_handle_connection(client, &ctx->proxy->proxy);
+        if (ret != 0) {
+            ctx->c_keep_alive = 0;
+            close_proxy = 1;
+        }
+        info("WebSocket connection closed");
+    } else if (strcmp(req->method, "HEAD") != 0) {
+        // default response
+        unsigned long snd_len = 0;
+        unsigned long len;
+        if (ctx->msg_buf != NULL) {
+            ret = sock_send(client, ctx->msg_buf, ctx->content_length, 0);
+            if (ret <= 0) {
+                error("Unable to send: %s", sock_strerror(client));
+            }
+            snd_len += ret;
+        } else if (ctx->file != NULL) {
+            while (snd_len < ctx->content_length) {
+                len = fread(buffer, 1, CHUNK_SIZE, ctx->file);
+                if (snd_len + len > ctx->content_length) {
+                    len = ctx->content_length - snd_len;
+                }
+                ret = sock_send(client, buffer, len, feof(ctx->file) ? 0 : MSG_MORE);
+                if (ret <= 0) {
+                    error("Unable to send: %s", sock_strerror(client));
+                    break;
+                }
+                snd_len += ret;
+            }
+        } else if (ctx->use_fastcgi) {
+            return 2;
+        } else if (ctx->use_proxy) {
+            return 3;
+        }
+
+        if (ret < 0) {
+            ctx->c_keep_alive = 0;
+        }
+    }
+
+    return 0;
+}
+
+void request_complete(client_ctx_t *ctx) {
+    // FIXME
+    //if (close_proxy && proxy.socket != 0) {
+    //    info(BLUE_STR "Closing proxy connection");
+    //    sock_close(&proxy);
+    //}
+
+    char buf[32];
+    ctx->req_e = clock_micros();
+    info("Transfer complete: %s", format_duration(ctx->req_e - ctx->req_s, buf));
+
+    if (ctx->file) fclose(ctx->file);
+    free(ctx->msg_buf_ptr);
+    uri_free(&ctx->uri);
+    http_free_req(&ctx->req);
+    http_free_res(&ctx->res);
+}

src/worker/tcp_acceptor.c

@@ -0,0 +1,130 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief TCP acceptor
+ * @file src/worker/tcp_acceptor.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-28
+ */
+
+#include "func.h"
+#include "../logger.h"
+#include "../lib/utils.h"
+#include "../lib/geoip.h"
+#include "../workers.h"
+#include "../server.h"
+
+#include <string.h>
+#include <errno.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+static int tcp_acceptor(client_ctx_t *ctx);
+
+void tcp_acceptor_func(client_ctx_t *ctx) {
+    if (tcp_acceptor(ctx) == 0) {
+        handle_request(ctx);
+    } else {
+        tcp_close(ctx);
+    }
+}
+
+static int tcp_acceptor(client_ctx_t *ctx) {
+    struct sockaddr_in6 server_addr;
+
+    inet_ntop(ctx->socket._addr.ipv6.sin6_family, &ctx->socket._addr.ipv6.sin6_addr, ctx->_c_addr, sizeof(ctx->_c_addr));
+    if (strncmp(ctx->_c_addr, "::ffff:", 7) == 0) {
+        ctx->socket.addr = ctx->_c_addr + 7;
+    } else {
+        ctx->socket.addr = ctx->_c_addr;
+    }
+
+    socklen_t len = sizeof(server_addr);
+    getsockname(ctx->socket.socket, (struct sockaddr *) &server_addr, &len);
+    inet_ntop(server_addr.sin6_family, (void *) &server_addr.sin6_addr, ctx->_s_addr, sizeof(ctx->_s_addr));
+    if (strncmp(ctx->_s_addr, "::ffff:", 7) == 0) {
+        ctx->socket.s_addr = ctx->_s_addr + 7;
+    } else {
+        ctx->socket.s_addr = ctx->_s_addr;
+    }
+
+    sprintf(ctx->log_prefix, "[%s%4i%s]%s[%*s][%5i]%s", (int) ctx->socket.enc ? HTTPS_STR : HTTP_STR,
+            ntohs(server_addr.sin6_port), CLR_STR, /*color_table[0]*/ "", INET6_ADDRSTRLEN, ctx->socket.addr,
+            ntohs(ctx->socket._addr.ipv6.sin6_port), CLR_STR);
+
+    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+    
+    int ret;
+    char buf[1024];
+    sock *client = &ctx->socket;
+
+    ctx->cnx_s = clock_micros();
+
+    if (config.dns_server[0] != 0) {
+        sprintf(buf, "dig @%s +short +time=1 -x %s", config.dns_server, ctx->socket.addr);
+        FILE *dig = popen(buf, "r");
+        if (dig == NULL) {
+            error("Unable to start dig: %s", strerror(errno));
+            goto dig_err;
+        }
+        unsigned long read = fread(buf, 1, sizeof(buf), dig);
+        ret = pclose(dig);
+        if (ret != 0) {
+            error("Dig terminated with exit code %i", ret);
+            goto dig_err;
+        }
+        char *ptr = memchr(buf, '\n', read);
+        if (ptr == buf || ptr == NULL) {
+            goto dig_err;
+        }
+        ptr[-1] = 0;
+        strncpy(ctx->host, buf, sizeof(ctx->host));
+    } else {
+        dig_err:
+        ctx->host[0] = 0;
+    }
+
+    ctx->cc[0] = 0;
+    geoip_lookup_country(&client->_addr.sock, ctx->cc);
+
+    info("Connection accepted from %s %s%s%s[%s]", ctx->socket.addr, ctx->host[0] != 0 ? "(" : "",
+         ctx->host[0] != 0 ? ctx->host : "", ctx->host[0] != 0 ? ") " : "",
+         ctx->cc[0] != 0 ? ctx->cc : "N/A");
+
+    if (sock_set_timeout(client, CLIENT_TIMEOUT)) {
+        error("Unable to set timeout for socket");
+        return -1;
+    }
+
+    if (client->enc) {
+        client->ssl = SSL_new(client->ctx);
+        SSL_set_fd(client->ssl, client->socket);
+        SSL_set_accept_state(client->ssl);
+
+        ret = SSL_accept(client->ssl);
+        client->_last_ret = ret;
+        client->_errno = errno;
+        client->_ssl_error = ERR_get_error();
+        if (ret <= 0) {
+            info("Unable to perform handshake: %s", sock_strerror(client));
+            return - 1;
+        }
+    }
+
+    ctx->req_num = 0;
+    ctx->s_keep_alive = 1;
+    ctx->c_keep_alive = 1;
+
+    return 0;
+}
+
+void tcp_close(client_ctx_t *ctx) {
+    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+
+    sock_close(&ctx->socket);
+
+    ctx->cnx_e = clock_micros();
+    char buf[32];
+    info("Connection closed (%s)", format_duration(ctx->cnx_e - ctx->cnx_s, buf));
+
+    memset(ctx, 0, sizeof(*ctx));
+}

src/worker/ws_frame_handler.c

@@ -0,0 +1,19 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief WebSocket frame handler
+ * @file src/worker/ws_frame_handler.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-30
+ */
+
+#include "func.h"
+
+static int ws_frame_handler(ws_ctx_t *ctx);
+
+void ws_frame_handler_func(ws_ctx_t *ctx) {
+
+}
+
+static int ws_frame_handler(ws_ctx_t *ctx) {
+    return 0;
+}

src/workers.c

@@ -0,0 +1,70 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Worker interface
+ * @file src/workers.c
+ * @author Lorenz Stechauner
+ * @date 2022-12-29
+ */
+
+#include "workers.h"
+#include "lib/mpmc.h"
+
+#include "worker/func.h"
+#include "async.h"
+
+static mpmc_t tcp_acceptor_ctx, request_handler_ctx,
+              local_handler_ctx, fastcgi_handler_cxt, proxy_handler_ctx;
+
+int workers_init(void) {
+    mpmc_init(&tcp_acceptor_ctx,     8, 64, (void (*)(void *)) tcp_acceptor_func,    "tcp");
+    mpmc_init(&request_handler_ctx, 16, 64, (void (*)(void *)) request_handler_func, "req");
+    mpmc_init(&local_handler_ctx,   16, 64, (void (*)(void *)) local_handler_func,   "local");
+    mpmc_init(&fastcgi_handler_cxt, 16, 64, (void (*)(void *)) fastcgi_handler_func, "fcgi");
+    mpmc_init(&proxy_handler_ctx,   16, 64, (void (*)(void *)) proxy_handler_func,   "proxy");
+    return -1;
+}
+
+void workers_stop(void) {
+    mpmc_stop(&tcp_acceptor_ctx);
+    mpmc_stop(&local_handler_ctx);
+    mpmc_stop(&fastcgi_handler_cxt);
+    mpmc_stop(&proxy_handler_ctx);
+    mpmc_stop(&request_handler_ctx);
+}
+
+void workers_destroy(void) {
+    mpmc_destroy(&tcp_acceptor_ctx);
+    mpmc_destroy(&local_handler_ctx);
+    mpmc_destroy(&fastcgi_handler_cxt);
+    mpmc_destroy(&proxy_handler_ctx);
+    mpmc_destroy(&request_handler_ctx);
+}
+
+int tcp_accept(client_ctx_t *ctx) {
+    return mpmc_queue(&tcp_acceptor_ctx, ctx);
+}
+
+static int handle_request_cb(client_ctx_t *ctx) {
+    return mpmc_queue(&request_handler_ctx, ctx);
+}
+
+int handle_request(client_ctx_t *ctx) {
+    if (ctx->c_keep_alive && ctx->s_keep_alive) {
+        return async(&ctx->socket, POLLIN, 0, (void (*)(void *)) handle_request_cb, ctx, (void (*)(void *)) tcp_close, ctx);
+    } else {
+        tcp_close(ctx);
+        return 0;
+    }
+}
+
+int local_handle(client_ctx_t *ctx) {
+    return mpmc_queue(&local_handler_ctx, ctx);
+}
+
+int fastcgi_handle(client_ctx_t *ctx) {
+    return mpmc_queue(&fastcgi_handler_cxt, ctx);
+}
+
+int proxy_handle(client_ctx_t *ctx) {
+    return mpmc_queue(&proxy_handler_ctx, ctx);
+}

src/workers.h

@@ -0,0 +1,30 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Worker interface (header file)
+ * @file src/workers.h
+ * @author Lorenz Stechauner
+ * @date 2022-12-29
+ */
+
+#ifndef SESIMOS_WORKERS_H
+#define SESIMOS_WORKERS_H
+
+#include "worker/func.h"
+
+int workers_init(void);
+
+void workers_stop(void);
+
+void workers_destroy(void);
+
+int tcp_accept(client_ctx_t *ctx);
+
+int handle_request(client_ctx_t *ctx);
+
+int local_handle(client_ctx_t *ctx);
+
+int fastcgi_handle(client_ctx_t *ctx);
+
+int proxy_handle(client_ctx_t *ctx);
+
+#endif //SESIMOS_WORKERS_H