Add architecture.md

.gitignore

@@ -1,7 +1,10 @@
 *
 !src
 !src/**
-!run.sh
+!doc
+!doc/**
+!test
+!test/**
 !Makefile
 !.gitignore
-!README.md
+!*.md

Makefile

@@ -1,19 +1,87 @@
-.DEFAULT_GOAL := install
 
-packages:
-	@echo "Installing packages..."
-	sudo apt-get install gcc libmagic-dev libssl-dev php-fpm
-	@echo "Finished downloading!"
+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
 
-compile:
-	@mkdir -p bin
-	gcc src/necronda-server.c -o bin/necronda-server -std=c11 -lssl -lcrypto -lmagic -lz -lmaxminddb -Wall
+DEBIAN_OPTS=-D CACHE_MAGIC_FILE="\"/usr/share/file/magic.mgc\"" -D PHP_FPM_SOCKET="\"/var/run/php/php7.4-fpm.sock\""
 
-compile-debian:
-	@mkdir -p bin
-	gcc src/necronda-server.c -o bin/necronda-server -std=c11 -lssl -lcrypto -lmagic -lz -lmaxminddb -Wall \
-		-D MAGIC_FILE="\"/usr/share/file/magic.mgc\"" \
-		-D PHP_FPM_SOCKET="\"/var/run/php/php7.3-fpm.sock\""
+.PHONY: all prod debug default debian permit clean test
+all: prod
+default: bin bin/lib bin/sesimos
 
-install: | packages compile
-	@echo "Finished!"
+prod: CFLAGS += -O3
+prod: default
+
+debug: CFLAGS += -Wall -pedantic
+debug: default
+
+debian: CFLAGS += $(DEBIAN_OPTS)
+debian: prod
+
+test: CFLAGS += -include test/mock_*.h
+test: bin bin/test
+	bin/test
+
+
+bin:
+	mkdir -p bin
+
+bin/lib:
+	mkdir -p bin/lib
+
+
+bin/test: test/mock_*.c test/test_*.c src/lib/utils.c src/lib/sock.c
+	$(CC) -o $@ $(CFLAGS) $^ -lcriterion
+
+
+bin/%.o: src/%.c
+	$(CC) -c -o $@ $(CFLAGS) $<
+
+bin/lib/%.o: src/lib/%.c
+	$(CC) -c -o $@ $(CFLAGS) $<
+
+bin/sesimos: bin/server.o bin/client.o bin/logger.o \
+			 bin/lib/cache.o bin/lib/compress.o bin/lib/config.o bin/lib/fastcgi.o bin/lib/geoip.o \
+			 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
+	$(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 \
+              src/lib/rev_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 \
+              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 src/logger.h
+
+bin/logger.o: src/logger.h
+
+bin/lib/cache.o: src/lib/cache.h src/lib/utils.h src/lib/uri.h src/lib/compress.h src/logger.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 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/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 src/logger.h
+
+bin/lib/rev_proxy.o: src/lib/rev_proxy.h src/defs.h src/server.h src/lib/compress.h src/logger.h
+
+bin/lib/sock.o: src/lib/sock.h
+
+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 src/logger.h
+
+
+permit:
+	sudo setcap 'cap_net_bind_service=+ep' "$(shell pwd)/bin/sesimos"
+
+clean:
+	rm -rf bin/*

README.md

@@ -1,2 +1,50 @@
 
-# Necronda web server
+Sesimos – Secure, simple, modern web server
+===========================================
+
+## Features
+
+* Full IPv4 and IPv6 support
+* TLS Server Name Inspection (SNI)
+* Serving local files via HTTP and HTTPS
+  * File compression ([gzip](https://www.gzip.org/), [Brotli](https://www.brotli.org/))
+  * Disk cache for compressed files
+* Reverse proxy for other HTTP and HTTPS servers
+  * Transparent WebSocket reverse proxy
+* FastCGI support (e.g. [PHP-FPM](https://php-fpm.org/))
+  * Automatic path info detection (e.g. `/my/file/extra/path` -> script: `/my/file.php`, path info: `extra/path`)
+* Support for [MaxMind's GeoIP Database](https://www.maxmind.com/en/geoip2-services-and-databases)
+* Optional DNS reverse lookup for connecting hosts
+* Automatic URL rewrite (e.g. `/index.html` -> `/`, `/test.php` -> `/test`)
+* Modern looking and responsive error documents
+
+
+## Configuration
+
+See [doc/example.conf](doc/example.conf) for more details.
+
+
+### Global directives
+
+* `geoip_dir` (optional) - path to a directory containing GeoIP databases
+* `dns_server` (optional) - address of a DNS server
+
+
+### Configuration
+
+* `[cert <cert-name>]` - begins section for a certificate
+  * `certificate` - path to SSL certificate (or certificate chain)
+  * `private_key` - path to SSL private key
+* `[host <host>]` - begins section for the virtual host `<host>`
+  * `cert` - the name of the certificate to use
+  * Local
+      * `webroot` - path to the root directory
+      * `dir_mode` - specify the behaviour for directories without an `index.html` or `index.php`
+          * `forbidden` - the server will respond with `403 Forbidden`
+          * `info` - try passing *path info* to an upper `.php` file.
+          * `list` - list contents of directory (**not implemented yet**)
+  * Reverse proxy
+      * `hostname` - hostname of server to be reverse proxy of
+      * `port` - port to be used
+      * `http` - use HTTP to communicate with server
+      * `https` - use HTTPS to communicate with server

architecture.md

@@ -0,0 +1,22 @@
+
+# Architecture
+
+* logger (1)
+* listener (2) - 80, 443
+* cache_handler (1)
+* connection_initializer
+* request_handler
+* local_handler
+* rev_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
+* rev_proxy_handler -> ws_handler -> request_handler

doc/example.conf

@@ -0,0 +1,24 @@
+
+#geoip_dir  /var/dir
+#dns_server 192.168.0.1
+
+[cert cert1]
+certificate /var/cert/cert.pem
+private_key /var/cert/cert.key
+
+[host localhost]
+webroot     /var/www/localhost
+dir_mode    forbidden
+cert        cert1
+
+[host me.local]
+hostname    www.example.com
+port        80
+cert        cert1
+http
+
+[host secure.local]
+hostname    www.example.com
+port        443
+cert        cert1
+https

run.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-echo "-- Building and starting Necronda Server..."
-make compile && \
- echo "-- Successfully finished compiling!" && \
- echo "-- Starting Server..." && \
- ./bin/necronda-server $@

src/cache.c

@@ -1,348 +0,0 @@
-/**
- * Necronda Web Server
- * File cache implementation
- * src/cache.c
- * Lorenz Stechauner, 2020-12-19
- */
-
-#include "cache.h"
-
-
-int magic_init() {
-    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, 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() {
-    cache_continue = 0;
-}
-
-int cache_process() {
-    signal(SIGINT, cache_process_term);
-    signal(SIGTERM, cache_process_term);
-
-    int shm_id = shmget(SHM_KEY_CACHE, FILE_CACHE_SIZE * sizeof(cache_entry), 0);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to create 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 shared memory (rw): %s" CLR_STR "\n", strerror(errno));
-        return -2;
-    }
-    cache = shm_rw;
-
-    if (mkdir("/var/necronda-server/", 0755) < 0) {
-        if (errno != EEXIST) {
-            fprintf(stderr, ERR_STR "Unable to create directory '/var/necronda-server/': %s" CLR_STR "\n", strerror(errno));
-            return -3;
-        }
-    }
-
-    FILE *cache_file = fopen("/var/necronda-server/cache", "rb");
-    if (cache_file != NULL) {
-        fread(cache, sizeof(cache_entry), FILE_CACHE_SIZE, cache_file);
-        fclose(cache_file);
-    }
-
-    for (int i = 0; i < FILE_CACHE_SIZE; i++) {
-        cache[i].is_updating = 0;
-    }
-
-    FILE *file;
-    char buf[16384];
-    char comp_buf[16384];
-    char filename_comp[256];
-    unsigned long read;
-    int compress;
-    SHA_CTX ctx;
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    int cache_changed = 0;
-    int p_len;
-    while (cache_continue) {
-        for (int i = 0; i < FILE_CACHE_SIZE; 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);
-                SHA1_Init(&ctx);
-                file = fopen(cache[i].filename, "rb");
-                compress = strncmp(cache[i].meta.type, "text/", 5) == 0 ||
-                        (strncmp(cache[i].meta.type, "application/", 12) == 0 &&
-                        strstr(cache[i].meta.type, "+xml") != NULL);
-
-                int level = NECRONDA_ZLIB_LEVEL;
-                z_stream strm;
-                FILE *comp_file = NULL;
-                if (compress) {
-                    sprintf(buf, "%.*s/.necronda-server", cache[i].webroot_len, cache[i].filename);
-                    mkdir(buf, 0755);
-                    sprintf(buf, "%.*s/.necronda-server/cache", cache[i].webroot_len, cache[i].filename);
-                    mkdir(buf, 0700);
-                    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 = snprintf(filename_comp, sizeof(filename_comp), "%.*s/.necronda-server/cache/%s.z",
-                                     cache[i].webroot_len, cache[i].filename, buf);
-                    if (p_len < 0 || p_len >= sizeof(filename_comp)) {
-                        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 = fopen(filename_comp, "wb");
-                    if (comp_file == NULL) {
-                        fprintf(stderr, ERR_STR "Unable to open cached file: %s" CLR_STR "\n", strerror(errno));
-                        comp_err:
-                        compress = 0;
-                    } else {
-                        strm.zalloc = Z_NULL;
-                        strm.zfree = Z_NULL;
-                        strm.opaque = Z_NULL;
-                        if (deflateInit(&strm, level) != Z_OK) {
-                            fprintf(stderr, ERR_STR "Unable to init deflate: %s" CLR_STR "\n", strerror(errno));
-                            compress = 0;
-                            fclose(comp_file);
-                        }
-                    }
-                }
-
-                while ((read = fread(buf, 1, sizeof(buf), file)) > 0) {
-                    SHA1_Update(&ctx, buf, read);
-                    if (compress) {
-                        strm.avail_in = read;
-                        strm.next_in = (unsigned char *) buf;
-                        do {
-                            strm.avail_out = sizeof(comp_buf);
-                            strm.next_out = (unsigned char *) comp_buf;
-                            deflate(&strm, feof(file) ? Z_FINISH : Z_NO_FLUSH);
-                            fwrite(comp_buf, 1, sizeof(comp_buf) - strm.avail_out, comp_file);
-                            strm.avail_in = 0;
-                        } while (strm.avail_out == 0);
-                    }
-                }
-
-                if (compress) {
-                    deflateEnd(&strm);
-                    fclose(comp_file);
-                    fprintf(stdout, "[cache] Finished compressing file %s\n", cache[i].filename);
-                    strcpy(cache[i].meta.filename_comp, filename_comp);
-                } else {
-                    memset(cache[i].meta.filename_comp, 0, sizeof(cache[i].meta.filename_comp));
-                }
-                SHA1_Final(hash, &ctx);
-                memset(cache[i].meta.etag, 0, sizeof(cache[i].meta.etag));
-                for (int j = 0; j < SHA_DIGEST_LENGTH; 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/necronda-server/cache", "wb");
-            fwrite(cache, sizeof(cache_entry), FILE_CACHE_SIZE, cache_file);
-            fclose(cache_file);
-        } else {
-            sleep(1);
-        }
-    }
-    return 0;
-}
-
-int cache_init() {
-    if (magic_init() != 0) {
-        return -1;
-    }
-
-    int shm_id = shmget(SHM_KEY_CACHE, FILE_CACHE_SIZE * sizeof(cache_entry), IPC_CREAT | IPC_EXCL | 0600);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to create 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 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 shared memory (rw): %s" CLR_STR "\n", strerror(errno));
-        return -4;
-    }
-    cache = shm_rw;
-    memset(cache, 0, FILE_CACHE_SIZE * sizeof(cache_entry));
-    shmdt(shm_rw);
-    cache = shm;
-
-    pid_t pid = fork();
-    if (pid == 0) {
-        // child
-        if (cache_process() == 0) {
-            return 1;
-        } else {
-            return -6;
-        }
-    } else if (pid > 0) {
-        // parent
-        fprintf(stderr, "Started child process with PID %i as cache-updater\n", pid);
-        children[0] = pid;
-    } else {
-        fprintf(stderr, ERR_STR "Unable to create child process: %s" CLR_STR "\n", strerror(errno));
-        return -5;
-    }
-
-    return 0;
-}
-
-int cache_unload() {
-    int shm_id = shmget(SHM_KEY_CACHE, 0, 0);
-    if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to get 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 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(SHM_KEY_CACHE, 0, 0);
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        print(ERR_STR "Unable to attach 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 (strcmp(type, "text/plain") == 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, "text/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, 0, sizeof(cache[entry_num].meta.filename_comp));
-    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(SHM_KEY_CACHE, 0, 0);
-    void *shm_rw = shmat(shm_id, NULL, 0);
-    if (shm_rw == (void *) -1) {
-        print(ERR_STR "Unable to attach shared memory (rw): %s" CLR_STR, strerror(errno));
-        return -1;
-    }
-    cache = shm_rw;
-
-    int i;
-    for (i = 0; i < FILE_CACHE_SIZE; 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, 0, sizeof(cache[i].meta.filename_comp));
-    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 < FILE_CACHE_SIZE; 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 < FILE_CACHE_SIZE; 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/cache.h

@@ -1,49 +0,0 @@
-/**
- * Necronda Web Server
- * File cache implementation (header file)
- * src/cache.h
- * Lorenz Stechauner, 2020-12-19
- */
-
-#ifndef NECRONDA_SERVER_CACHE_H
-#define NECRONDA_SERVER_CACHE_H
-
-#include "uri.h"
-
-#include <stdio.h>
-#include <zlib.h>
-#include <magic.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-
-
-magic_t magic;
-
-typedef struct {
-    char filename[256];
-    unsigned char webroot_len;
-    unsigned char is_updating:1;
-    meta_data meta;
-} cache_entry;
-
-cache_entry *cache;
-
-int cache_continue = 1;
-
-int magic_init();
-
-void cache_process_term();
-
-int cache_process();
-
-int cache_init();
-
-int cache_unload();
-
-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 //NECRONDA_SERVER_CACHE_H

src/client.c

@@ -1,70 +1,97 @@
 /**
- * Necronda Web Server
- * Client connection and request handlers
- * src/client.c
- * Lorenz Stechauner, 2020-12-03
+ * 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 "logger.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};
 
 host_config *get_host_config(const char *host) {
-    for (int i = 0; i < MAX_HOST_CONFIG; i++) {
-        host_config *hc = &config[i];
+    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() {
+void client_terminate(int _) {
     server_keep_alive = 0;
 }
 
-int client_websocket_handler() {
-    // TODO implement client_websocket_handler
-    return 0;
-}
-
-int client_request_handler(sock *client, unsigned long client_num, unsigned int req_num) {
+int client_request_handler(client_ctx_t *cctx, sock *client, unsigned long client_num, unsigned int req_num, const char *restrict log_client_prefix) {
     struct timespec begin, end;
     long ret;
     int client_keep_alive;
+
     char buf0[1024], buf1[1024];
-    char msg_buf[4096], msg_pre_buf[4096], err_msg[256];
+    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];
-    err_msg[0] = 0;
-    char host[256], *host_ptr, *hdr_connection;
-    host_config *conf = NULL;
-    long content_length = 0;
-    FILE *file = NULL;
+    char host[256];
+    const char *host_ptr, *hdr_connection;
+    char log_req_prefix[512];
+
     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 php_fpm = {.socket = 0, .req_id = 0};
+
+    fastcgi_conn fcgi_conn = {.socket = 0, .req_id = 0, .ctx = cctx};
     http_status custom_status;
 
-    http_res res;
-    sprintf(res.version, "1.1");
-    res.status = http_get_status(501);
-    res.hdr.field_num = 0;
+    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);
 
-    fd_set socket_fds;
-    FD_ZERO(&socket_fds);
-    FD_SET(client->socket, &socket_fds);
-    client_timeout.tv_sec = CLIENT_TIMEOUT;
-    client_timeout.tv_usec = 0;
-    ret = select(client->socket + 1, &socket_fds, NULL, NULL, &client_timeout);
+    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;
-        }
+        if (errno != 0) return 1;
+
         client_keep_alive = 0;
         res.status = http_get_status(408);
         goto respond;
@@ -78,23 +105,22 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         if (ret < 0) {
             goto abort;
         } else if (ret == 1) {
-            sprintf(err_msg, "Unable to parse header: Invalid header format.");
+            sprintf(err_msg, "Unable to parse http header: Invalid header format.");
         } else if (ret == 2) {
-            sprintf(err_msg, "Unable to parse header: Invalid method.");
+            sprintf(err_msg, "Unable to parse http header: Invalid method.");
         } else if (ret == 3) {
-            sprintf(err_msg, "Unable to parse header: Invalid version.");
+            sprintf(err_msg, "Unable to parse http header: Invalid version.");
         } else if (ret == 4) {
-            sprintf(err_msg, "Unable to parse header: Header contains illegal characters.");
+            sprintf(err_msg, "Unable to parse http header: Header contains illegal characters.");
         } else if (ret == 5) {
-            sprintf(err_msg, "Unable to parse header: End of header not found.");
+            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 &&
-                        (strcmp(hdr_connection, "keep-alive") == 0 || strcmp(hdr_connection, "Keep-Alive") == 0);
+    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;
@@ -102,10 +128,10 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         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);
+        if (strchr(cctx->addr, ':') == NULL) {
+            strcpy(host, cctx->addr);
         } else {
-            sprintf(host, "[%s]", client_addr_str);
+            sprintf(host, "[%s]", cctx->addr);
         }
         res.status = http_get_status(400);
         sprintf(err_msg, "The client provided no or an invalid Host header field.");
@@ -114,13 +140,13 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         strcpy(host, host_ptr);
     }
 
-    sprintf(log_req_prefix, "[%s%24s%s]%s ", BLD_STR, host, CLR_STR, log_client_prefix);
-    log_prefix = log_req_prefix;
-    print(BLD_STR "%s %s" CLR_STR, req.method, req.uri);
+    sprintf(log_req_prefix, "[%6i][%s%*s%s]%s", getpid(), BLD_STR, INET6_ADDRSTRLEN, host, CLR_STR, log_client_prefix);
+    logger_set_prefix(log_req_prefix);
+    info(BLD_STR "%s %s", req.method, req.uri);
 
     conf = get_host_config(host);
     if (conf == NULL) {
-        print("Host unknown, redirecting to default");
+        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);
@@ -128,7 +154,7 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
     }
 
     http_uri uri;
-    unsigned char dir_mode = conf->type == CONFIG_TYPE_LOCAL ? conf->local.dir_mode : URI_DIR_MODE_NO_VALIDATION;
+    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) {
@@ -152,13 +178,12 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         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 = sizeof(buf0);
-            url_encode(uri.uri, buf0, &size);
+            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);
+                    error("Header field 'Location' too long");
                     goto respond;
                 }
                 http_add_header_field(&res.hdr, "Location", buf1);
@@ -175,6 +200,23 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
     }
 
     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.");
@@ -198,42 +240,80 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
 
         if (uri.is_static) {
             res.status = http_get_status(200);
-            http_add_header_field(&res.hdr, "Allow", "GET, HEAD");
             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;
             }
-            char *last_modified = http_format_date(uri.meta->stat.st_mtime, buf0, sizeof(buf0));
+            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");
             }
 
-            char *if_modified_since = http_get_header_field(&req.hdr, "If-Modified-Since");
-            char *if_none_match = http_get_header_field(&req.hdr, "If-None-Match");
+            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)) {
+                (accept_if_modified_since && if_modified_since != NULL && strcmp(if_modified_since, last_modified) == 0))
+            {
                 res.status = http_get_status(304);
                 goto respond;
             }
 
-            char *range = http_get_header_field(&req.hdr, "Range");
+            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);
@@ -277,64 +357,65 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
                 goto respond;
             }
 
-            char *accept_encoding = http_get_header_field(&req.hdr, "Accept-Encoding");
-            if (uri.meta->filename_comp[0] != 0 && accept_encoding != NULL &&
-                strstr(accept_encoding, "deflate") != NULL) {
-                file = fopen(uri.meta->filename_comp, "rb");
             if (file == NULL) {
-                    cache_filename_comp_invalid(uri.filename);
-                    goto not_compressed;
-                }
-                http_add_header_field(&res.hdr, "Content-Encoding", "deflate");
-            } else {
-                not_compressed:
                 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);
+                error("Invalid FastCGI extension: %s", 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(&php_fpm, client_num, req_num, client, &req, &uri) != 0) {
-                res.status = http_get_status(502);
-                sprintf(err_msg, "Unable to communicate with PHP-FPM.");
+            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;
             }
 
-            if (strcmp(req.method, "POST") == 0 || strcmp(req.method, "PUT") == 0) {
-                char *client_content_length = http_get_header_field(&req.hdr, "Content-Length");
-                unsigned long client_content_len;
-                if (client_content_length == NULL) {
-                    goto fastcgi_end;
+            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;
             }
-                client_content_len = strtoul(client_content_length, NULL, 10);
-                ret = fastcgi_receive(&php_fpm, client, client_content_len);
             if (ret != 0) {
                 if (ret < 0) {
                     goto abort;
                 } else {
-                        sprintf(err_msg, "Unable to communicate with PHP-FPM.");
+                    sprintf(err_msg, "Unable to communicate with FastCGI socket.");
                 }
                 res.status = http_get_status(502);
                 goto respond;
             }
-            }
-            fastcgi_end:
-            fastcgi_close_stdin(&php_fpm);
+            fastcgi_close_stdin(&fcgi_conn);
 
-            ret = fastcgi_header(&php_fpm, &res, err_msg);
+            ret = fastcgi_header(&fcgi_conn, &res, err_msg);
             if (ret != 0) {
-                if (ret < 0) {
-                    goto abort;
-                }
+                if (ret < 0) goto abort;
                 goto respond;
             }
-            char *status = http_get_header_field(&res.hdr, "Status");
+
+            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);
@@ -351,60 +432,195 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
                 }
             }
 
-            char *accept_encoding = http_get_header_field(&req.hdr, "Accept-Encoding");
-            if (accept_encoding != NULL && strstr(accept_encoding, "deflate") != NULL) {
-                http_add_header_field(&res.hdr, "Content-Encoding", "deflate");
+            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;
-            use_fastcgi = 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);
+        info("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, conf, client, &custom_status, err_msg);
-        use_rev_proxy = ret == 0;
+
+        ret = rev_proxy_init(&req, &res, &ctx, conf, client, cctx, &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 {
-        print(ERR_STR "Unknown host type: %i" CLR_STR, conf->type);
+                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 {
+        error("Unknown host type: %i", 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 && !use_rev_proxy && file == NULL &&
-            ((res.status->code >= 400 && res.status->code < 600) || err_msg[0] != 0)) {
+        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);
 
-            sprintf(msg_pre_buf, info->doc, res.status->code, res.status->msg,
-                    http_msg != NULL ? http_msg->msg : "", err_msg[0] != 0 ? err_msg : "");
+            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=\"%s\">%s</a></li>\n</ul>\n", location, 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, info->mode, info->icon, info->color, host);
-            http_add_header_field(&res.hdr, "Content-Type", "text/html; charset=UTF-8");
+                                      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;
         }
     }
 
-    char *conn = http_get_header_field(&res.hdr, "Connection");
-    int close_proxy = conn == NULL || (strcmp(conn, "keep-alive") != 0 && strcmp(conn, "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) {
@@ -414,24 +630,35 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         } else {
             http_add_header_field(&res.hdr, "Connection", "close");
         }
+    }
 
     http_send_response(client, &res);
     clock_gettime(CLOCK_MONOTONIC, &end);
-    char *location = http_get_header_field(&res.hdr, "Location");
+    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,
+    info("%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 (strcmp(req.method, "HEAD") != 0) {
+    if (use_rev_proxy == 2) {
+        // WebSocket
+        info("Upgrading connection to WebSocket connection");
+        ret = ws_handle_connection(client, &rev_proxy);
+        if (ret != 0) {
+            client_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 (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));
+                error("Unable to send: %s", sock_strerror(client));
             }
             snd_len += ret;
         } else if (file != NULL) {
@@ -442,58 +669,58 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
                 }
                 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));
+                    error("Unable to send: %s", sock_strerror(client));
                     break;
                 }
                 snd_len += ret;
             }
         } else if (use_fastcgi) {
-            char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
-            int chunked = transfer_encoding != NULL && strcmp(transfer_encoding, "chunked") == 0;
-            char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
-            int comp = content_encoding != NULL && strcmp(content_encoding, "deflate") == 0;
-            int flags = (chunked ? FASTCGI_CHUNKED : 0) | (comp ? FASTCGI_COMPRESS : 0);
-            fastcgi_send(&php_fpm, client, flags);
+            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) {
-            char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
-            int chunked = transfer_encoding != NULL && strcmp(transfer_encoding, "chunked") == 0;
-            char *content_len = http_get_header_field(&res.hdr, "Content-Length");
+            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);
             }
-            rev_proxy_send(client, chunked, len_to_send);
+
+            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);
+        info(BLUE_STR "Closing proxy connection");
         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));
+    info("Transfer complete: %s", format_duration(micros, buf0));
 
     uri_free(&uri);
     abort:
-    if (php_fpm.socket != 0) {
-        shutdown(php_fpm.socket, SHUT_RDWR);
-        close(php_fpm.socket);
-        php_fpm.socket = 0;
+    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);
-    if (client->buf != NULL) {
-        free(client->buf);
-        client->buf = NULL;
-        client->buf_off = 0;
-        client->buf_len = 0;
-    }
     return !client_keep_alive;
 }
 
-int client_connection_handler(sock *client, unsigned long client_num) {
+int client_connection_handler(client_ctx_t *ctx, sock *client, unsigned long client_num, const char *restrict log_conn_prefix, const char *restrict log_client_prefix) {
     struct timespec begin, end;
     int ret, req_num;
     char buf[1024];
@@ -501,16 +728,16 @@ int client_connection_handler(sock *client, unsigned long client_num) {
     clock_gettime(CLOCK_MONOTONIC, &begin);
 
     if (dns_server[0] != 0) {
-        sprintf(buf, "dig @%s +short +time=1 -x %s", dns_server, client_addr_str);
+        sprintf(buf, "dig @%s +short +time=1 -x %s", dns_server, ctx->addr);
         FILE *dig = popen(buf, "r");
         if (dig == NULL) {
-            print(ERR_STR "Unable to start dig: %s" CLR_STR "\n", strerror(errno));
+            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) {
-            print(ERR_STR "Dig terminated with exit code %i" CLR_STR "\n", ret);
+            error("Dig terminated with exit code %i", ret);
             goto dig_err;
         }
         char *ptr = memchr(buf, '\n', read);
@@ -518,23 +745,21 @@ int client_connection_handler(sock *client, unsigned long client_num) {
             goto dig_err;
         }
         ptr[-1] = 0;
-        client_host_str = malloc(strlen(buf) + 1);
-        strcpy(client_host_str, buf);
+        strncpy(ctx->host, buf, sizeof(ctx->host));
     } else {
         dig_err:
-        client_host_str = NULL;
+        ctx->host[0] = 0;
     }
 
-    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);
+        MMDB_lookup_result_s result = MMDB_lookup_string(&mmdbs[i], ctx->addr, &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));
+            error("Unable to lookup geoip info: %s", MMDB_strerror(mmdb_res));
             continue;
         } else if (gai_error != 0) {
-            print(ERR_STR "Unable to lookup geoip info" CLR_STR "\n");
+            error("Unable to lookup geoip info");
             continue;
         } else if (!result.found_entry) {
             continue;
@@ -543,7 +768,7 @@ int client_connection_handler(sock *client, unsigned long client_num) {
         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));
+            error("Unable to lookup geoip info: %s", MMDB_strerror(mmdb_res));
             continue;
         }
 
@@ -551,32 +776,30 @@ int client_connection_handler(sock *client, unsigned long client_num) {
         if (str_off != 0) {
             str_off--;
         }
-        mmdb_json(list, client_geoip, &str_off, GEOIP_MAX_SIZE);
+        mmdb_json(list, ctx->geoip, &str_off, GEOIP_MAX_SIZE);
         if (prev != 0) {
-            client_geoip[prev - 1] = ',';
+            ctx->geoip[prev - 1] = ',';
         }
 
         MMDB_free_entry_data_list(list);
     }
 
-    char client_cc[3];
-    client_cc[0] = 0;
+    ctx->cc[0] = 0;
     if (str_off == 0) {
-        free(client_geoip);
-        client_geoip = NULL;
+        ctx->geoip[0] = 0;
     } else {
-        char *pos = client_geoip;
+        const char *pos = ctx->geoip;
         pos = strstr(pos, "\"country\":");
         if (pos != NULL) {
             pos = strstr(pos, "\"iso_code\":");
             pos += 12;
-            strncpy(client_cc, pos, 2);
+            snprintf(ctx->cc, sizeof(ctx->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");
+    info("Connection accepted from %s %s%s%s[%s]", ctx->addr, ctx->host[0] != 0 ? "(" : "",
+         ctx->host[0] != 0 ? ctx->host : "", ctx->host[0] != 0 ? ") " : "",
+         ctx->cc[0] != 0 ? ctx->cc : "N/A");
 
     client_timeout.tv_sec = CLIENT_TIMEOUT;
     client_timeout.tv_usec = 0;
@@ -584,7 +807,7 @@ int client_connection_handler(sock *client, unsigned long client_num) {
         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));
+        error("Unable to set timeout for socket");
         return 1;
     }
 
@@ -598,7 +821,8 @@ int client_connection_handler(sock *client, unsigned long client_num) {
         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));
+            error("Unable to perform handshake: %s", sock_strerror(client));
+            ret = -1;
             goto close;
         }
     }
@@ -606,80 +830,62 @@ int client_connection_handler(sock *client, unsigned long client_num) {
     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;
+        ret = client_request_handler(ctx, client, client_num, req_num++, log_client_prefix);
+        logger_set_prefix(log_conn_prefix);
     }
 
     close:
     sock_close(client);
 
     if (rev_proxy.socket != 0) {
-        print(BLUE_STR "Closing proxy connection" CLR_STR);
+        info(BLUE_STR "Closing proxy connection");
         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));
+    info("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;
 
+    client_ctx_t ctx;
+    char log_client_prefix[256], log_conn_prefix[512];
+
     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;
+    inet_ntop(client_addr->sin6_family, (void *) &client_addr->sin6_addr, ctx._c_addr, sizeof(ctx._c_addr));
+    if (strncmp(ctx._c_addr, "::ffff:", 7) == 0) {
+        ctx.addr = ctx._c_addr + 7;
     } else {
-        client_addr_str = client_addr_str_ptr;
+        ctx.addr = ctx._c_addr;
     }
 
     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;
+    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.s_addr = ctx._s_addr + 7;
     } else {
-        server_addr_str = server_addr_str_ptr;
+        ctx.s_addr = ctx._s_addr;
     }
 
-    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], INET_ADDRSTRLEN, client_addr_str,
+            ntohs(server_addr->sin6_port), CLR_STR, color_table[client_num % 6], INET6_ADDRSTRLEN, ctx.addr,
             ntohs(client_addr->sin6_port), CLR_STR);
 
-    log_conn_prefix = malloc(256);
-    sprintf(log_conn_prefix, "[%24s]%s ", server_addr_str, log_client_prefix);
-    log_prefix = log_conn_prefix;
+    sprintf(log_conn_prefix, "[%6i][%*s]%s", getpid(), INET6_ADDRSTRLEN, ctx.s_addr, log_client_prefix);
+    logger_set_prefix(log_conn_prefix);
 
-    print("Started child process with PID %i", getpid());
+    info("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;
+    return client_connection_handler(&ctx, client, client_num, log_conn_prefix, log_client_prefix);
 }

src/client.h

@@ -1,23 +1,32 @@
 /**
- * Necronda Web Server
- * Client connection and request handlers (header file)
- * src/client.h
- * Lorenz Stechauner, 2021-01-17
+ * 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 NECRONDA_SERVER_CLIENT_H
-#define NECRONDA_SERVER_CLIENT_H
+#ifndef SESIMOS_CLIENT_H
+#define SESIMOS_CLIENT_H
 
-#include "necronda-server.h"
-#include "utils.h"
-#include "uri.h"
-#include "http.h"
-#include "fastcgi.h"
+#include "lib/config.h"
+#include "lib/sock.h"
+#include "lib/geoip.h"
 
+#include <arpa/inet.h>
 
-int server_keep_alive = 1;
-char *log_client_prefix, *log_conn_prefix, *log_req_prefix, *client_geoip;
+typedef struct {
+    char *addr;
+    char *s_addr;
+    char cc[3];
+    char host[256];
+    char geoip[GEOIP_MAX_SIZE + 1];
+    char _c_addr[INET6_ADDRSTRLEN + 1];
+    char _s_addr[INET6_ADDRSTRLEN + 1];
+} client_ctx_t;
 
-struct timeval client_timeout = {.tv_sec = CLIENT_TIMEOUT, .tv_usec = 0};
+host_config *get_host_config(const char *host);
 
-#endif //NECRONDA_SERVER_CLIENT_H
+int client_handler(sock *client, unsigned long client_num, struct sockaddr_in6 *client_addr);
+
+#endif //SESIMOS_CLIENT_H

src/config.h

@@ -1,50 +0,0 @@
-/**
- * Necronda Web Server
- * Configuration file loader (header file)
- * src/config.h
- * Lorenz Stechauner, 2021-01-05
- */
-
-
-#ifndef NECRONDA_SERVER_CONFIG_H
-#define NECRONDA_SERVER_CONFIG_H
-
-#define CONFIG_TYPE_UNSET 0
-#define CONFIG_TYPE_LOCAL 1
-#define CONFIG_TYPE_REVERSE_PROXY 2
-
-#include "uri.h"
-
-#include <stdio.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-
-
-typedef struct {
-    int type;
-    char name[256];
-    union {
-        struct {
-            char hostname[256];
-            unsigned short port;
-            unsigned char enc:1;
-        } rev_proxy;
-        struct {
-            char webroot[256];
-            unsigned char dir_mode:2;
-        } local;
-    };
-} host_config;
-
-
-host_config *config;
-char cert_file[256], key_file[256], geoip_dir[256], dns_server[256];
-
-
-int config_init();
-
-int config_load(const char *filename);
-
-int config_unload();
-
-#endif //NECRONDA_SERVER_CONFIG_H

src/defs.h

@@ -0,0 +1,26 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Definitions
+ * @file src/defs.h
+ * @author Lorenz Stechauner
+ * @date 2021-05-04
+ */
+
+#ifndef SESIMOS_DEF_H
+#define SESIMOS_DEF_H
+
+#define SERVER_VERSION "4.6"
+#define SERVER_STR "Sesimos/" SERVER_VERSION
+#define SERVER_STR_HTML "Sesimos web server " SERVER_VERSION
+
+#define CHUNK_SIZE 8192
+
+#ifndef DEFAULT_HOST
+#   define DEFAULT_HOST "www.necronda.net"
+#endif
+
+#ifndef SERVER_NAME
+#   define SERVER_NAME DEFAULT_HOST
+#endif
+
+#endif //SESIMOS_DEF_H

src/http.c

@@ -1,312 +0,0 @@
-/**
- * Necronda Web Server
- * HTTP implementation
- * src/net/http.c
- * Lorenz Stechauner, 2020-12-09
- */
-
-#include "http.h"
-
-
-void http_to_camel_case(char *str, int mode) {
-    char last = '-';
-    char ch;
-    for (int i = 0; i < strlen(str); i++) {
-        ch = str[i];
-        if (mode == HTTP_CAMEL && last == '-' && ch >= 'a' && ch <= 'z') {
-            str[i] = (char) ((int) ch & 0x5F);
-        } else if (mode == HTTP_LOWER && ch >= 'A' && ch <= 'Z') {
-            str[i] = (char) ((int) ch | 0x20);
-        }
-        last = str[i];
-    }
-}
-
-void http_free_hdr(http_hdr *hdr) {
-    for (int i = 0; i < hdr->field_num; i++) {
-        free(hdr->fields[i][0]);
-        free(hdr->fields[i][1]);
-    }
-    hdr->field_num = 0;
-}
-
-void http_free_req(http_req *req) {
-    if (req->uri == NULL) free(req->uri);
-    req->uri = NULL;
-    http_free_hdr(&req->hdr);
-}
-
-void http_free_res(http_res *res) {
-    http_free_hdr(&res->hdr);
-}
-
-int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr) {
-    char *pos1 = memchr(buf, ':', end_ptr - buf);
-    char *pos2;
-    if (pos1 == NULL) {
-        print(ERR_STR "Unable to parse header" CLR_STR);
-        return 3;
-    }
-
-    long len = pos1 - buf;
-    hdr->fields[(int) hdr->field_num][0] = malloc(len + 1);
-    sprintf(hdr->fields[(int) hdr->field_num][0], "%.*s", (int) len, buf);
-    http_to_camel_case(hdr->fields[(int) hdr->field_num][0], HTTP_CAMEL);
-
-    pos1++;
-    pos2 = (char *) end_ptr - 1;
-    while (pos1[0] == ' ') pos1++;
-    while (pos2[0] == ' ') pos2--;
-    len = pos2 - pos1 + 1;
-
-    if (len <= 0) {
-        hdr->fields[(int) hdr->field_num][1] = malloc(1);
-        hdr->fields[(int) hdr->field_num][1][0] = 0;
-    } else {
-        hdr->fields[(int) hdr->field_num][1] = malloc(len + 1);
-        sprintf(hdr->fields[(int) hdr->field_num][1], "%.*s", (int) len, pos1);
-    }
-    hdr->field_num++;
-    return 0;
-}
-
-int http_receive_request(sock *client, http_req *req) {
-    long rcv_len, len;
-    char *ptr, *pos0, *pos1, *pos2;
-    char buf[CLIENT_MAX_HEADER_SIZE];
-    memset(buf, 0, sizeof(buf));
-    memset(req->method, 0, sizeof(req->method));
-    memset(req->version, 0, sizeof(req->version));
-    req->uri = NULL;
-    req->hdr.field_num = 0;
-
-    while (1) {
-        rcv_len  = sock_recv(client, buf, CLIENT_MAX_HEADER_SIZE, 0);
-        if (rcv_len <= 0) {
-            print("Unable to receive: %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 header: End of header not found" CLR_STR);
-            return 5;
-        }
-
-        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);
-                return 4;
-            }
-        }
-
-        ptr = buf;
-        while (header_len > (ptr - buf + 2)) {
-            pos0 = strstr(ptr, "\r\n");
-            if (pos0 == NULL) {
-                print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
-                return 1;
-            }
-
-            if (req->version[0] == 0) {
-                pos1 = 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 header: Method name too long" CLR_STR);
-                    return 2;
-                }
-
-                for (int i = 0; i < (pos1 - ptr - 1); i++) {
-                    if (ptr[i] < 'A' || ptr[i] > 'Z') {
-                        print(ERR_STR "Unable to parse header: Invalid method" CLR_STR);
-                        return 2;
-                    }
-                }
-                strncpy(req->method, ptr, pos1 - ptr - 1);
-
-                pos2 = memchr(pos1, ' ', rcv_len - (pos1 - buf)) + 1;
-                if (pos2 == NULL) {
-                    err_hdr_fmt:
-                    print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
-                    return 1;
-                }
-
-                if (memcmp(pos2, "HTTP/", 5) != 0 || memcmp(pos2 + 8, "\r\n", 2) != 0) {
-                    print(ERR_STR "Unable to parse header: Invalid version" CLR_STR);
-                    return 3;
-                }
-
-                len = pos2 - pos1 - 1;
-                req->uri = malloc(len + 1);
-                sprintf(req->uri, "%.*s", (int) len, pos1);
-                sprintf(req->version, "%.3s", pos2 + 5);
-            } else {
-                int ret = http_parse_header_field(&req->hdr, ptr, pos0);
-                if (ret != 0) return ret;
-            }
-            ptr = pos0 + 2;
-        }
-        if (pos0[2] == '\r' && pos0[3] == '\n') {
-            break;
-        }
-    }
-
-    client->buf_len = rcv_len - (pos0 - buf + 4);
-    if (client->buf_len > 0) {
-        client->buf = malloc(client->buf_len);
-        client->buf_off = 0;
-        memcpy(client->buf, pos0 + 4, client->buf_len);
-    }
-
-    return 0;
-}
-
-char *http_get_header_field(const http_hdr *hdr, const char *field_name) {
-    char field_name_1[256], field_name_2[256];
-    strcpy(field_name_1, field_name);
-    http_to_camel_case(field_name_1, HTTP_LOWER);
-    for (int i = 0; i < hdr->field_num; i++) {
-        strcpy(field_name_2, hdr->fields[i][0]);
-        http_to_camel_case(field_name_2, HTTP_LOWER);
-        if (strcmp(field_name_1, field_name_2) == 0) {
-            return hdr->fields[i][1];
-        }
-    }
-    return NULL;
-}
-
-void http_add_header_field(http_hdr *hdr, const char *field_name, const char *field_value) {
-    size_t len_name = strlen(field_name);
-    size_t len_value = strlen(field_value);
-    char *_field_name = malloc(len_name + 1);
-    char *_field_value = malloc(len_value + 1);
-    strcpy(_field_name, field_name);
-    strcpy(_field_value, field_value);
-    http_to_camel_case(_field_name, HTTP_PRESERVE);
-    hdr->fields[(int) hdr->field_num][0] = _field_name;
-    hdr->fields[(int) hdr->field_num][1] = _field_value;
-    hdr->field_num++;
-}
-
-void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode) {
-    char field_name_1[256], field_name_2[256];
-    strcpy(field_name_1, field_name);
-    http_to_camel_case(field_name_1, HTTP_LOWER);
-
-    int i = 0;
-    int diff = 1;
-    if (mode == HTTP_REMOVE_LAST) {
-        i = hdr->field_num - 1;
-        diff = -1;
-    }
-    for (; i < hdr->field_num && i >= 0; i += diff) {
-        strcpy(field_name_2, hdr->fields[i][0]);
-        http_to_camel_case(field_name_2, HTTP_LOWER);
-        if (strcmp(field_name_1, field_name_2) == 0) {
-            for (int j = i; j < hdr->field_num - 1; j++) {
-                memcpy(hdr->fields[j], hdr->fields[j + 1], sizeof(hdr->fields[0]));
-            }
-            hdr->field_num--;
-            if (mode == HTTP_REMOVE_ALL) {
-                i -= diff;
-            } else {
-                return;
-            }
-        }
-    }
-}
-
-int http_send_response(sock *client, http_res *res) {
-    char buf[CLIENT_MAX_HEADER_SIZE];
-    long off = sprintf(buf, "HTTP/%s %03i %s\r\n", res->version, res->status->code, res->status->msg);
-    for (int i = 0; i < res->hdr.field_num; i++) {
-        off += sprintf(buf + off, "%s: %s\r\n", res->hdr.fields[i][0], res->hdr.fields[i][1]);
-    }
-    off += sprintf(buf + off, "\r\n");
-    if (sock_send(client, buf, off, 0) < 0) {
-        return -1;
-    }
-    return 0;
-}
-
-int http_send_request(sock *server, http_req *req) {
-    char buf[CLIENT_MAX_HEADER_SIZE];
-    long off = sprintf(buf, "%s %s HTTP/%s\r\n", req->method, req->uri, req->version);
-    for (int i = 0; i < req->hdr.field_num; i++) {
-        off += sprintf(buf + off, "%s: %s\r\n", req->hdr.fields[i][0], req->hdr.fields[i][1]);
-    }
-    off += sprintf(buf + off, "\r\n");
-    long ret = sock_send(server, buf, off, 0);
-    if (ret <= 0) {
-        return -1;
-    }
-    return 0;
-}
-
-const http_status *http_get_status(unsigned short status_code) {
-    for (int i = 0; i < sizeof(http_statuses) / sizeof(http_status); i++) {
-        if (http_statuses[i].code == status_code) {
-            return &http_statuses[i];
-        }
-    }
-    return NULL;
-}
-
-const http_status_msg *http_get_error_msg(const http_status *status) {
-    unsigned short code = status->code;
-    for (int i = 0; i < sizeof(http_status_messages) / sizeof(http_status_msg); i++) {
-        if (http_status_messages[i].code == code) {
-            return &http_status_messages[i];
-        }
-    }
-    return NULL;
-}
-
-const char *http_get_status_color(const http_status *status) {
-    unsigned short code = status->code;
-    if (code >= 100 && code < 200) {
-        return HTTP_1XX_STR;
-    } else if ((code >= 200 && code < 300) || code == 304) {
-        return HTTP_2XX_STR;
-    } else if (code >= 300 && code < 400) {
-        return HTTP_3XX_STR;
-    } else if (code >= 400 && code < 500) {
-        return HTTP_4XX_STR;
-    } else if (code >= 500 && code < 600) {
-        return HTTP_5XX_STR;
-    }
-    return "";
-}
-
-char *http_format_date(time_t time, char *buf, size_t size) {
-    struct tm *timeinfo = gmtime(&time);
-    strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", timeinfo);
-    return buf;
-}
-
-char *http_get_date(char *buf, size_t size) {
-    time_t rawtime;
-    time(&rawtime);
-    return http_format_date(rawtime, buf, 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},
-            {"success", HTTP_COLOR_SUCCESS, http_success_icon, http_success_document},
-            {"warning", HTTP_COLOR_WARNING, http_warning_icon, http_warning_document},
-            {"error", HTTP_COLOR_ERROR, http_error_icon, http_error_document}
-    };
-    if (code >= 100 && code < 200) {
-        return &info[0];
-    } else if ((code >= 200 && code < 300) || code == 304) {
-        return &info[1];
-    } else if (code >= 300 && code < 400) {
-        return &info[2];
-    } else if (code >= 400 && code < 600) {
-        return &info[3];
-    }
-    return NULL;
-}

src/lib/cache.c

@@ -0,0 +1,406 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief File cache implementation
+ * @file src/lib/cache.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-19
+ */
+
+#include "../logger.h"
+#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) {
+        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 -2;
+    }
+    return 0;
+}
+
+void cache_process_term(int _) {
+    cache_continue = 0;
+}
+
+int cache_process(void) {
+    errno = 0;
+    signal(SIGINT, cache_process_term);
+    signal(SIGTERM, cache_process_term);
+
+    logger_set_name("cache");
+
+    int shm_id = shmget(CACHE_SHM_KEY, CACHE_ENTRIES * sizeof(cache_entry), 0);
+    if (shm_id < 0) {
+        critical("Unable to create cache shared memory");
+        return -1;
+    }
+
+    shmdt(cache);
+    errno = 0;
+    void *shm_rw = shmat(shm_id, NULL, 0);
+    if (shm_rw == (void *) -1) {
+        critical("Unable to attach cache shared memory (rw)");
+        return -2;
+    }
+    cache = shm_rw;
+
+    if (mkdir("/var/sesimos/", 0755) < 0 && errno != EEXIST) {
+        critical("Unable to create directory '/var/sesimos/'");
+        return -3;
+    }
+
+    if (mkdir("/var/sesimos/server/", 0755) < 0 && errno != EEXIST) {
+        critical("Unable to create directory '/var/sesimos/server/'");
+        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);
+    }
+
+    errno = 0;
+
+    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;
+                info("Hashing file %s", 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) {
+                        error("Unable to create directory %s", buf);
+                        goto comp_err;
+                    }
+
+                    sprintf(buf, "%.*s/.sesimos/cache", cache[i].webroot_len, cache[i].filename);
+                    if (mkdir(buf, 0700) != 0 && errno != EEXIST) {
+                        error("Unable to create directory %s", buf);
+                        goto comp_err;
+                    }
+                    errno = 0;
+
+                    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)) {
+                        error("Unable to open cached file: File name for compressed file too long");
+                        goto comp_err;
+                    }
+
+                    info("Compressing file %s", 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) {
+                        error("Unable to open cached file");
+                        comp_err:
+                        compress = 0;
+                    } else {
+                        ret = compress_init(&comp_ctx, COMPRESS_GZ | COMPRESS_BR);
+                        if (ret != 0) {
+                            error("Unable to init compression");
+                            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);
+                    info("Finished compressing file %s", 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);
+                info("Finished hashing file %s", 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) {
+                critical("Unable to open cache file");
+                return -1;
+            }
+            fwrite(cache, sizeof(cache_entry), CACHE_ENTRIES, cache_file);
+            fclose(cache_file);
+        } else {
+            sleep(1);
+        }
+    }
+
+    return 0;
+}
+
+int cache_init(void) {
+    errno = 0;
+    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) {
+        critical("Unable to create cache shared memory");
+        return -2;
+    }
+
+    void *shm = shmat(shm_id, NULL, SHM_RDONLY);
+    if (shm == (void *) -1) {
+        critical("Unable to attach cache shared memory (ro)");
+        return -3;
+    }
+    cache = shm;
+
+    void *shm_rw = shmat(shm_id, NULL, 0);
+    if (shm_rw == (void *) -1) {
+        critical("Unable to attach cache shared memory (rw)");
+        return -4;
+    }
+    cache = shm_rw;
+    memset(cache, 0, CACHE_ENTRIES * sizeof(cache_entry));
+    shmdt(shm_rw);
+    cache = shm;
+    errno = 0;
+
+    pid_t pid = fork();
+    if (pid == 0) {
+        // child
+        if (cache_process() == 0) {
+            return 0;
+        } else {
+            return -6;
+        }
+    } else if (pid > 0) {
+        // parent
+        info("Started child process with PID %i as cache-updater", pid);
+        return pid;
+    } else {
+        critical("Unable to create child process");
+        return -5;
+    }
+}
+
+int cache_unload(void) {
+    int shm_id = shmget(CACHE_SHM_KEY, 0, 0);
+    if (shm_id < 0) {
+        critical("Unable to get cache shared memory id");
+        shmdt(cache);
+        return -1;
+    } else if (shmctl(shm_id, IPC_RMID, NULL) < 0) {
+        critical("Unable to configure cache shared memory");
+        shmdt(cache);
+        return -1;
+    }
+    shmdt(cache);
+    errno = 0;
+    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) {
+        error("Unable to attach cache shared memory (rw)");
+        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;
+    errno = 0;
+    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) {
+        error("Unable to attach cache shared memory (rw)");
+        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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,82 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Compression interface
+ * @file src/lib/compress.c
+ * @author Lorenz Stechauner
+ * @date 2021-05-05
+ */
+
+#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->zfree = Z_NULL;
+        ctx->gzip->opaque = Z_NULL;
+        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) {
+        ctx->mode |= COMPRESS_BR;
+        ctx->brotli = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+        if (ctx->brotli == NULL) return -1;
+        BrotliEncoderSetParameter(ctx->brotli, BROTLI_PARAM_MODE, BROTLI_MODE_GENERIC);
+        BrotliEncoderSetParameter(ctx->brotli, BROTLI_PARAM_QUALITY, COMPRESS_LEVEL_BROTLI);
+    }
+    return 0;
+}
+
+int compress_compress(compress_ctx *ctx, const char *in, unsigned long *in_len, char *out, unsigned long *out_len, int finish) {
+    if ((ctx->mode & COMPRESS_GZ) && (ctx->mode & COMPRESS_BR)) {
+        errno = EINVAL;
+        return -1;
+    }
+    return compress_compress_mode(ctx, ctx->mode, in, in_len, out, out_len, finish);
+}
+
+int compress_compress_mode(compress_ctx *ctx, int mode, const char *in, unsigned long *in_len, char *out, unsigned long *out_len, int finish) {
+    if ((mode & COMPRESS_GZ) && (mode & COMPRESS_BR)) {
+        errno = EINVAL;
+        return -1;
+    } else if (mode & COMPRESS_GZ) {
+        ctx->gzip->next_in = (unsigned char*) in;
+        ctx->gzip->avail_in = *in_len;
+        ctx->gzip->next_out = (unsigned char*) out;
+        ctx->gzip->avail_out = *out_len;
+        int ret = deflate(ctx->gzip, finish ? Z_FINISH : Z_NO_FLUSH);
+        *in_len = ctx->gzip->avail_in;
+        *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,
+                                              in_len, (const unsigned char**) &in, out_len, (unsigned char **) &out, NULL);
+        return (ret == BROTLI_TRUE) ? 0 : -1;
+    } else {
+        errno = EINVAL;
+        return -2;
+    }
+}
+
+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;
+    }
+    ctx->mode = 0;
+    return 0;
+}

src/lib/compress.h

@@ -0,0 +1,38 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Compression interface (header file)
+ * @file src/lib/compress.h
+ * @author Lorenz Stechauner
+ * @date 2021-05-05
+ */
+
+#ifndef SESIMOS_COMPRESS_H
+#define SESIMOS_COMPRESS_H
+
+#include <zlib.h>
+#include <brotli/encode.h>
+
+#define COMPRESS_LEVEL_GZIP 9
+#define COMPRESS_LEVEL_BROTLI BROTLI_MAX_QUALITY
+
+#define COMPRESS_GZ 1
+#define COMPRESS_BR 2
+#define COMPRESS 3
+
+typedef struct {
+    int mode;
+    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 finish);
+
+int compress_compress_mode(compress_ctx *ctx, int mode, const char *in, unsigned long *in_len, char *out,
+                           unsigned long *out_len, int finish);
+
+int compress_free(compress_ctx *ctx);
+
+#endif //SESIMOS_COMPRESS_H

src/lib/config.c

@@ -1,47 +1,60 @@
 /**
- * Necronda Web Server
- * Configuration file loader
- * src/config.c
- * Lorenz Stechauner, 2021-01-05
+ * sesimos - secure, simple, modern web server
+ * @brief Configuration file loader
+ * @file src/lib/config.c
+ * @author Lorenz Stechauner
+ * @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>
 
 
-int config_init() {
-    int shm_id = shmget(SHM_KEY_CONFIG, MAX_HOST_CONFIG * sizeof(host_config), IPC_CREAT | IPC_EXCL | 0640);
+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 shared memory: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to create config shared memory");
         return -1;
     }
 
     void *shm = shmat(shm_id, NULL, SHM_RDONLY);
     if (shm == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach shared memory (ro): %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to attach config shared memory (ro)");
         return -2;
     }
     config = shm;
 
     void *shm_rw = shmat(shm_id, NULL, 0);
     if (shm_rw == (void *) -1) {
-        fprintf(stderr, ERR_STR "Unable to attach shared memory (rw): %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to attach config shared memory (rw)");
         return -3;
     }
     config = shm_rw;
-    memset(config, 0, MAX_HOST_CONFIG * sizeof(host_config));
+    memset(config, 0, sizeof(t_config));
     shmdt(shm_rw);
     config = shm;
     return 0;
 }
 
-int config_unload() {
-    int shm_id = shmget(SHM_KEY_CONFIG, 0, 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 shared memory id: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to get config shared memory id");
         shmdt(config);
         return -1;
     } else if (shmctl(shm_id, IPC_RMID, NULL) < 0) {
-        fprintf(stderr, ERR_STR "Unable to configure shared memory: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to configure config shared memory");
         shmdt(config);
         return -1;
     }
@@ -52,49 +65,89 @@ int config_unload() {
 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);
     unsigned long len = ftell(file);
     fseek(file, 0, SEEK_SET);
-    char *conf = malloc(len);
+    char *conf = alloca(len + 1);
     fread(conf, 1, len, file);
+    conf[len] = 0;
     fclose(file);
 
-    host_config *tmp_config = malloc(MAX_HOST_CONFIG * sizeof(host_config));
-    memset(tmp_config, 0, MAX_HOST_CONFIG * sizeof(host_config));
+    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 mode = 0;
+    char section = 0;
     char *ptr = NULL;
     char *source, *target;
-    while ((ptr = strtok(ptr == NULL ? conf :  NULL, "\n")) != NULL) {
+    while ((ptr = strsep(&conf, "\r\n")) != NULL) {
+        line++;
         char *comment = strchr(ptr, '#');
         if (comment != NULL) comment[0] = 0;
+
         len = strlen(ptr);
+        char *end_ptr = ptr + len - 1;
+        while (end_ptr[0] == ' ' || end_ptr[0] == '\t') {
+            end_ptr[0] = 0;
+            end_ptr--;
+        }
+        len = strlen(ptr);
+        if (len == 0) continue;
+
         if (ptr[0] == '[') {
             if (ptr[len - 1] != ']') goto err;
-            strncpy(tmp_config[i].name, ptr + 1, len - 2);
+            ptr++;
+            int l = 0;
+            if (strncmp(ptr, "host", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
+                ptr += 4;
+                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);
                 i++;
+                section = 'h';
+            } else if (strncmp(ptr, "cert", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
+                ptr += 4;
+                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);
+                j++;
+                section = 'c';
+            } else {
+                goto err;
+            }
             continue;
-        } else if (i == 0) {
-            if (len > 12 && strncmp(ptr, "certificate", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
-                source = ptr + 11;
-                target = cert_file;
-            } else if (len > 12 && strncmp(ptr, "private_key", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
-                source = ptr + 11;
-                target = key_file;
-            } else if (len > 10 && strncmp(ptr, "geoip_dir", 9) == 0 && (ptr[9] == ' ' || ptr[9] == '\t')) {
+        } else if (section == 0) {
+            if (len > 10 && strncmp(ptr, "geoip_dir", 9) == 0 && (ptr[9] == ' ' || ptr[9] == '\t')) {
                 source = ptr + 9;
                 target = geoip_dir;
             } else if (len > 11 && strncmp(ptr, "dns_server", 10) == 0 && (ptr[10] == ' ' || ptr[10] == '\t')) {
                 source = ptr + 10;
                 target = dns_server;
-            }
             } else {
-            host_config *hc = &tmp_config[i - 1];
+                goto err;
+            }
+        } else if (section == 'c') {
+            cert_config *cc = &tmp_config->certs[j - 1];
+            if (len > 12 && strncmp(ptr, "certificate", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
+                source = ptr + 11;
+                target = cc->full_chain;
+            } else if (len > 12 && strncmp(ptr, "private_key", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
+                source = ptr + 11;
+                target = cc->priv_key;
+            } else {
+                goto err;
+            }
+        } else if (section == 'h') {
+            host_config *hc = &tmp_config->hosts[i - 1];
             if (len > 8 && strncmp(ptr, "webroot", 7) == 0 && (ptr[7] == ' ' || ptr[7] == '\t')) {
                 source = ptr + 7;
                 target = hc->local.webroot;
@@ -103,6 +156,9 @@ int config_load(const char *filename) {
                 } else {
                     hc->type = CONFIG_TYPE_LOCAL;
                 }
+            } else if (len > 5 && strncmp(ptr, "cert", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
+                source = ptr + 4;
+                target = hc->cert_name;
             } else if (len > 9 && strncmp(ptr, "dir_mode", 8) == 0 && (ptr[8] == ' ' || ptr[8] == '\t')) {
                 source = ptr + 8;
                 target = NULL;
@@ -145,49 +201,66 @@ int config_load(const char *filename) {
                     hc->rev_proxy.enc = 1;
                 }
                 continue;
+            } else {
+                goto err;
             }
+        } else {
+            goto err;
         }
-        char *end_ptr = source + strlen(source) - 1;
+
         while (source[0] == ' ' || source[0] == '\t') source++;
-        while (end_ptr[0] == ' ' || end_ptr[0] == '\t') end_ptr--;
-        if (end_ptr <= source) {
+        if (strlen(source) == 0) {
             err:
-            free(conf);
             free(tmp_config);
-            fprintf(stderr, ERR_STR "Unable to parse config file" CLR_STR "\n");
+            critical("Unable to parse config file (line %i)", line);
             return -2;
         }
-        end_ptr[1] = 0;
+
         if (target != NULL) {
             strcpy(target, source);
         } else if (mode == 1) {
             if (strcmp(source, "forbidden") == 0) {
-                tmp_config[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
+                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
             } else if (strcmp(source, "info") == 0) {
-                tmp_config[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
+                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
             } else if (strcmp(source, "list") == 0) {
-                tmp_config[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
+                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
             } else {
                 goto err;
             }
         } else if (mode == 2) {
-            tmp_config[i - 1].rev_proxy.port = (unsigned short) strtoul(source, NULL, 10);
+            tmp_config->hosts[i - 1].rev_proxy.port = (unsigned short) strtoul(source, NULL, 10);
         }
     }
-    free(conf);
 
-    for (int j = 0; j < i; j++) {
-        if (tmp_config[j].type == CONFIG_TYPE_LOCAL) {
-            char *webroot = tmp_config[j].local.webroot;
+    for (int k = 0; k < i; k++) {
+        host_config *hc = &tmp_config->hosts[k];
+        if (hc->type == CONFIG_TYPE_LOCAL) {
+            char *webroot = tmp_config->hosts[k].local.webroot;
             if (webroot[strlen(webroot) - 1] == '/') {
                 webroot[strlen(webroot) - 1] = 0;
             }
         }
+        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) {
+                hc->cert = m;
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            err2:
+            free(tmp_config);
+            critical("Unable to parse config file");
+            return -2;
+        }
     }
 
-    int shm_id = shmget(SHM_KEY_CONFIG, 0, 0);
+    int shm_id = shmget(CONFIG_SHM_KEY, 0, 0);
     if (shm_id < 0) {
-        fprintf(stderr, ERR_STR "Unable to get shared memory id: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to get config shared memory id");
         shmdt(config);
         return -3;
     }
@@ -195,10 +268,10 @@ int config_load(const char *filename) {
     void *shm_rw = shmat(shm_id, NULL, 0);
     if (shm_rw == (void *) -1) {
         free(tmp_config);
-        fprintf(stderr, ERR_STR "Unable to attach shared memory (rw): %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to attach config shared memory (rw)");
         return -4;
     }
-    memcpy(shm_rw, tmp_config, MAX_HOST_CONFIG * sizeof(host_config));
+    memcpy(shm_rw, tmp_config, sizeof(t_config));
     free(tmp_config);
     shmdt(shm_rw);
     return 0;

src/lib/config.h

@@ -0,0 +1,65 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Configuration file loader (header file)
+ * @file src/lib/config.h
+ * @author Lorenz Stechauner
+ * @date 2021-01-05
+ */
+
+#ifndef SESIMOS_CONFIG_H
+#define SESIMOS_CONFIG_H
+
+#include "uri.h"
+
+#define CONFIG_SHM_KEY 255642
+#define CONFIG_MAX_HOST_CONFIG 64
+#define CONFIG_MAX_CERT_CONFIG 64
+
+#define CONFIG_TYPE_UNSET 0
+#define CONFIG_TYPE_LOCAL 1
+#define CONFIG_TYPE_REVERSE_PROXY 2
+
+#ifndef DEFAULT_CONFIG_FILE
+#   define DEFAULT_CONFIG_FILE "/etc/sesimos/server.conf"
+#endif
+
+
+typedef struct {
+    int type;
+    char name[256];
+    char cert_name[256];
+    int cert;
+    union {
+        struct {
+            char hostname[256];
+            unsigned short port;
+            unsigned char enc:1;
+        } rev_proxy;
+        struct {
+            char webroot[256];
+            unsigned char dir_mode:2;
+        } local;
+    };
+} host_config;
+
+typedef struct {
+    char name[256];
+    char full_chain[256];
+    char priv_key[256];
+} cert_config;
+
+typedef struct {
+    host_config hosts[CONFIG_MAX_HOST_CONFIG];
+    cert_config certs[CONFIG_MAX_CERT_CONFIG];
+} t_config;
+
+extern t_config *config;
+extern char geoip_dir[256], dns_server[256];
+
+int config_init(void);
+
+int config_load(const char *filename);
+
+int config_unload(void);
+
+#endif //SESIMOS_CONFIG_H

src/lib/fastcgi.c

@@ -1,11 +1,21 @@
 /**
- * Necronda Web Server
- * FastCGI interface implementation
- * src/fastcgi.c
- * Lorenz Stechauner, 2020-12-26
+ * sesimos - secure, simple, modern web server
+ * @brief FastCGI interface implementation
+ * @file src/lib/fastcgi.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-26
  */
 
 #include "fastcgi.h"
+#include "utils.h"
+#include "compress.h"
+#include "../server.h"
+#include "../logger.h"
+
+#include <sys/un.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <string.h>
 
 
 char *fastcgi_add_param(char *buf, const char *key, const char *value) {
@@ -35,36 +45,43 @@ char *fastcgi_add_param(char *buf, const char *key, const char *value) {
         ptr += 4;
     }
 
-    memcpy(ptr, key, key_len);
+    strcpy(ptr, key);
     ptr += key_len;
-    memcpy(ptr, value, val_len);
+    strcpy(ptr, value);
     ptr += val_len;
 
     return ptr;
 }
 
-int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_num, const sock *client,
-                 const http_req *req, const http_uri *uri) {
+int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client, 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;
     } else {
         req_id |= req_num & 0xF;
     }
+    conn->mode = mode;
     conn->req_id = req_id;
     conn->out_buf = NULL;
     conn->out_off = 0;
+    conn->webroot = uri->webroot;
 
-    int php_fpm = socket(AF_UNIX, SOCK_STREAM, 0);
-    if (php_fpm < 0) {
-        print(ERR_STR "Unable to create unix socket: %s" CLR_STR, strerror(errno));
+    int fcgi_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fcgi_sock < 0) {
+        error("Unable to create unix socket");
         return -1;
     }
-    conn->socket = php_fpm;
+    conn->socket = fcgi_sock;
 
-    struct sockaddr_un php_fpm_addr = {AF_UNIX, PHP_FPM_SOCKET};
-    if (connect(conn->socket, (struct sockaddr *) &php_fpm_addr, sizeof(php_fpm_addr)) < 0) {
-        print(ERR_STR "Unable to connect to unix socket of PHP-FPM: %s" CLR_STR, strerror(errno));
+    struct sockaddr_un sock_addr = {AF_UNIX};
+    if (conn->mode == FASTCGI_SESIMOS) {
+        snprintf(sock_addr.sun_path, sizeof(sock_addr.sun_path) - 1, "%s", SESIMOS_BACKEND_SOCKET);
+    } else if (conn->mode == FASTCGI_PHP) {
+        snprintf(sock_addr.sun_path, sizeof(sock_addr.sun_path) - 1, "%s", PHP_FPM_SOCKET);
+    }
+
+    if (connect(conn->socket, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0) {
+        error("Unable to connect to unix socket of FastCGI socket");
         return -1;
     }
 
@@ -84,7 +101,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
             {.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 PHP-FPM: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
@@ -115,8 +132,8 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     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_HOST", client_host_str != NULL ? client_host_str : client_addr_str);
+    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_ADDR", conn->ctx->addr);
+    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_HOST", conn->ctx->host[0] != 0 ? conn->ctx->host : conn->ctx->addr);
     //param_ptr = fastcgi_add_param(param_ptr, "REMOTE_IDENT", "");
     //param_ptr = fastcgi_add_param(param_ptr, "REMOTE_USER", "");
 
@@ -135,19 +152,21 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     param_ptr = fastcgi_add_param(param_ptr, "PATH_INFO", buf0);
 
     //param_ptr = fastcgi_add_param(param_ptr, "AUTH_TYPE", "");
-    char *content_length = http_get_header_field(&req->hdr, "Content-Length");
+    const char *content_length = http_get_header_field(&req->hdr, "Content-Length");
     param_ptr = fastcgi_add_param(param_ptr, "CONTENT_LENGTH", content_length != NULL ? content_length : "");
-    char *content_type = http_get_header_field(&req->hdr, "Content-Type");
+    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) {
-        param_ptr = fastcgi_add_param(param_ptr, "REMOTE_INFO", client_geoip);
+    if (conn->ctx->geoip[0] != 0) {
+        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];
+        const char *name = http_field_get_name(f);
         char *ptr = buf0;
         ptr += sprintf(ptr, "HTTP_");
-        for (int j = 0; j < strlen(req->hdr.fields[i][0]); j++, ptr++) {
-            char ch = req->hdr.fields[i][0][j];
+        for (int j = 0; j < strlen(name); j++, ptr++) {
+            char ch = name[j];
             if ((ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')) {
                 ch = ch;
             } else if (ch >= 'a' && ch <= 'z') {
@@ -158,7 +177,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
             ptr[0] = ch;
             ptr[1] = 0;
         }
-        param_ptr = fastcgi_add_param(param_ptr, buf0, req->hdr.fields[i][1]);
+        param_ptr = fastcgi_add_param(param_ptr, buf0, http_field_get_value(f));
     }
 
     unsigned short param_len = param_ptr - param_buf - sizeof(header);
@@ -167,7 +186,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     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 PHP-FPM: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
@@ -175,7 +194,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     header.contentLengthB1 = 0;
     header.contentLengthB0 = 0;
     if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) {
-        print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
@@ -195,23 +214,24 @@ int fastcgi_close_stdin(fastcgi_conn *conn) {
     };
 
     if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) {
-        print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+        error("Unable to send to FastCGI socket");
         return -2;
     }
 
     return 0;
 }
 
-int fastcgi_php_error(const char *msg, int msg_len, char *err_msg) {
+int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, char *err_msg) {
     char *msg_str = malloc(msg_len + 1);
     char *ptr0 = msg_str;
-    strncpy(msg_str, msg, msg_len);
+    memcpy(msg_str, msg, msg_len);
+    msg_str[msg_len] = 0;
     char *ptr1 = NULL;
     int len;
     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) {
@@ -225,16 +245,16 @@ int fastcgi_php_error(const char *msg, int msg_len, char *err_msg) {
         }
 
         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;
         }
 
@@ -247,9 +267,9 @@ int fastcgi_php_error(const char *msg, int msg_len, char *err_msg) {
             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, msg_type != 0 ? CLR_STR : "");
+            logmsgf(msg_type, "%.*s", len2, ptr2);
             if (msg_type == 2 && ptr2 == ptr0) {
-                sprintf(err_msg, "%.*s", len2, ptr2);
+                strcpy_rem_webroot(err_msg, ptr2, len2, conn->webroot);
                 err = 1;
             }
             if (ptr3 == NULL) {
@@ -272,20 +292,20 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
     FCGI_Header header;
     char *content;
     unsigned short content_len, req_id;
-    int ret;
+    long ret;
     int err = 0;
 
     while (1) {
         ret = recv(conn->socket, &header, sizeof(header), 0);
         if (ret < 0) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM: %s" CLR_STR, strerror(errno));
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            error("Unable to receive from FastCGI socket");
             return 1;
         } else if (ret != sizeof(header)) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            error("Unable to receive from FastCGI socket");
             return 1;
         }
         req_id = (header.requestIdB1 << 8) | header.requestIdB0;
@@ -293,15 +313,15 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
         content = malloc(content_len + header.paddingLength);
         ret = recv(conn->socket, content, content_len + header.paddingLength, 0);
         if (ret < 0) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM: %s" CLR_STR, strerror(errno));
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            error("Unable to receive from FastCGI socket");
             free(content);
             return 1;
         } else if (ret != (content_len + header.paddingLength)) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            error("Unable to receive from FastCGI socket");
             free(content);
             return 1;
         }
@@ -315,21 +335,24 @@ 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 "Script 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;
             free(content);
             return 1;
         } else if (header.type == FCGI_STDERR) {
-            err = err || fastcgi_php_error(content, content_len, err_msg);
+            // TODO implement Sesimos backend error handling
+            if (conn->mode == FASTCGI_PHP) {
+                err = err || fastcgi_php_error(conn, content, content_len, 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);
@@ -346,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;
         }
     }
@@ -361,12 +384,12 @@ 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;
         }
 
-        ret = http_parse_header_field(&res->hdr, ptr, pos0);
-        if (ret != 0) return ret;
+        ret = http_parse_header_field(&res->hdr, ptr, pos0, 0);
+        if (ret != 0) return (int) ret;
         if (pos0[2] == '\r' && pos0[3] == '\n') {
             return 0;
         }
@@ -378,7 +401,7 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
 
 int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
     FCGI_Header header;
-    int ret;
+    long ret;
     char buf0[256];
     int len;
     char *content, *ptr;
@@ -386,15 +409,18 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
     char comp_out[4096];
     int finish_comp = 0;
 
-    z_stream strm;
-    if (flags & FASTCGI_COMPRESS) {
-        int level = NECRONDA_ZLIB_LEVEL;
-        strm.zalloc = Z_NULL;
-        strm.zfree = Z_NULL;
-        strm.opaque = Z_NULL;
-        if (deflateInit(&strm, level) != Z_OK) {
-            print(ERR_STR "Unable to init deflate: %s" CLR_STR, strerror(errno));
-            flags &= !FASTCGI_COMPRESS;
+    compress_ctx comp_ctx;
+    if (flags & FASTCGI_COMPRESS_BR) {
+        flags &= ~FASTCGI_COMPRESS_GZ;
+        if (compress_init(&comp_ctx, COMPRESS_BR) != 0) {
+            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) {
+            error("Unable to init gzip");
+            flags &= ~FASTCGI_COMPRESS_GZ;
         }
     }
 
@@ -408,36 +434,38 @@ 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 PHP-FPM: %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 PHP-FPM" CLR_STR);
+            error("Unable to receive from FastCGI socket: received len (%li) != header len (%li)", ret, sizeof(header));
             return -1;
         }
+
         req_id = (header.requestIdB1 << 8) | header.requestIdB0;
         content_len = (header.contentLengthB1 << 8) | header.contentLengthB0;
         content = malloc(content_len + header.paddingLength);
         ptr = content;
-        ret = recv(conn->socket, content, content_len + header.paddingLength, 0);
+
+        long rcv_len = 0;
+        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 PHP-FPM: %s" CLR_STR, strerror(errno));
-            free(content);
-            return -1;
-        } else if (ret != (content_len + header.paddingLength)) {
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
+                error("Unable to receive from FastCGI socket");
                 free(content);
                 return -1;
             }
+            rcv_len += ret;
+        }
 
         if (header.type == FCGI_END_REQUEST) {
             FCGI_EndRequestBody *body = (FCGI_EndRequestBody *) content;
             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 "Script 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;
@@ -448,7 +476,7 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
                 content_len = 0;
                 goto out;
                 finish:
-                deflateEnd(&strm);
+                compress_free(&comp_ctx);
             }
 
             if (flags & FASTCGI_CHUNKED) {
@@ -457,22 +485,22 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
 
             return 0;
         } else if (header.type == FCGI_STDERR) {
-            fastcgi_php_error(content, content_len, buf0);
-        } else if (header.type == FCGI_STDOUT) {
-            out:
-            if (flags & FASTCGI_COMPRESS) {
-                strm.avail_in = content_len;
-                strm.next_in = (unsigned char *) ptr;
+            // TODO implement Sesimos backend error handling
+            if (conn->mode == FASTCGI_PHP) {
+                fastcgi_php_error(conn, content, content_len, buf0);
             }
+        } else if (header.type == FCGI_STDOUT) {
+            unsigned long avail_in, avail_out;
+            out:
+            avail_in = content_len;
+            char *next_in = ptr;
             do {
                 int buf_len = content_len;
                 if (flags & FASTCGI_COMPRESS) {
-                    strm.avail_out = sizeof(comp_out);
-                    strm.next_out = (unsigned char *) comp_out;
-                    deflate(&strm, finish_comp ? Z_FINISH : Z_NO_FLUSH);
-                    strm.avail_in = 0;
+                    avail_out = sizeof(comp_out);
+                    compress_compress(&comp_ctx, next_in + content_len - avail_in, &avail_in, comp_out, &avail_out, finish_comp);
                     ptr = comp_out;
-                    buf_len = (int) (sizeof(comp_out) - strm.avail_out);
+                    buf_len = (int) (sizeof(comp_out) - avail_out);
                 }
                 if (buf_len != 0) {
                     len = sprintf(buf0, "%X\r\n", buf_len);
@@ -480,10 +508,75 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
                     sock_send(client, ptr, buf_len, 0);
                     if (flags & FASTCGI_CHUNKED) sock_send(client, "\r\n", 2, 0);
                 }
-            } while ((flags & FASTCGI_COMPRESS) && strm.avail_out == 0);
+            } 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) {
+    FCGI_Header header;
+    long ret;
+    char buf0[256];
+    char *content, *ptr = buf;
+    unsigned short req_id, content_len;
+
+    if (conn->out_buf != NULL && conn->out_len > conn->out_off) {
+        ptr += snprintf(ptr, len, "%.*s", conn->out_len - conn->out_off, conn->out_buf + conn->out_off);
+    }
+
+    while (1) {
+        ret = recv(conn->socket, &header, sizeof(header), 0);
+        if (ret < 0) {
+            error("Unable to receive from FastCGI socket");
+            return -1;
+        } else if (ret != sizeof(header)) {
+            error("Unable to receive from FastCGI socket: received len (%li) != header len (%li)", ret, sizeof(header));
+            return -1;
+        }
+
+        req_id = (header.requestIdB1 << 8) | header.requestIdB0;
+        content_len = (header.contentLengthB1 << 8) | header.contentLengthB0;
+        content = malloc(content_len + header.paddingLength);
+
+        long rcv_len = 0;
+        while (rcv_len < content_len + header.paddingLength) {
+            ret = recv(conn->socket, content + rcv_len, content_len + header.paddingLength - rcv_len, 0);
+            if (ret < 0) {
+                error("Unable to receive from FastCGI socket");
+                free(content);
+                return -1;
+            }
+            rcv_len += ret;
+        }
+
+        if (header.type == FCGI_END_REQUEST) {
+            FCGI_EndRequestBody *body = (FCGI_EndRequestBody *) content;
+            int app_status = (body->appStatusB3 << 24) | (body->appStatusB2 << 16) | (body->appStatusB1 << 8) |
+                             body->appStatusB0;
+            if (body->protocolStatus != FCGI_REQUEST_COMPLETE) {
+                error("FastCGI protocol error: %i", body->protocolStatus);
+            }
+            if (app_status != 0) {
+                error("FastCGI app terminated with exit code %i", app_status);
+            }
+            close(conn->socket);
+            conn->socket = 0;
+            free(content);
+
+            return 0;
+        } else if (header.type == FCGI_STDERR) {
+            // TODO implement Sesimos backend error handling
+            if (conn->mode == FASTCGI_PHP) {
+                fastcgi_php_error(conn, content, content_len, buf0);
+            }
+        } else if (header.type == FCGI_STDOUT) {
+            ptr += snprintf(ptr, len - (ptr - buf), "%.*s", content_len, content);
+        } else {
+            error("Unknown FastCGI type: %i", header.type);
         }
         free(content);
     }
@@ -504,29 +597,40 @@ int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len) {
             .reserved = 0
     };
 
-    if (client->buf != NULL && client->buf_len - client->buf_off > 0) {
-        ret = (int) (client->buf_len - client->buf_off);
-        memcpy(buf, client->buf + client->buf_off, ret);
-        goto send;
-    }
-
     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;
         }
 
-        send:
         rcv_len += ret;
         header.contentLengthB1 = (ret >> 8) & 0xFF;
         header.contentLengthB0 = ret & 0xFF;
         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 PHP-FPM: %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) {
+    long ret;
+    unsigned long next_len;
+
+    while (1) {
+        ret = sock_get_chunk_header(client);
+        if (ret < 0) return (int) ret;
+
+        next_len = ret;
+        if (next_len <= 0) break;
+
+        ret = fastcgi_receive(conn, client, next_len);
+        if (ret < 0) return (int) ret;
+    }
+
+    return 0;
+}

src/lib/fastcgi.h

@@ -0,0 +1,62 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief FastCGI interface implementation (header file)
+ * @file src/lib/fastcgi.h
+ * @author Lorenz Stechauner
+ * @date 2020-12-26
+ */
+
+#ifndef SESIMOS_FASTCGI_H
+#define SESIMOS_FASTCGI_H
+
+#include "include/fastcgi.h"
+#include "http.h"
+#include "uri.h"
+#include "../client.h"
+
+#define FASTCGI_CHUNKED 1
+#define FASTCGI_COMPRESS_GZ 2
+#define FASTCGI_COMPRESS_BR 4
+#define FASTCGI_COMPRESS 6
+#define FASTCGI_COMPRESS_HOLD 8
+
+#define FASTCGI_PHP 1
+#define FASTCGI_SESIMOS 2
+
+#ifndef PHP_FPM_SOCKET
+#   define PHP_FPM_SOCKET "/var/run/php-fpm/php-fpm.sock"
+#endif
+
+#define SESIMOS_BACKEND_SOCKET "/var/run/sesimos/backend.sock"
+
+typedef struct {
+    int mode;
+    int socket;
+    unsigned short req_id;
+    char *out_buf;
+    const char *webroot;
+    unsigned short out_len;
+    unsigned short out_off;
+    client_ctx_t *ctx;
+} fastcgi_conn;
+
+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,
+                 const http_req *req, const http_uri *uri);
+
+int fastcgi_close_stdin(fastcgi_conn *conn);
+
+int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, char *err_msg);
+
+int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg);
+
+int fastcgi_send(fastcgi_conn *conn, sock *client, int flags);
+
+int fastcgi_dump(fastcgi_conn *conn, char *buf, long len);
+
+int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len);
+
+int fastcgi_receive_chunked(fastcgi_conn *conn, sock *client);
+
+#endif //SESIMOS_FASTCGI_H

src/lib/geoip.c

@@ -0,0 +1,71 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief MaxMind GeoIP Database interface
+ * @file src/lib/geoip.c
+ * @author Lorenz Stechauner
+ * @date 2021-05-04
+ */
+
+#include "geoip.h"
+
+
+MMDB_entry_data_list_s *mmdb_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, "{");
+            break;
+        case MMDB_DATA_TYPE_ARRAY:
+            *str_off += sprintf(str + *str_off, "[");
+            break;
+        case MMDB_DATA_TYPE_UTF8_STRING:
+            *str_off += sprintf(str + *str_off, "\"%.*s\"", list->entry_data.data_size, list->entry_data.utf8_string);
+            break;
+        case MMDB_DATA_TYPE_UINT16:
+            *str_off += sprintf(str + *str_off, "%u", list->entry_data.uint16);
+            break;
+        case MMDB_DATA_TYPE_UINT32:
+            *str_off += sprintf(str + *str_off, "%u", list->entry_data.uint32);
+            break;
+        case MMDB_DATA_TYPE_UINT64:
+            *str_off += sprintf(str + *str_off, "%lu", list->entry_data.uint64);
+            break;
+        case MMDB_DATA_TYPE_UINT128:
+            *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);
+            break;
+        case MMDB_DATA_TYPE_BOOLEAN:
+            *str_off += sprintf(str + *str_off, "%s", list->entry_data.boolean ? "true" : "false");
+            break;
+        case MMDB_DATA_TYPE_FLOAT:
+            *str_off += sprintf(str + *str_off, "%f", list->entry_data.float_value);
+            break;
+        case MMDB_DATA_TYPE_DOUBLE:
+            *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) {
+        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);
+        if (list->entry_data.type == MMDB_DATA_TYPE_MAP) {
+            stat = !stat;
+            if (stat) {
+                i--;
+                *str_off += sprintf(str + *str_off, ":");
+                continue;
+            }
+        }
+        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, "]");
+    }
+    return next;
+}

src/lib/geoip.h

@@ -0,0 +1,19 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief MaxMind GeoIP Database interface (header file)
+ * @file src/lib/geoip.h
+ * @author Lorenz Stechauner
+ * @date 2021-05-04
+ */
+
+
+#ifndef SESIMOS_GEOIP_H
+#define SESIMOS_GEOIP_H
+
+#include <maxminddb.h>
+
+#define GEOIP_MAX_SIZE 8192
+
+MMDB_entry_data_list_s *mmdb_json(MMDB_entry_data_list_s *list, char *str, long *str_off, long str_len);
+
+#endif //SESIMOS_GEOIP_H

src/lib/http.c

@@ -0,0 +1,451 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief HTTP implementation
+ * @file src/lib/http.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-09
+ */
+
+#include "../logger.h"
+#include "http.h"
+#include "utils.h"
+#include "compress.h"
+
+#include <string.h>
+
+
+void http_to_camel_case(char *str, int mode) {
+    if (mode == HTTP_PRESERVE)
+        return;
+
+    char ch, last = '-';
+    for (int i = 0; i < strlen(str); i++) {
+        ch = str[i];
+        if (mode == HTTP_CAMEL && last == '-' && ch >= 'a' && ch <= 'z') {
+            str[i] = (char) ((int) ch & 0x5F);
+        } else if (mode == HTTP_LOWER && ch >= 'A' && ch <= 'Z') {
+            str[i] = (char) ((int) ch | 0x20);
+        }
+        last = str[i];
+    }
+}
+
+const char *http_field_get_name(const http_field *field) {
+    if (field->type == HTTP_FIELD_NORMAL) {
+        return field->normal.name;
+    } else if (field->type == HTTP_FIELD_EX_VALUE) {
+        return field->ex_value.name;
+    } else if (field->type == HTTP_FIELD_EX_NAME) {
+        return field->ex_name.name;
+    }
+    return NULL;
+}
+
+const char *http_field_get_value(const http_field *field) {
+    if (field->type == HTTP_FIELD_NORMAL) {
+        return field->normal.value;
+    } else if (field->type == HTTP_FIELD_EX_VALUE) {
+        return field->ex_value.value;
+    } else if (field->type == HTTP_FIELD_EX_NAME) {
+        return field->ex_name.value;
+    }
+    return NULL;
+}
+
+void http_free_field(http_field *f) {
+    if (f->type == HTTP_FIELD_NORMAL) {
+        f->normal.name[0] = 0;
+        f->normal.value[0] = 0;
+    } else if (f->type == HTTP_FIELD_EX_VALUE) {
+        f->ex_value.name[0] = 0;
+        free(f->ex_value.value);
+        f->ex_value.value = NULL;
+    } else if (f->type == HTTP_FIELD_EX_NAME) {
+        free(f->ex_name.name);
+        free(f->ex_name.value);
+        f->ex_name.name = NULL;
+        f->ex_name.value = NULL;
+    }
+}
+
+void http_free_hdr(http_hdr *hdr) {
+    for (int i = 0; i < hdr->field_num; i++) {
+        http_free_field(&hdr->fields[i]);
+    }
+    hdr->field_num = 0;
+    hdr->last_field_num = -1;
+}
+
+void http_free_req(http_req *req) {
+    if (req->uri != NULL) free(req->uri);
+    req->uri = NULL;
+    http_free_hdr(&req->hdr);
+}
+
+void http_free_res(http_res *res) {
+    http_free_hdr(&res->hdr);
+}
+
+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) {
+        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) {
+            error("Unable to parse header");
+            return 3;
+        }
+        http_field *f = &hdr->fields[(int) hdr->last_field_num];
+
+        str_trim_lws(&pos1, &pos2);
+        http_append_to_header_field(f, pos1, pos2 - pos1);
+
+        return 0;
+    }
+
+    pos1 = memchr(buf, ':', end_ptr - buf);
+    if (pos1 == NULL) {
+        error("Unable to parse header");
+        return 3;
+    }
+    long len1 = pos1 - buf;
+
+    pos1++;
+    str_trim_lws(&pos1, &pos2);
+    long len2 = pos2 - pos1;
+
+    char field_num = hdr->field_num;
+    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) {
+            error("Unable to parse header: Too many header fields");
+            return 3;
+        }
+    } else {
+        field_num = (char) found;
+        http_append_to_header_field(&hdr->fields[found], ", ", 2);
+        http_append_to_header_field(&hdr->fields[found], pos1, len2);
+    }
+
+    hdr->last_field_num = (char) field_num;
+    return 0;
+}
+
+int http_receive_request(sock *client, http_req *req) {
+    long rcv_len, len;
+    char buf[CLIENT_MAX_HEADER_SIZE];
+    char *ptr, *pos0 = buf, *pos1, *pos2;
+    memset(buf, 0, sizeof(buf));
+    memset(req->method, 0, sizeof(req->method));
+    memset(req->version, 0, sizeof(req->version));
+    req->uri = NULL;
+    req->hdr.field_num = 0;
+    req->hdr.last_field_num = -1;
+
+    while (1) {
+        rcv_len = sock_recv(client, buf, CLIENT_MAX_HEADER_SIZE, MSG_PEEK);
+        if (rcv_len <= 0) {
+            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) {
+            error("Unable to parse http header: End of header not found");
+            return 5;
+        } else {
+            rcv_len = sock_recv(client, buf, header_len, 0);
+        }
+
+        for (int i = 0; i < header_len; i++) {
+            if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
+                error("Unable to parse http header: Header contains illegal characters");
+                return 4;
+            }
+        }
+
+        ptr = buf;
+        while (header_len > (ptr - buf + 2)) {
+            pos0 = strstr(ptr, "\r\n");
+            if (pos0 == NULL) {
+                error("Unable to parse http header: Invalid header format");
+                return 1;
+            }
+
+            if (req->version[0] == 0) {
+                pos1 = (char *) memchr(ptr, ' ', rcv_len - (ptr - buf)) + 1;
+                if (pos1 == NULL) goto err_hdr_fmt;
+
+                if (pos1 - ptr - 1 >= sizeof(req->method)) {
+                    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') {
+                        error("Unable to parse http header: Invalid method");
+                        return 2;
+                    }
+                }
+                snprintf(req->method, sizeof(req->method), "%.*s", (int) (pos1 - ptr - 1), ptr);
+
+                pos2 = (char *) memchr(pos1, ' ', rcv_len - (pos1 - buf)) + 1;
+                if (pos2 == NULL) {
+                    err_hdr_fmt:
+                    error("Unable to parse http header: Invalid header format");
+                    return 1;
+                }
+
+                if (memcmp(pos2, "HTTP/", 5) != 0 || memcmp(pos2 + 8, "\r\n", 2) != 0) {
+                    error("Unable to parse http header: Invalid version");
+                    return 3;
+                }
+
+                len = pos2 - pos1 - 1;
+                req->uri = malloc(len + 1);
+                sprintf(req->uri, "%.*s", (int) len, pos1);
+                sprintf(req->version, "%.3s", pos2 + 5);
+            } else {
+                int ret = http_parse_header_field(&req->hdr, ptr, pos0, HTTP_MERGE_FIELDS);
+                if (ret != 0) return ret;
+            }
+            ptr = pos0 + 2;
+        }
+        if (pos0[2] == '\r' && pos0[3] == '\n') {
+            break;
+        }
+    }
+
+    return 0;
+}
+
+const char *http_get_header_field(const http_hdr *hdr, const char *field_name) {
+    return http_get_header_field_len(hdr, field_name, strlen(field_name));
+}
+
+const char *http_get_header_field_len(const http_hdr *hdr, const char *field_name, unsigned long len) {
+    int num = http_get_header_field_num_len(hdr, field_name, len);
+    return (num >= 0 && num < HTTP_MAX_HEADER_FIELD_NUM) ? http_field_get_value(&hdr->fields[num]) : NULL;
+}
+
+int http_get_header_field_num(const http_hdr *hdr, const char *field_name) {
+    return http_get_header_field_num_len(hdr, field_name, strlen(field_name));
+}
+
+int http_get_header_field_num_len(const http_hdr *hdr, const char *field_name, unsigned long len) {
+    char field_name_1[256], field_name_2[256];
+    memcpy(field_name_1, field_name, len);
+    field_name_1[len] = 0;
+    http_to_camel_case(field_name_1, HTTP_LOWER);
+
+    for (int i = 0; i < hdr->field_num; i++) {
+        strcpy(field_name_2, http_field_get_name(&hdr->fields[i]));
+        http_to_camel_case(field_name_2, HTTP_LOWER);
+
+        if (strcmp(field_name_1, field_name_2) == 0)
+            return i;
+    }
+
+    return -1;
+}
+
+int http_add_header_field(http_hdr *hdr, const char *field_name, const char *field_value) {
+    return http_add_header_field_len(hdr, field_name, strlen(field_name), field_value, strlen(field_value));
+}
+
+int http_add_header_field_len(http_hdr *hdr, const char *name, unsigned long name_len, const char *value, unsigned long value_len) {
+    if (hdr->field_num >= HTTP_MAX_HEADER_FIELD_NUM)
+        return -1;
+
+    http_field *f = &hdr->fields[(int) hdr->field_num];
+
+    if (name_len < sizeof(f->normal.name) && value_len < sizeof(f->normal.value)) {
+        f->type = HTTP_FIELD_NORMAL;
+        memcpy(f->normal.name, name, name_len);
+        memcpy(f->normal.value, value, value_len);
+        f->normal.name[name_len] = 0;
+        f->normal.value[value_len] = 0;
+        http_to_camel_case(f->normal.name, HTTP_PRESERVE);
+    } else if (name_len < sizeof(f->ex_value.name)) {
+        f->type = HTTP_FIELD_EX_VALUE;
+        f->ex_value.value = malloc(value_len + 1);
+        memcpy(f->ex_value.name, name, name_len);
+        memcpy(f->ex_value.value, value, value_len);
+        f->ex_value.name[name_len] = 0;
+        f->ex_value.value[value_len] = 0;
+        http_to_camel_case(f->ex_value.name, HTTP_PRESERVE);
+    } else {
+        f->type = HTTP_FIELD_EX_NAME;
+        f->ex_name.name = malloc(name_len + 1);
+        f->ex_name.value = malloc(value_len + 1);
+        memcpy(f->ex_name.name, name, name_len);
+        memcpy(f->ex_name.value, value, value_len);
+        f->ex_name.name[name_len] = 0;
+        f->ex_name.value[value_len] = 0;
+        http_to_camel_case(f->ex_name.name, HTTP_PRESERVE);
+    }
+
+    hdr->field_num++;
+    return 0;
+}
+
+void http_append_to_header_field(http_field *field, const char *value, unsigned long len) {
+    if (field->type == HTTP_FIELD_NORMAL) {
+        unsigned long total_len = strlen(field->normal.value) + len + 1;
+        if (total_len < sizeof(field->normal.value)) {
+            strncat(field->normal.value, value, len);
+        } else {
+            field->type = HTTP_FIELD_EX_VALUE;
+            char *new = malloc(total_len);
+            strcpy(new, field->normal.value);
+            strncat(new, value, len);
+            field->ex_value.value = new;
+        }
+    } else if (field->type == HTTP_FIELD_EX_VALUE) {
+        field->ex_value.value = realloc(field->ex_value.value, strlen(field->ex_value.value) + len + 1);
+        strncat(field->ex_value.value, value, len);
+    } else if (field->type == HTTP_FIELD_EX_NAME) {
+        field->ex_name.value = realloc(field->ex_name.value, strlen(field->ex_name.value) + len + 1);
+        strncat(field->ex_name.value, value, len);
+    }
+}
+
+void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode) {
+    char field_name_1[256], field_name_2[256];
+    strcpy(field_name_1, field_name);
+    http_to_camel_case(field_name_1, HTTP_LOWER);
+
+    int i = 0;
+    int diff = 1;
+    if (mode == HTTP_REMOVE_LAST) {
+        i = hdr->field_num - 1;
+        diff = -1;
+    }
+    for (; i < hdr->field_num && i >= 0; i += diff) {
+        strcpy(field_name_2, http_field_get_name(&hdr->fields[i]));
+        http_to_camel_case(field_name_2, HTTP_LOWER);
+        if (strcmp(field_name_1, field_name_2) == 0) {
+            http_free_field(&hdr->fields[i]);
+            memmove(&hdr->fields[i], &hdr->fields[i + 1], sizeof(hdr->fields[0]) * (hdr->field_num - i));
+            hdr->field_num--;
+            if (mode == HTTP_REMOVE_ALL) {
+                i -= diff;
+            } else {
+                return;
+            }
+        }
+    }
+}
+
+int http_send_response(sock *client, http_res *res) {
+    char buf[CLIENT_MAX_HEADER_SIZE];
+    long off = sprintf(buf, "HTTP/%s %03i %s\r\n", res->version, res->status->code, res->status->msg);
+    for (int i = 0; i < res->hdr.field_num; i++) {
+        const http_field *f = &res->hdr.fields[i];
+        off += sprintf(buf + off, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
+    }
+    off += sprintf(buf + off, "\r\n");
+    if (sock_send(client, buf, off, 0) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+int http_send_request(sock *server, http_req *req) {
+    char buf[CLIENT_MAX_HEADER_SIZE];
+    long off = sprintf(buf, "%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];
+        off += sprintf(buf + off, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
+    }
+    off += sprintf(buf + off, "\r\n");
+    long ret = sock_send(server, buf, off, 0);
+    if (ret <= 0) {
+        return -1;
+    }
+    return 0;
+}
+
+const http_status *http_get_status(unsigned short status_code) {
+    for (int i = 0; i < http_statuses_size / sizeof(http_status); i++) {
+        if (http_statuses[i].code == status_code) {
+            return &http_statuses[i];
+        }
+    }
+    return NULL;
+}
+
+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++) {
+        if (http_status_messages[i].code == code) {
+            return &http_status_messages[i];
+        }
+    }
+    return NULL;
+}
+
+const char *http_get_status_color(const http_status *status) {
+    unsigned short code = status->code;
+    if (code >= 100 && code < 200) {
+        return HTTP_1XX_STR;
+    } else if ((code >= 200 && code < 300) || code == 304) {
+        return HTTP_2XX_STR;
+    } else if (code >= 300 && code < 400) {
+        return HTTP_3XX_STR;
+    } else if (code >= 400 && code < 500) {
+        return HTTP_4XX_STR;
+    } else if (code >= 500 && code < 600) {
+        return HTTP_5XX_STR;
+    }
+    return "";
+}
+
+char *http_format_date(time_t time, char *buf, size_t size) {
+    struct tm *timeinfo = gmtime(&time);
+    strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", timeinfo);
+    return buf;
+}
+
+char *http_get_date(char *buf, size_t size) {
+    time_t rawtime;
+    time(&rawtime);
+    return http_format_date(rawtime, buf, 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},
+            {"success", HTTP_COLOR_SUCCESS, http_success_icon, http_success_document},
+            {"warning", HTTP_COLOR_WARNING, http_warning_icon, http_warning_document},
+            {"error", HTTP_COLOR_ERROR, http_error_icon, http_error_document}
+    };
+    if (code >= 100 && code < 200) {
+        return &info[0];
+    } else if ((code >= 200 && code < 300) || code == 304) {
+        return &info[1];
+    } else if (code >= 300 && code < 400) {
+        return &info[2];
+    } else if (code >= 400 && code < 600) {
+        return &info[3];
+    }
+    return NULL;
+}
+
+int http_get_compression(const http_req *req, const http_res *res) {
+    const char *accept_encoding = http_get_header_field(&req->hdr, "Accept-Encoding");
+    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 (mime_is_compressible(content_type) && content_encoding == NULL && accept_encoding != NULL) {
+        if (strstr(accept_encoding, "br") != NULL) {
+            return COMPRESS_BR;
+        } else if (strstr(accept_encoding, "gzip") != NULL) {
+            return COMPRESS_GZ;
+        }
+    }
+    return 0;
+}

src/lib/http.h

@@ -0,0 +1,183 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief HTTP implementation (header file)
+ * @file src/lib/http.h
+ * @author Lorenz Stechauner
+ * @date 2020-12-09
+ */
+
+#ifndef SESIMOS_HTTP_H
+#define SESIMOS_HTTP_H
+
+#include "sock.h"
+
+#define HTTP_PRESERVE 0
+#define HTTP_LOWER 1
+#define HTTP_CAMEL 2
+
+#define HTTP_REMOVE_ONE 0
+#define HTTP_REMOVE_ALL 1
+#define HTTP_REMOVE_LAST 2
+
+#define HTTP_FIELD_NORMAL 0
+#define HTTP_FIELD_EX_VALUE 1
+#define HTTP_FIELD_EX_NAME 2
+
+#define HTTP_MERGE_FIELDS 1
+
+#define HTTP_1XX_STR "\x1B[1;32m"
+#define HTTP_2XX_STR "\x1B[1;32m"
+#define HTTP_3XX_STR "\x1B[1;33m"
+#define HTTP_4XX_STR "\x1B[1;31m"
+#define HTTP_5XX_STR "\x1B[1;31m"
+
+#define HTTP_COLOR_SUCCESS "#008000"
+#define HTTP_COLOR_INFO "#606060"
+#define HTTP_COLOR_WARNING "#E0C000"
+#define HTTP_COLOR_ERROR "#C00000"
+
+#define CLIENT_MAX_HEADER_SIZE 8192
+#define HTTP_MAX_HEADER_FIELD_NUM 64
+
+#ifndef SERVER_STR
+#   define SERVER_STR "Sesimos"
+#endif
+
+#ifndef SERVER_STR_HTML
+#   define SERVER_STR_HTML "Sesimos web server"
+#endif
+
+typedef struct {
+    unsigned short code;
+    char type[16];
+    char msg[64];
+} http_status;
+
+typedef struct {
+    unsigned short code;
+    const char *msg;
+} http_status_msg;
+
+typedef struct {
+    char mode[8];
+    char color[8];
+    const char *icon;
+    const char *doc;
+} http_doc_info;
+
+typedef struct {
+    char type;
+    union {
+        struct {
+            char name[64];
+            char value[192];
+        } normal;
+        struct {
+            char name[192];
+            char *value;
+        } ex_value;
+        struct {
+            char *name;
+            char *value;
+        } ex_name;
+    };
+} http_field;
+
+typedef struct {
+    char field_num;
+    char last_field_num;
+    http_field fields[HTTP_MAX_HEADER_FIELD_NUM];
+} http_hdr;
+
+typedef struct {
+    char method[16];
+    char *uri;
+    char version[4];
+    http_hdr hdr;
+} http_req;
+
+typedef struct {
+    const http_status *status;
+    char version[4];
+    http_hdr hdr;
+} http_res;
+
+typedef enum {
+    NONE, INTERNAL, CLIENT_REQ, SERVER_REQ, SERVER, SERVER_RES, CLIENT_RES
+} http_error_origin;
+
+typedef struct {
+    unsigned short status;
+    http_error_origin origin;
+    const char* ws_key;
+} http_status_ctx;
+
+extern const http_status http_statuses[];
+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_rev_proxy_document[];
+extern const char http_error_document[];
+extern const char http_error_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);
+
+const char *http_field_get_name(const http_field *field);
+
+const char *http_field_get_value(const http_field *field);
+
+void http_free_field(http_field *f);
+
+void http_free_hdr(http_hdr *hdr);
+
+void http_free_req(http_req *req);
+
+void http_free_res(http_res *res);
+
+int http_receive_request(sock *client, http_req *req);
+
+int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags);
+
+const char *http_get_header_field(const http_hdr *hdr, const char *field_name);
+
+const char *http_get_header_field_len(const http_hdr *hdr, const char *field_name, unsigned long len);
+
+int http_get_header_field_num(const http_hdr *hdr, const char *field_name);
+
+int http_get_header_field_num_len(const http_hdr *hdr, const char *field_name, unsigned long len);
+
+int http_add_header_field(http_hdr *hdr, const char *field_name, const char *field_value);
+
+int http_add_header_field_len(http_hdr *hdr, const char *name, unsigned long name_len, const char *value, unsigned long value_len);
+
+void http_append_to_header_field(http_field *field, const char *value, unsigned long len);
+
+void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode);
+
+int http_send_response(sock *client, http_res *res);
+
+int http_send_request(sock *server, http_req *req);
+
+const http_status *http_get_status(unsigned short status_code);
+
+const http_status_msg *http_get_error_msg(const http_status *status);
+
+const char *http_get_status_color(const http_status *status);
+
+char *http_format_date(time_t time, char *buf, size_t size);
+
+char *http_get_date(char *buf, size_t size);
+
+const http_doc_info *http_get_status_info(const http_status *status);
+
+int http_get_compression(const http_req *req, const http_res *res);
+
+#endif //SESIMOS_HTTP_H

src/lib/http_static.c

@@ -1,67 +1,16 @@
 /**
- * Necronda Web Server
- * HTTP implementation (header file)
- * src/net/http.h
- * Lorenz Stechauner, 2020-12-09
+ * sesimos - secure, simple, modern web server
+ * @brief HTTP static implementation
+ * @file src/lib/http_static.c
+ * @author Lorenz Stechauner
+ * @date 2021-05-03
  */
 
-#ifndef NECRONDA_SERVER_HTTP_H
-#define NECRONDA_SERVER_HTTP_H
-
-#define HTTP_PRESERVE 0
-#define HTTP_LOWER 1
-#define HTTP_CAMEL 2
-
-#define HTTP_REMOVE_ONE 0
-#define HTTP_REMOVE_ALL 1
-#define HTTP_REMOVE_LAST 2
-
-#define HTTP_COLOR_SUCCESS "#008000"
-#define HTTP_COLOR_INFO "#606060"
-#define HTTP_COLOR_WARNING "#E0C000"
-#define HTTP_COLOR_ERROR "#C00000"
-
-#include "sock.h"
-#include "utils.h"
+#include "../defs.h"
+#include "http.h"
 
 
-typedef struct {
-    unsigned short code;
-    char type[16];
-    char msg[32];
-} http_status;
-
-typedef struct {
-    unsigned short code;
-    const char *msg;
-} http_status_msg;
-
-typedef struct {
-    char mode[8];
-    char color[8];
-    const char *icon;
-    const char *doc;
-} http_doc_info;
-
-typedef struct {
-    char field_num;
-    char *fields[64][2];
-} http_hdr;
-
-typedef struct {
-    char method[16];
-    char *uri;
-    char version[3];
-    http_hdr hdr;
-} http_req;
-
-typedef struct {
-    const http_status *status;
-    char version[3];
-    http_hdr hdr;
-} http_res;
-
-static const http_status http_statuses[] = {
+const http_status http_statuses[] = {
         {100, "Informational", "Continue"},
         {101, "Informational", "Switching Protocols"},
 
@@ -109,7 +58,7 @@ static const http_status http_statuses[] = {
         {505, "Server Error",  "HTTP Version Not Supported"},
 };
 
-static const http_status_msg http_status_messages[] = {
+const http_status_msg http_status_messages[] = {
         {100, "The client SHOULD continue with its request."},
         {101, "The server understands and is willing to comply with the clients request, via the Upgrade message header field, for a change in the application protocol being used on this connection."},
 
@@ -156,7 +105,7 @@ static 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."}
 };
 
-static const char http_default_document[] =
+const char http_default_document[] =
         "<!DOCTYPE html>\n"
         "<html lang=\"en\">\n"
         "<head>\n"
@@ -169,20 +118,85 @@ static const char http_default_document[] =
         "\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 ";--color:var(--%4$s);}\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:1em;background-color:#FFFFFF;border: 1px solid var(--color);border-radius:4px;padding:1em;}\n"
-        "\t\th1,h2,h3,h4,h5,h6,h7{text-align:center;color:var(--color);font-weight:normal;}\n"
-        "\t\th1{font-size:3em;margin:0.125em 0 0.125em 0;}\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:#808080;font-size:0.75em;text-align:center;margin:2em 0 0.5em 0;}\n"
-        "\t\tdiv.footer a{color:#808080;}\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;}\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"
@@ -190,96 +204,102 @@ static const char http_default_document[] =
         "\t<main>\n"
         "\t\t<section>\n"
         "%3$s"
-        "\t\t\t<div class=\"footer\"><a href=\"https://%7$s/\">%7$s</a> - Necronda&nbsp;web&nbsp;server&nbsp;" NECRONDA_VERSION "</div>\n"
+        "%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";
 
-static const char http_error_document[] =
+const char http_rev_proxy_document[] =
+        "\t\t<section class=\"error-ctx\">\n"
+        "\t\t\t<div class=\"box%1$s\">\n"
+        "\t\t\t\t<div class=\"content\">\n"
+        "\t\t\t\t\t<span>Client</span>\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";
 
-static const char http_error_icon[] =
+const char http_error_icon[] =
         "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiNDMDAwMDAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjooPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
 
-static const char http_warning_document[] =
-        "\t\t\t<h1>%1$i</h1>\n"
-        "\t\t\t<h2>%2$s :&#xFEFF;o</h2>\n"
-        "\t\t\t<p>%3$s</p>\n"
-        "\t\t\t<p>%4$s</p>\n";
-
-static const char http_warning_icon[] =
-        "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
-        "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
-        "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiNFMEMwMDAiIHN0eWxlPSJmb250LWZhbWls"
-        "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjpvPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
-
-
-static const char http_success_document[] =
+const char http_warning_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";
 
-static const char http_success_icon[] =
+const char http_warning_icon[] =
+        "\t<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[] =
+        "\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_success_icon[] =
         "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiMwMDgwMDAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjopPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
 
-static const char http_info_document[] =
+const char http_info_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";
 
-static const char http_info_icon[] =
+const char http_info_icon[] =
         "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiM2MDYwNjAiIHN0eWxlPSJmb250LWZhbWls"
         "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjopPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
-
-void http_to_camel_case(char *str, int mode);
-
-void http_free_hdr(http_hdr *hdr);
-
-void http_free_req(http_req *req);
-
-void http_free_res(http_res *res);
-
-int http_receive_request(sock *client, http_req *req);
-
-int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr) ;
-
-char *http_get_header_field(const http_hdr *hdr, const char *field_name);
-
-void http_add_header_field(http_hdr *hdr, const char *field_name, const char *field_value);
-
-void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode);
-
-int http_send_response(sock *client, http_res *res);
-
-int http_send_request(sock *server, http_req *req);
-
-const http_status *http_get_status(unsigned short status_code);
-
-const http_status_msg *http_get_error_msg(const http_status *status);
-
-const char *http_get_status_color(const http_status *status);
-
-char *http_format_date(time_t time, char *buf, size_t size);
-
-char *http_get_date(char *buf, size_t size);
-
-const http_doc_info *http_get_status_info(const http_status *status);
-
-#endif //NECRONDA_SERVER_HTTP_H
+const int http_statuses_size = sizeof(http_statuses);
+const int http_status_messages_size = sizeof(http_status_messages);

src/lib/include/fastcgi.h

@@ -1,48 +1,11 @@
 /**
- * Necronda Web Server
- * FastCGI interface implementation (header file)
- * src/fastcgi.h
- * Lorenz Stechauner, 2020-12-26
+ * sesimos - secure, simple, modern web server
+ * @brief FastCGI header file
+ * @file src/lib/include/fastcgi.h
  */
 
-#ifndef NECRONDA_SERVER_FASTCGI_H
-#define NECRONDA_SERVER_FASTCGI_H
-
-#define FASTCGI_CHUNKED 1
-#define FASTCGI_COMPRESS 2
-
-#include "necronda-server.h"
-#include "http.h"
-#include "uri.h"
-#include "client.h"
-
-#include <sys/un.h>
-#include <zlib.h>
-
-
-typedef struct {
-    int socket;
-    unsigned short req_id;
-    char *out_buf;
-    unsigned short out_len;
-    unsigned short out_off;
-} fastcgi_conn;
-
-char *fastcgi_add_param(char *buf, const char *key, const char *value);
-
-int fastcgi_init(fastcgi_conn *conn, 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_php_error(const char *msg, int msg_len, char *err_msg);
-
-int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg);
-
-int fastcgi_send(fastcgi_conn *conn, sock *client, int flags);
-
-int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len);
-
+#ifndef SESIMOS_EXTERN_FASTCGI_H
+#define SESIMOS_EXTERN_FASTCGI_H
 
 /*
  * Listening socket file number
@@ -155,4 +118,4 @@ typedef struct {
     FCGI_UnknownTypeBody body;
 } FCGI_UnknownTypeRecord;
 
-#endif //NECRONDA_SERVER_FASTCGI_H
+#endif //SESIMOS_EXTERN_FASTCGI_H

src/lib/rev_proxy.c

@@ -0,0 +1,567 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Reverse proxy
+ * @file src/lib/rev_proxy.c
+ * @author Lorenz Stechauner
+ * @date 2021-01-07
+ */
+
+#include "../defs.h"
+#include "../server.h"
+#include "../logger.h"
+#include "rev_proxy.h"
+#include "utils.h"
+#include "compress.h"
+
+#include <openssl/ssl.h>
+#include <string.h>
+#include <errno.h>
+#include <openssl/err.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+
+
+sock rev_proxy;
+char *rev_proxy_host = NULL;
+struct timeval server_timeout = {.tv_sec = SERVER_TIMEOUT, .tv_usec = 0};
+
+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, client_ctx_t *ctx) {
+    char buf1[256], buf2[256];
+    int p_len;
+
+    const char *via = http_get_header_field(&req->hdr, "Via");
+    sprintf(buf1, "HTTP/%s %s", req->version, SERVER_NAME);
+    if (via == NULL) {
+        http_add_header_field(&req->hdr, "Via", buf1);
+    } else {
+        p_len = snprintf(buf2, sizeof(buf2), "%s, %s", via, buf1);
+        if (p_len < 0 || p_len >= sizeof(buf2)) {
+            error("Header field 'Via' too long");
+            return -1;
+        }
+        http_remove_header_field(&req->hdr, "Via", HTTP_REMOVE_ALL);
+        http_add_header_field(&req->hdr, "Via", buf2);
+    }
+
+    const char *host = http_get_header_field(&req->hdr, "Host");
+    const char *forwarded = http_get_header_field(&req->hdr, "Forwarded");
+    int client_ipv6 = strchr(ctx->addr, ':') != NULL;
+    int server_ipv6 = strchr(ctx->s_addr, ':') != NULL;
+
+    p_len = snprintf(buf1, sizeof(buf1), "by=%s%s%s;for=%s%s%s;host=%s;proto=%s",
+                     server_ipv6 ? "\"[" : "", ctx->s_addr, server_ipv6 ? "]\"" : "",
+                     client_ipv6 ? "\"[" : "", ctx->addr, client_ipv6 ? "]\"" : "",
+                     host, enc ? "https" : "http");
+    if (p_len < 0 || p_len >= sizeof(buf1)) {
+        error("Appended part of header field 'Forwarded' too long");
+        return -1;
+    }
+
+    if (forwarded == NULL) {
+        http_add_header_field(&req->hdr, "Forwarded", buf1);
+    } else {
+        p_len = snprintf(buf2, sizeof(buf2), "%s, %s", forwarded, buf1);
+        if (p_len < 0 || p_len >= sizeof(buf2)) {
+            error("Header field 'Forwarded' too long");
+            return -1;
+        }
+        http_remove_header_field(&req->hdr, "Forwarded", HTTP_REMOVE_ALL);
+        http_add_header_field(&req->hdr, "Forwarded", buf2);
+    }
+
+    const char *xff = http_get_header_field(&req->hdr, "X-Forwarded-For");
+    if (xff == NULL) {
+        http_add_header_field(&req->hdr, "X-Forwarded-For", ctx->addr);
+    } else {
+        sprintf(buf1, "%s, %s", xff, ctx->addr);
+        http_remove_header_field(&req->hdr, "X-Forwarded-For", HTTP_REMOVE_ALL);
+        http_add_header_field(&req->hdr, "X-Forwarded-For", buf1);
+    }
+
+    const char *xfh = http_get_header_field(&req->hdr, "X-Forwarded-Host");
+    if (xfh == NULL) {
+        if (forwarded == NULL) {
+            http_add_header_field(&req->hdr, "X-Forwarded-Host", host);
+        } else {
+            char *ptr = strchr(forwarded, ',');
+            unsigned long len;
+            if (ptr != NULL) len = ptr - forwarded;
+            else len = strlen(forwarded);
+            ptr = strstr(forwarded, "host=");
+            if ((ptr - forwarded) < len) {
+                char *end = strchr(ptr, ';');
+                if (end == NULL) len -= (ptr - forwarded);
+                else len = (end - ptr);
+                len -= 5;
+                sprintf(buf1, "%.*s", (int) len, ptr + 5);
+                http_add_header_field(&req->hdr, "X-Forwarded-Host", buf1);
+            }
+        }
+    }
+
+    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");
+        } else {
+            char *ptr = strchr(forwarded, ',');
+            unsigned long len;
+            if (ptr != NULL) len = ptr - forwarded;
+            else len = strlen(forwarded);
+            ptr = strstr(forwarded, "proto=");
+            if ((ptr - forwarded) < len) {
+                char *end = strchr(ptr, ';');
+                if (end == NULL) len -= (ptr - forwarded);
+                else len = (end - ptr);
+                len -= 6;
+                sprintf(buf1, "%.*s", (int) len, ptr + 6);
+                http_add_header_field(&req->hdr, "X-Forwarded-Proto", buf1);
+            }
+        }
+    }
+
+    return 0;
+}
+
+int rev_proxy_response_header(http_req *req, http_res *res, host_config *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)) {
+        error("Appended part of header field 'Via' too long");
+        return -1;
+    }
+    if (via == NULL) {
+        http_add_header_field(&res->hdr, "Via", buf1);
+    } else {
+        p_len = snprintf(buf2, sizeof(buf2), "%s, %s", via, buf1);
+        if (p_len < 0 || p_len >= sizeof(buf2)) {
+            error("Header field 'Via' too long");
+            return -1;
+        }
+        http_remove_header_field(&res->hdr, "Via", HTTP_REMOVE_ALL);
+        http_add_header_field(&res->hdr, "Via", buf2);
+    }
+
+    const char *location = http_get_header_field(&res->hdr, "Location");
+    if (location != NULL) {
+        char *hostnames[] = {conf->name, conf->rev_proxy.hostname};
+        for (int i = 0; i < sizeof(hostnames) / sizeof(hostnames[0]); i++) {
+            char *hostname = hostnames[i];
+
+            p_len = snprintf(buf1, sizeof(buf1), "http://%s/", hostname);
+            if (strncmp(location, buf1, p_len) == 0) goto match;
+
+            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);
+            if (strncmp(location, buf1, p_len) == 0) goto match;
+
+            p_len = snprintf(buf1, sizeof(buf1), "https://%s:%i/", hostname, conf->rev_proxy.port);
+            if (strncmp(location, buf1, p_len) == 0) goto match;
+        }
+
+        if (0) {
+            match:
+            strcpy(buf1, location + p_len - 1);
+            http_remove_header_field(&res->hdr, "Location", HTTP_REMOVE_ALL);
+            http_add_header_field(&res->hdr, "Location", buf1);
+        }
+    }
+
+    return 0;
+}
+
+int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config *conf, sock *client, client_ctx_t *cctx, 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)
+        goto rev_proxy;
+
+    retry:
+    if (rev_proxy.socket != 0) {
+        info(BLUE_STR "Closing proxy connection");
+        sock_close(&rev_proxy);
+    }
+    retry = 0;
+    tries++;
+
+    rev_proxy.socket = socket(AF_INET6, SOCK_STREAM, 0);
+    if (rev_proxy.socket  < 0) {
+        error("Unable to create socket");
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        return -1;
+    }
+
+    server_timeout.tv_sec = SERVER_TIMEOUT_INIT;
+    server_timeout.tv_usec = 0;
+    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);
+    if (host_ent == NULL) {
+        host_ent = gethostbyname2(conf->rev_proxy.hostname, AF_INET);
+        if (host_ent == NULL) {
+            res->status = http_get_status(503);
+            ctx->origin = SERVER_REQ;
+            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)};
+    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) {
+        unsigned char addr[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0, 0, 0, 0};
+        memcpy(addr + 12, host_ent->h_addr_list[0], host_ent->h_length);
+        memcpy(&address.sin6_addr, addr, 16);
+    }
+
+    inet_ntop(address.sin6_family, (void *) &address.sin6_addr, buffer, sizeof(buffer));
+
+    info(BLUE_STR "Connecting to " BLD_STR "[%s]:%i" CLR_STR BLUE_STR "...", buffer, conf->rev_proxy.port);
+    if (connect(rev_proxy.socket, (struct sockaddr *) &address, sizeof(address)) < 0) {
+        if (errno == ETIMEDOUT || errno == EINPROGRESS) {
+            res->status = http_get_status(504);
+            ctx->origin = SERVER_REQ;
+        } else if (errno == ECONNREFUSED) {
+            res->status = http_get_status(503);
+            ctx->origin = SERVER_REQ;
+        } else {
+            res->status = http_get_status(500);
+            ctx->origin = INTERNAL;
+        }
+        error("Unable to connect to [%s]:%i: %s", buffer, conf->rev_proxy.port, strerror(errno));
+        sprintf(err_msg, "Unable to connect to server: %s.", strerror(errno));
+        goto proxy_err;
+    }
+
+    server_timeout.tv_sec = SERVER_TIMEOUT;
+    server_timeout.tv_usec = 0;
+    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;
+        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) {
+        rev_proxy.ssl = SSL_new(rev_proxy.ctx);
+        SSL_set_fd(rev_proxy.ssl, rev_proxy.socket);
+        SSL_set_connect_state(rev_proxy.ssl);
+
+        ret = SSL_do_handshake(rev_proxy.ssl);
+        rev_proxy._last_ret = ret;
+        rev_proxy._errno = errno;
+        rev_proxy._ssl_error = ERR_get_error();
+        rev_proxy.enc = 1;
+        if (ret < 0) {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_REQ;
+            error("Unable to perform handshake: %s", sock_strerror(&rev_proxy));
+            sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&rev_proxy));
+            goto proxy_err;
+        }
+    }
+
+    rev_proxy_host = conf->name;
+    info(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i", buffer, conf->rev_proxy.port);
+
+    rev_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");
+        ws_version = http_get_header_field(&req->hdr, "Sec-WebSocket-Version");
+        if (upgrade != NULL && ws_version != NULL && strcmp(upgrade, "websocket") == 0 && strcmp(ws_version, "13") == 0) {
+            ctx->ws_key = http_get_header_field(&req->hdr, "Sec-WebSocket-Key");
+        } else {
+            res->status = http_get_status(501);
+            ctx->origin = INTERNAL;
+            return -1;
+        }
+    } 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, cctx);
+    if (ret != 0) {
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        return -1;
+    }
+
+    ret = http_send_request(&rev_proxy, req);
+    if (ret < 0) {
+        res->status = http_get_status(502);
+        ctx->origin = SERVER_REQ;
+        error("Unable to send request to server (1): %s", sock_strerror(&rev_proxy));
+        sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
+        retry = tries < 4;
+        goto proxy_err;
+    }
+
+    const char *content_length = http_get_header_field(&req->hdr, "Content-Length");
+    unsigned long content_len = content_length != NULL ? strtoul(content_length, NULL, 10) : 0;
+    const char *transfer_encoding = http_get_header_field(&req->hdr, "Transfer-Encoding");
+
+    ret = 0;
+    if (content_len > 0) {
+        ret = sock_splice(&rev_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));
+    }
+
+    if (ret < 0 || (content_len != 0 && ret != content_len)) {
+        if (ret == -1) {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_REQ;
+            error("Unable to send request to server (2): %s", sock_strerror(&rev_proxy));
+            sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
+            retry = tries < 4;
+            goto proxy_err;
+        } else if (ret == -2) {
+            res->status = http_get_status(400);
+            ctx->origin = CLIENT_REQ;
+            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;
+        }
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        error("Unknown Error");
+        return -1;
+    }
+
+    ret = sock_recv(&rev_proxy, buffer, sizeof(buffer), MSG_PEEK);
+    if (ret <= 0) {
+        int enc_err = sock_enc_error(&rev_proxy);
+        if (errno == EAGAIN || errno == EINPROGRESS || enc_err == SSL_ERROR_WANT_READ ||
+            enc_err == SSL_ERROR_WANT_WRITE)
+        {
+            res->status = http_get_status(504);
+            ctx->origin = SERVER_RES;
+        } else {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
+        }
+        error("Unable to receive response from server: %s", sock_strerror(&rev_proxy));
+        sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&rev_proxy));
+        retry = tries < 4;
+        goto proxy_err;
+    }
+
+    char *buf = buffer;
+    unsigned short header_len = (unsigned short) (strstr(buffer, "\r\n\r\n") - buffer + 4);
+
+    if (header_len <= 0) {
+        res->status = http_get_status(502);
+        ctx->origin = SERVER_RES;
+        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;
+    }
+
+    for (int i = 0; i < header_len; i++) {
+        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;
+            error("Unable to parse header: Header contains illegal characters");
+            sprintf(err_msg, "Unable to parse header: Header contains illegal characters.");
+            goto proxy_err;
+        }
+    }
+
+    char *ptr = buf;
+    while (header_len != (ptr - buf)) {
+        char *pos0 = strstr(ptr, "\r\n");
+        if (pos0 == NULL) {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
+            error("Unable to parse header: Invalid header format");
+            sprintf(err_msg, "Unable to parse header: Invalid header format.");
+            goto proxy_err;
+        }
+        if (ptr == buf) {
+            if (strncmp(ptr, "HTTP/", 5) != 0) {
+                res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
+                error("Unable to parse header: Invalid header format");
+                sprintf(err_msg, "Unable to parse header: Invalid header format.");
+                goto proxy_err;
+            }
+            int status_code = (int) strtol(ptr + 9, NULL, 10);
+            res->status = http_get_status(status_code);
+            if (res->status == NULL && status_code >= 100 && status_code <= 999) {
+                custom_status->code = status_code;
+                strcpy(custom_status->type, "");
+                snprintf(custom_status->msg, sizeof(custom_status->msg), "%.*s",
+                         (int) (strchr(ptr, '\r') - ptr - 13), ptr + 13);
+                res->status = custom_status;
+            } else if (res->status == NULL) {
+                res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
+                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;
+            }
+        } else {
+            ret = http_parse_header_field(&res->hdr, ptr, pos0, 0);
+            if (ret != 0) {
+                res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
+                error("Unable to parse header");
+                sprintf(err_msg, "Unable to parse header.");
+                goto proxy_err;
+            }
+        }
+        if (pos0[2] == '\r' && pos0[3] == '\n') {
+            break;
+        }
+        ptr = pos0 + 2;
+    }
+    sock_recv(&rev_proxy, buffer, header_len, 0);
+
+    ret = rev_proxy_response_header(req, res, conf);
+    if (ret != 0) {
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        return -1;
+    }
+
+    return 0;
+
+    proxy_err:
+    if (retry) goto retry;
+    return -1;
+}
+
+int rev_proxy_send(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) {
+        flags &= ~REV_PROXY_COMPRESS_GZ;
+        if (compress_init(&comp_ctx, COMPRESS_BR) != 0) {
+            error("Unable to init brotli");
+            flags &= ~REV_PROXY_COMPRESS_BR;
+        }
+    } else if (flags & REV_PROXY_COMPRESS_GZ) {
+        flags &= ~REV_PROXY_COMPRESS_BR;
+        if (compress_init(&comp_ctx, COMPRESS_GZ) != 0) {
+            error("Unable to init gzip");
+            flags &= ~REV_PROXY_COMPRESS_GZ;
+        }
+    }
+
+    do {
+        snd_len = 0;
+        if (flags & REV_PROXY_CHUNKED) {
+            ret = sock_get_chunk_header(&rev_proxy);
+            if (ret < 0) {
+                if (ret == -1) {
+                    error("Unable to receive from server: Malformed chunk header");
+                } else {
+                    error("Unable to receive from server: %s", sock_strerror(&rev_proxy));
+                }
+                break;
+            }
+
+            len_to_send = ret;
+            ret = 1;
+            if (len_to_send == 0 && (flags & REV_PROXY_COMPRESS)) {
+                finish_comp = 1;
+                len = 0;
+                ptr = NULL;
+                goto out;
+                finish:
+                compress_free(&comp_ctx);
+            }
+        }
+        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);
+            if (ret <= 0) {
+                error("Unable to receive from server: %s", sock_strerror(&rev_proxy));
+                break;
+            }
+            len = ret;
+            ptr = buffer;
+            out:
+            avail_in = len;
+            char *next_in = ptr;
+            do {
+                long buf_len = len;
+                if (flags & REV_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;
+                    buf_len = (int) (sizeof(comp_out) - avail_out);
+                    snd_len += (long) (len - avail_in);
+                }
+                if (buf_len != 0) {
+                    len = sprintf(buf, "%lX\r\n", buf_len);
+                    ret = 1;
+
+                    if (flags & REV_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 & REV_PROXY_CHUNKED) ret = sock_send(client, "\r\n", 2, 0);
+                    if (ret <= 0) {
+                        err:
+                        error("Unable to send: %s", sock_strerror(client));
+                        break;
+                    }
+                }
+            } while ((flags & REV_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);
+    } while ((flags & REV_PROXY_CHUNKED) && len_to_send > 0);
+
+    if (ret <= 0) return -1;
+
+    if (flags & REV_PROXY_CHUNKED) {
+        ret = sock_send(client, "0\r\n\r\n", 5, 0);
+        if (ret <= 0) {
+            error("Unable to send: %s", sock_strerror(client));
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+int rev_proxy_dump(char *buf, long len) {
+    sock_recv(&rev_proxy, buf, len, 0);
+    sock_close(&rev_proxy);
+    return 0;
+}

src/lib/rev_proxy.h

@@ -0,0 +1,39 @@
+/**
+ * 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"
+#include "../client.h"
+
+extern sock rev_proxy;
+
+int rev_proxy_preload(void);
+
+int rev_proxy_request_header(http_req *req, int enc, client_ctx_t *ctx);
+
+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, client_ctx_t *cctx, 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

@@ -0,0 +1,203 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Basic TCP and TLS socket
+ * @file src/lib/sock.c
+ * @author Lorenz Stechauner
+ * @date 2021-01-07
+ */
+
+#include "sock.h"
+#include "utils.h"
+
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <poll.h>
+
+
+int sock_enc_error(sock *s) {
+    return (int) s->enc ? SSL_get_error(s->ssl, (int) s->_last_ret) : 0;
+}
+
+const char *sock_strerror(sock *s) {
+    if (s->_last_ret == 0) {
+        return "closed";
+    } else if (s->enc) {
+        if (s->_last_ret > 0) {
+            return NULL;
+        }
+        const char *err1 = ERR_reason_error_string(s->_ssl_error);
+        const char *err2 = strerror(errno);
+        switch (sock_enc_error(s)) {
+            case SSL_ERROR_NONE:
+                return NULL;
+            case SSL_ERROR_ZERO_RETURN:
+                return "closed";
+            case SSL_ERROR_WANT_READ:
+                return "want read";
+            case SSL_ERROR_WANT_WRITE:
+                return "want write";
+            case SSL_ERROR_WANT_CONNECT:
+                return "want connect";
+            case SSL_ERROR_WANT_ACCEPT:
+                return "want accept";
+            case SSL_ERROR_WANT_X509_LOOKUP:
+                return "want x509 lookup";
+            case SSL_ERROR_SYSCALL:
+                return ((s->_ssl_error == 0) ? ((s->_last_ret == 0) ? "protocol violation" : err2) : err1);
+            case SSL_ERROR_SSL:
+                return err1;
+            default:
+                return "unknown error";
+        }
+    } else {
+        return strerror(s->_errno);
+    }
+}
+
+long sock_send(sock *s, void *buf, unsigned long len, int flags) {
+    long ret;
+    if (s->enc) {
+        ret = SSL_write(s->ssl, buf, (int) len);
+        s->_ssl_error = ERR_get_error();
+    } else {
+        ret = send(s->socket, buf, len, flags);
+    }
+    s->_last_ret = ret;
+    s->_errno = errno;
+    return ret >= 0 ? ret : -1;
+}
+
+long sock_recv(sock *s, void *buf, unsigned long len, int flags) {
+    long ret;
+    if (s->enc) {
+        int (*func)(SSL*, void*, int) = (flags & MSG_PEEK) ? SSL_peek : SSL_read;
+        ret = func(s->ssl, buf, (int) len);
+        s->_ssl_error = ERR_get_error();
+    } else {
+        ret = recv(s->socket, buf, len, flags);
+    }
+    s->_last_ret = ret;
+    s->_errno = errno;
+    return ret >= 0 ? ret : -1;
+}
+
+long sock_splice(sock *dst, sock *src, void *buf, unsigned long buf_len, unsigned long len) {
+    long ret;
+    unsigned long send_len = 0;
+    unsigned long next_len;
+    while (send_len < len) {
+        next_len = (buf_len < (len - send_len)) ? buf_len : (len - send_len);
+        ret = sock_recv(src, buf, next_len, 0);
+        if (ret <= 0) return -2;
+        next_len = ret;
+        ret = sock_send(dst, buf, next_len, send_len + next_len < len ? MSG_MORE : 0);
+        if (ret < 0) return -1;
+        if (ret != next_len) return -3;
+        send_len += next_len;
+    }
+    return (long) send_len;
+}
+
+long sock_splice_chunked(sock *dst, sock *src, void *buf, unsigned long buf_len) {
+    long ret;
+    unsigned long send_len = 0;
+    unsigned long next_len;
+
+    while (1) {
+        ret = sock_get_chunk_header(src);
+        if (ret < 0) return -2;
+
+        next_len = ret;
+        if (next_len <= 0) break;
+
+        ret = sock_splice(dst, src, buf, buf_len, next_len);
+        if (ret < 0) return ret;
+    }
+
+    return (long) send_len;
+}
+
+int sock_close(sock *s) {
+    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;
+    return 0;
+}
+
+int sock_check(sock *s) {
+    char buf;
+    return recv(s->socket, &buf, 1, MSG_PEEK | MSG_DONTWAIT) == 1;
+}
+
+int sock_poll(sock *sockets[], sock *ready[], sock *error[], int n_sock, int *n_ready, int *n_error, short events, int timeout_ms) {
+    struct pollfd fds[n_sock];
+    for (int i = 0; i < n_sock; i++) {
+        fds[i].fd = sockets[i]->socket;
+        fds[i].events = events;
+    }
+
+    int ret = poll(fds, n_sock, timeout_ms);
+    if (ret < 0 || ready == NULL || error == NULL) return ret;
+
+    *n_ready = 0, *n_error = 0;
+    for (int i = 0; i < n_sock; i++) {
+        if (fds[i].revents & events)
+            ready[(*n_ready)++] = sockets[i];
+        if (fds[i].revents & (POLLERR | POLLHUP | POLLNVAL))
+            error[(*n_error)++] = sockets[i];
+    }
+
+    return ret;
+}
+
+int sock_poll_read(sock *sockets[], sock *readable[], sock *error[], int n_sock, int *n_readable, int *n_error, int timeout_ms) {
+    return sock_poll(sockets, readable, error, n_sock, n_readable, n_error, POLLIN, timeout_ms);
+}
+
+int sock_poll_write(sock *sockets[], sock *writable[], sock *error[], int n_sock, int *n_writable, int *n_error, int timeout_ms) {
+    return sock_poll(sockets, writable, error, n_sock, n_writable, n_error, POLLOUT, timeout_ms);
+}
+
+long sock_parse_chunk_header(const char *buf, long len, long *ret_len) {
+    for (int i = 0; i < len; i++) {
+        char ch = buf[i];
+        if (ch == '\r') {
+            continue;
+        } else if (ch == '\n') {
+            if (ret_len != NULL) *ret_len = i + 1;
+            return strtol(buf, NULL, 16);
+        } else if (!((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'))) {
+            return -2;
+        }
+    }
+
+    return -1;
+}
+
+long sock_get_chunk_header(sock *s) {
+    long ret, len;
+    char buf[16];
+
+    do {
+        ret = sock_recv(s, buf, sizeof(buf), MSG_PEEK);
+        if (ret <= 0) return -2;
+        else if (ret < 2) continue;
+
+        ret = sock_parse_chunk_header(buf, ret, &len);
+        if (ret == -2) return -1;
+    } while (ret < 0);
+
+    if (sock_recv(s, buf, len, 0) != len)
+        return -2;
+
+    return ret;
+}

src/lib/sock.h

@@ -0,0 +1,51 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Basic TCP and TLS socket (header file)
+ * @file src/lib/sock.h
+ * @author Lorenz Stechauner
+ * @date 2021-01-07
+ */
+
+#ifndef SESIMOS_SOCK_H
+#define SESIMOS_SOCK_H
+
+#include <openssl/crypto.h>
+#include <sys/socket.h>
+
+typedef struct {
+    unsigned int enc:1;
+    int socket;
+    SSL_CTX *ctx;
+    SSL *ssl;
+    long _last_ret;
+    int _errno;
+    unsigned long _ssl_error;
+} sock;
+
+int sock_enc_error(sock *s);
+
+const char *sock_strerror(sock *s);
+
+long sock_send(sock *s, void *buf, unsigned long len, int flags);
+
+long sock_recv(sock *s, void *buf, unsigned long len, int flags);
+
+long sock_splice(sock *dst, sock *src, void *buf, unsigned long buf_len, unsigned long len);
+
+long sock_splice_chunked(sock *dst, sock *src, void *buf, unsigned long buf_len);
+
+int sock_close(sock *s);
+
+int sock_check(sock *s);
+
+int sock_poll(sock *sockets[], sock *ready[], sock *error[], int n_sock, int *n_ready, int *n_error, short events, int timeout_ms);
+
+int sock_poll_read(sock *sockets[], sock *readable[], sock *error[], int n_sock, int *n_readable, int *n_error, int timeout_ms);
+
+int sock_poll_write(sock *sockets[], sock *writable[], sock *error[], int n_sock, int *n_writable, int *n_error, int timeout_ms);
+
+long sock_parse_chunk_header(const char *buf, long len, long *ret_len);
+
+long sock_get_chunk_header(sock *s);
+
+#endif //SESIMOS_SOCK_H

src/lib/uri.c

@@ -1,11 +1,16 @@
 /**
- * Necronda Web Server
- * URI and path handlers
- * src/uri.c
- * Lorenz Stechauner, 2020-12-13
+ * sesimos - secure, simple, modern web server
+ * @brief URI and path handlers
+ * @file src/lib/uri.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-13
  */
 
 #include "uri.h"
+#include "utils.h"
+
+#include <stdlib.h>
+#include <string.h>
 
 
 int path_is_directory(const char *path) {
@@ -28,6 +33,7 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
     char buf1[1024];
     char buf2[1024];
     char buf3[1024];
+    char buf4[1024];
     int p_len;
     uri->webroot = NULL;
     uri->req_path = NULL;
@@ -51,12 +57,12 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
     } else {
         query[0] = 0;
         query++;
-        ssize_t size = strlen(query) + 1;
+        long size = (long) strlen(query) + 1;
         uri->query = malloc(size);
         strcpy(uri->query, query);
     }
 
-    ssize_t size = strlen(uri_str) + 1;
+    long size = (long) strlen(uri_str) + 1;
     uri->req_path = malloc(size);
     url_decode(uri_str, uri->req_path, &size);
     if (query != NULL) {
@@ -66,7 +72,7 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
         return 2;
     }
 
-    size = strlen(uri->req_path) + 1;
+    size = (long) strlen(uri->req_path) + 1;
     uri->path = malloc(size);
     uri->pathinfo = malloc(size);
 
@@ -97,50 +103,61 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
 
     while (1) {
         sprintf(buf0, "%s%s", uri->webroot, uri->path);
-        p_len = snprintf(buf1, sizeof(buf1), "%s.php", buf0);
+        p_len = snprintf(buf1, sizeof(buf1), "%s.ncr", buf0);
         if (p_len < 0 || p_len >= sizeof(buf1)) return -1;
-        p_len = snprintf(buf2, sizeof(buf2), "%s.html", buf0);
+        p_len = snprintf(buf2, sizeof(buf2), "%s.php", buf0);
         if (p_len < 0 || p_len >= sizeof(buf2)) return -1;
+        p_len = snprintf(buf3, sizeof(buf3), "%s.html", buf0);
+        if (p_len < 0 || p_len >= sizeof(buf3)) return -1;
 
-        if (strlen(uri->path) <= 1 || path_exists(buf0) || path_is_file(buf1) || path_is_file(buf2)) {
+        if (strlen(uri->path) <= 1 ||
+            path_exists(buf0) ||
+            path_is_file(buf1) ||
+            path_is_file(buf2) ||
+            path_is_file(buf3)) {
             break;
         }
 
         char *ptr;
         parent_dir:
         ptr = strrchr(uri->path, '/');
-        size = strlen(ptr);
-        sprintf(buf3, "%.*s%s", (int) size, ptr, uri->pathinfo);
-        strcpy(uri->pathinfo, buf3);
+        size = (long) strlen(ptr);
+        sprintf(buf4, "%.*s%s", (int) size, ptr, uri->pathinfo);
+        strcpy(uri->pathinfo, buf4);
         ptr[0] = 0;
     }
     if (uri->pathinfo[0] != 0) {
-        sprintf(buf3, "%s", uri->pathinfo + 1);
-        strcpy(uri->pathinfo, buf3);
+        sprintf(buf4, "%s", uri->pathinfo + 1);
+        strcpy(uri->pathinfo, buf4);
     }
 
     if (path_is_file(buf0)) {
         uri->filename = malloc(strlen(buf0) + 1);
         strcpy(uri->filename, buf0);
-        ssize_t len = strlen(uri->path);
-        if (strcmp(uri->path + len - 5, ".html") == 0) {
-            uri->path[len - 5] = 0;
-        } else if (strcmp(uri->path + len - 4, ".php") == 0) {
+        long len = (long) strlen(uri->path);
+        if (strcmp(uri->path + len - 4, ".ncr") == 0 || strcmp(uri->path + len - 4, ".php") == 0) {
             uri->path[len - 4] = 0;
             uri->is_static = 0;
+        } else if (strcmp(uri->path + len - 5, ".html") == 0) {
+            uri->path[len - 5] = 0;
         }
     } else if (path_is_file(buf1)) {
         uri->is_static = 0;
         uri->filename = malloc(strlen(buf1) + 1);
         strcpy(uri->filename, buf1);
     } else if (path_is_file(buf2)) {
+        uri->is_static = 0;
         uri->filename = malloc(strlen(buf2) + 1);
         strcpy(uri->filename, buf2);
+    } else if (path_is_file(buf3)) {
+        uri->filename = malloc(strlen(buf3) + 1);
+        strcpy(uri->filename, buf3);
     } else {
         uri->is_dir = 1;
         strcpy(uri->path + strlen(uri->path), "/");
-        sprintf(buf1, "%s%sindex.php", uri->webroot, uri->path);
-        sprintf(buf2, "%s%sindex.html", uri->webroot, uri->path);
+        sprintf(buf1, "%s%sindex.ncr", uri->webroot, uri->path);
+        sprintf(buf2, "%s%sindex.php", uri->webroot, uri->path);
+        sprintf(buf3, "%s%sindex.html", uri->webroot, uri->path);
         if (path_is_file(buf1)) {
             uri->filename = malloc(strlen(buf1) + 1);
             strcpy(uri->filename, buf1);
@@ -148,6 +165,10 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
         } else if (path_is_file(buf2)) {
             uri->filename = malloc(strlen(buf2) + 1);
             strcpy(uri->filename, buf2);
+            uri->is_static = 0;
+        } else if (path_is_file(buf3)) {
+            uri->filename = malloc(strlen(buf3) + 1);
+            strcpy(uri->filename, buf3);
         } else {
             if (dir_mode == URI_DIR_MODE_FORBIDDEN) {
                 uri->is_static = 1;
@@ -167,7 +188,9 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
     if (strcmp(uri->path + strlen(uri->path) - 5, "index") == 0) {
         uri->path[strlen(uri->path) - 5] = 0;
     }
-    if (strcmp(uri->pathinfo, "index.php") == 0 || strcmp(uri->pathinfo, "index.html") == 0) {
+    if (strcmp(uri->pathinfo, "index.ncr") == 0 ||
+        strcmp(uri->pathinfo, "index.php") == 0 ||
+        strcmp(uri->pathinfo, "index.html") == 0) {
         uri->pathinfo[0] = 0;
     }
 

src/lib/uri.h

@@ -1,26 +1,27 @@
 /**
- * Necronda Web Server
- * URI and path handlers (header file)
- * src/uri.h
- * Lorenz Stechauner, 2020-12-13
+ * sesimos - secure, simple, modern web server
+ * @brief URI and path handlers (header file)
+ * @file src/lib/uri.h
+ * @author Lorenz Stechauner
+ * @date 2020-12-13
  */
 
-#ifndef NECRONDA_SERVER_URI_H
-#define NECRONDA_SERVER_URI_H
+#ifndef SESIMOS_URI_H
+#define SESIMOS_URI_H
+
+#include <sys/stat.h>
 
 #define URI_DIR_MODE_NO_VALIDATION 0
 #define URI_DIR_MODE_FORBIDDEN 1
 #define URI_DIR_MODE_LIST 2
 #define URI_DIR_MODE_INFO 3
 
-#include <sys/stat.h>
-
-
 typedef struct {
     char etag[64];
     char type[24];
     char charset[16];
-    char filename_comp[256];
+    char filename_comp_gz[256];
+    char filename_comp_br[256];
     struct stat stat;
 } meta_data;
 
@@ -44,4 +45,4 @@ int uri_init_cache(http_uri *uri);
 
 void uri_free(http_uri *uri);
 
-#endif //NECRONDA_SERVER_URI_H
+#endif //SESIMOS_URI_H

src/lib/utils.c

@@ -0,0 +1,205 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Utilities
+ * @file src/lib/utils.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-03
+ */
+
+#include "utils.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+static const char base64_encode_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const int base64_mod_table[3] = {0, 2, 1};
+
+
+char *format_duration(unsigned long micros, char *buf) {
+    if (micros < 10000) {
+        sprintf(buf, "%.1f ms", (double) micros / 1000);
+    } else if (micros < 1000000 - 1000) {
+        sprintf(buf, "%.0f ms", (double) micros / 1000);
+    } else if (micros < 60000000 - 1000000) {
+        sprintf(buf, "%.1f s", (double) micros / 1000000);
+    } else if (micros < 6000000000) {
+        sprintf(buf, "%.1f min", (double) micros / 1000000 / 60);
+    } else {
+        sprintf(buf, "%.0f min", (double) micros / 1000000 / 60);
+    }
+    return buf;
+}
+
+int url_encode_component(const void *in, size_t size_in, char *out, size_t size_out) {
+    int size = 0;
+
+    // Encode control characters
+    for (int i = 0; i < size_in; i++) {
+        unsigned char ch = ((unsigned char *) in)[i];
+        if (ch == ' ') {
+            ch = '+';
+        } else if (
+                ch <= 0x20 || ch >= 0x7F ||
+                !((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') ||
+                  ch == '-' || ch == '_' || ch == '.' || ch == '!' || ch == '~' || ch == '*' || ch == '\'' ||
+                  ch == '(' || ch == ')')
+        ) {
+            size += 3;
+            if (size < size_out) sprintf(out + size - 3, "%%%02X", ch);
+            ch = 0;
+        }
+
+        if (ch != 0) {
+            size++;
+            if (size < size_out) out[size - 1] = (char) ch;
+        }
+    }
+
+    // Set terminating null byte
+    if (size_out > 0) out[size < size_out ? size : size_out - 1] = 0;
+
+    // Return theoretical size
+    return size;
+}
+
+int url_encode(const void *in, size_t size_in, char *out, size_t size_out) {
+    int size = 0;
+
+    // Encode control characters
+    for (int i = 0; i < size_in; i++) {
+        unsigned char ch = ((unsigned char *) in)[i];
+        if (ch <= 0x20 || ch >= 0x7F) {
+            size += 3;
+            if (size < size_out) sprintf(out + size - 3, "%%%02X", ch);
+        } else {
+            size++;
+            if (size < size_out) out[size - 1] = (char) ch;
+        }
+    }
+
+    // Set terminating null byte
+    if (size_out > 0) out[size < size_out ? size : size_out - 1] = 0;
+
+    // Return theoretical size
+    return size;
+}
+
+int url_decode(const char *str, char *dec, long *size) {
+    char *ptr = dec;
+    char ch, buf[3];
+    memset(dec, 0, *size);
+    for (int i = 0; i < strlen(str); i++, ptr++) {
+        if ((ptr - dec) >= *size) {
+            return -1;
+        }
+        ch = str[i];
+        if (ch == '+') {
+            ch = ' ';
+        } else if (ch == '%') {
+            memcpy(buf, str + i + 1, 2);
+            buf[2] = 0;
+            ch = (char) strtol(buf, NULL, 16);
+            i += 2;
+        } else if (ch == '?') {
+            strcpy(ptr, str + i);
+            break;
+        }
+        ptr[0] = ch;
+    }
+    *size = ptr - dec;
+    return 0;
+}
+
+int mime_is_compressible(const char *type) {
+    if (type == NULL) return 0;
+    char type_parsed[64];
+    snprintf(type_parsed, sizeof(type_parsed), "%s", type);
+    char *pos = strchr(type_parsed, ';');
+    if (pos != NULL) pos[0] = 0;
+    return
+        strncmp(type_parsed, "text/", 5) == 0 ||
+        strncmp(type_parsed, "message/", 7) == 0 ||
+        strstr(type_parsed, "+xml") != NULL ||
+        strstr(type_parsed, "+json") != NULL ||
+        strcmp(type_parsed, "application/javascript") == 0 ||
+        strcmp(type_parsed, "application/json") == 0 ||
+        strcmp(type_parsed, "application/xml") == 0 ||
+        strcmp(type_parsed, "application/x-www-form-urlencoded") == 0 ||
+        strcmp(type_parsed, "application/x-tex") == 0 ||
+        strcmp(type_parsed, "application/x-httpd-php") == 0 ||
+        strcmp(type_parsed, "application/x-latex") == 0 ||
+        strcmp(type_parsed, "application/vnd.ms-fontobject") == 0 ||
+        strcmp(type_parsed, "application/x-font-ttf") == 0 ||
+        strcmp(type_parsed, "application/x-javascript") == 0 ||
+        strcmp(type_parsed, "font/eot") == 0 ||
+        strcmp(type_parsed, "font/opentype") == 0 ||
+        strcmp(type_parsed, "image/bmp") == 0 ||
+        strcmp(type_parsed, "image/gif") == 0 ||
+        strcmp(type_parsed, "image/vnd.microsoft.icon") == 0 ||
+        strcmp(type_parsed, "image/vnd.microsoft.iconbinary") == 0 ||
+        strcmp(type_parsed, "image/x-icon") == 0;
+}
+
+int strcpy_rem_webroot(char *dst, const char *src, long len, const char *webroot) {
+    memcpy(dst, src, len);
+    dst[len] = 0;
+    if (webroot == NULL)
+        return 0;
+
+    char *pos;
+    const unsigned long webroot_len = strlen(webroot);
+    if (webroot_len == 0)
+        return 0;
+
+    while ((pos = strstr(dst, webroot)) != NULL) {
+        strcpy(pos, pos + webroot_len);
+    }
+
+    return 0;
+}
+
+int str_trim(char **start, char **end) {
+    if (start == NULL || end == NULL || *start == NULL || *end == NULL)
+        return -1;
+
+    (*end)--;
+    while (*start[0] == ' ' || *start[0] == '\t' || *start[0] == '\r' || *start[0] == '\n') (*start)++;
+    while (*end[0] == ' ' || *end[0] == '\t' || *end[0] == '\r' || *end[0] == '\n') (*end)--;
+    (*end)++;
+    return 0;
+}
+
+int str_trim_lws(char **start, char **end) {
+    if (start == NULL || end == NULL || *start == NULL || *end == NULL)
+        return -1;
+
+    (*end)--;
+    while (*start[0] == ' ' || *start[0] == '\t') (*start)++;
+    while (*end[0] == ' ' || *end[0] == '\t') (*end)--;
+    (*end)++;
+    return 0;
+}
+
+int base64_encode(void *data, unsigned long data_len, char *output, unsigned long *output_len) {
+    unsigned long out_len = 4 * ((data_len + 2) / 3);
+    if (output_len != NULL) *output_len = out_len;
+
+    for (int i = 0, j = 0; i < data_len;) {
+        unsigned int octet_a = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
+        unsigned int octet_b = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
+        unsigned int octet_c = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
+        unsigned int triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+        output[j++] = base64_encode_table[(triple >> 3 * 6) & 0x3F];
+        output[j++] = base64_encode_table[(triple >> 2 * 6) & 0x3F];
+        output[j++] = base64_encode_table[(triple >> 1 * 6) & 0x3F];
+        output[j++] = base64_encode_table[(triple >> 0 * 6) & 0x3F];
+    }
+
+    for (int i = 0; i < base64_mod_table[data_len % 3]; i++)
+        output[out_len - 1 - i] = '=';
+    output[out_len] = 0;
+
+    return 0;
+}

src/lib/utils.h

@@ -0,0 +1,40 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Utilities (header file)
+ * @file src/lib/utils.h
+ * @author Lorenz Stechauner
+ * @date 2020-12-03
+ */
+
+#ifndef SESIMOS_UTILS_H
+#define SESIMOS_UTILS_H
+
+#include <stdio.h>
+
+#define ERR_STR "\x1B[1;31m"
+#define CLR_STR "\x1B[0m"
+#define BLD_STR "\x1B[1m"
+#define WRN_STR "\x1B[1;33m"
+#define BLUE_STR "\x1B[34m"
+#define HTTP_STR "\x1B[1;31m"
+#define HTTPS_STR "\x1B[1;32m"
+
+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);
+
+int url_encode(const void *in, size_t size_in, char *out, size_t size_out);
+
+int url_decode(const char *str, char *dec, long *size);
+
+int mime_is_compressible(const char *type);
+
+int strcpy_rem_webroot(char *dst, const char *str, long len, const char *webroot);
+
+int str_trim(char **start, char **end);
+
+int str_trim_lws(char **start, char **end);
+
+int base64_encode(void *data, unsigned long data_len, char *output, unsigned long *output_len);
+
+#endif //SESIMOS_UTILS_H

src/lib/websocket.c

@@ -0,0 +1,208 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief WebSocket reverse proxy
+ * @file src/lib/websocket.c
+ * @author Lorenz Stechauner
+ * @date 2022-08-16
+ */
+
+#include "../defs.h"
+#include "../logger.h"
+#include "websocket.h"
+#include "utils.h"
+
+#include <string.h>
+#include <openssl/sha.h>
+#include <errno.h>
+#include <signal.h>
+
+static const char ws_key_uuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+static volatile sig_atomic_t terminate = 0;
+
+void ws_terminate(int _) {
+    terminate = 1;
+}
+
+int ws_calc_accept_key(const char *key, char *accept_key) {
+    if (key == NULL || accept_key == NULL)
+        return -1;
+
+    char input[256] = "";
+    unsigned char output[SHA_DIGEST_LENGTH];
+    strcat(input, key);
+    strcat(input, ws_key_uuid);
+
+    if (SHA1((unsigned char *) input, strlen(input), output) == NULL) {
+        return -2;
+    }
+
+    base64_encode(output, sizeof(output), accept_key, NULL);
+
+    return 0;
+}
+
+int ws_recv_frame_header(sock *s, ws_frame *frame) {
+    unsigned char buf[12];
+
+    long ret = sock_recv(s, buf, 2, 0);
+    if (ret < 0) {
+        error("Unable to receive from socket");
+        return -1;
+    } else if (ret != 2) {
+        error("Unable to receive 2 bytes from socket");
+        return -2;
+    }
+
+    unsigned short bits = (buf[0] << 8) | buf[1];
+    frame->f_fin = (bits >> 15) & 1;
+    frame->f_rsv1 = (bits >> 14) & 1;
+    frame->f_rsv2 = (bits >> 13) & 1;
+    frame->f_rsv3 = (bits >> 12) & 1;
+    frame->opcode = (bits >> 8) & 0xF;
+    frame->f_mask = (bits >> 7) & 1;
+    unsigned short len = (bits & 0x7F);
+
+    int remaining = frame->f_mask ? 4 : 0;
+    if (len == 126) {
+        remaining += 2;
+    } else if (len == 127) {
+        remaining += 8;
+    }
+
+    ret = sock_recv(s, buf, remaining, 0);
+    if (ret < 0) {
+        error("Unable to receive from socket");
+        return -1;
+    } else if (ret != remaining) {
+        error("Unable to receive correct number of bytes from socket");
+        return -2;
+    }
+
+    if (len == 126) {
+        frame->len = (((unsigned long) buf[0]) << 8) | ((unsigned long) buf[1]);
+    } else if (len == 127) {
+        frame->len =
+                (((unsigned long) buf[0]) << 56) |
+                (((unsigned long) buf[1]) << 48) |
+                (((unsigned long) buf[2]) << 40) |
+                (((unsigned long) buf[3]) << 32) |
+                (((unsigned long) buf[4]) << 24) |
+                (((unsigned long) buf[5]) << 16) |
+                (((unsigned long) buf[6]) << 8) |
+                (((unsigned long) buf[7]) << 0);
+    } else {
+        frame->len = len;
+    }
+
+    if (frame->f_mask) memcpy(frame->masking_key, buf + (remaining - 4), 4);
+
+    return 0;
+}
+
+int ws_send_frame_header(sock *s, ws_frame *frame) {
+    unsigned char buf[14], *ptr = buf;
+
+    unsigned short len;
+    if (frame->len > 0x7FFF) {
+        len = 127;
+    } else if (frame->len > 125) {
+        len = 126;
+    } else {
+        len = frame->len;
+    }
+
+    unsigned short bits =
+            (frame->f_fin << 15) |
+            (frame->f_rsv1 << 14) |
+            (frame->f_rsv2 << 13) |
+            (frame->f_rsv3 << 12) |
+            (frame->opcode << 8) |
+            (frame->f_mask << 7) |
+            len;
+
+    ptr++[0] = bits >> 8;
+    ptr++[0] = bits & 0xFF;
+
+    if (len >= 126) {
+        for (int i = (len == 126 ? 2 : 8) - 1; i >= 0; i--)
+            ptr++[0] = (unsigned char) ((frame->len >> (i * 8)) & 0xFF);
+    }
+
+    if (frame->f_mask) {
+        memcpy(ptr, frame->masking_key, 4);
+        ptr += 4;
+    }
+
+    long ret = sock_send(s, buf, ptr - buf, frame->len != 0 ? MSG_MORE : 0);
+    if (ret < 0) {
+        error("Unable to send to socket");
+        return -1;
+    } else if (ret != ptr - buf) {
+        error("Unable to send to socket");
+        return -2;
+    }
+
+    return 0;
+}
+
+int ws_handle_connection(sock *s1, sock *s2) {
+    sock *poll_socks[2] = {s1, s2};
+    sock *readable[2], *error[2];
+    int n_sock = 2, n_readable = 0, n_error = 0;
+    ws_frame frame;
+    char buf[CHUNK_SIZE];
+    int closes = 0;
+    long ret;
+
+    signal(SIGINT, ws_terminate);
+    signal(SIGTERM, ws_terminate);
+
+    while (!terminate && closes != 3) {
+        ret = sock_poll_read(poll_socks, readable, error, n_sock, &n_readable, &n_error, WS_TIMEOUT * 1000);
+        if (terminate) {
+            break;
+        } else if (ret < 0) {
+            error("Unable to poll sockets");
+            return -1;
+        } else if (n_readable == 0) {
+            error("Connection timed out");
+            return -2;
+        } else if (n_error > 0) {
+            error("Peer closed connection");
+            return -3;
+        }
+
+        for (int i = 0; i < n_readable; i++) {
+            sock *s = readable[i];
+            sock *o = (s == s1) ? s2 : s1;
+            if (ws_recv_frame_header(s, &frame) != 0) return -3;
+
+            // debug("WebSocket: Peer %s, Opcode=0x%X, Len=%li", (s == s1) ? "1" : "2", frame.opcode, frame.len);
+
+            if (frame.opcode == 0x8) {
+                n_sock--;
+                if (s == s1) {
+                    poll_socks[0] = s2;
+                    closes |= 1;
+                } else {
+                    closes |= 2;
+                }
+            }
+
+            if (ws_send_frame_header(o, &frame) != 0) return -3;
+
+            if (frame.len > 0) {
+                ret = sock_splice(o, s, buf, sizeof(buf), frame.len);
+                if (ret < 0) {
+                    error("Unable to forward data in WebSocket");
+                    return -4;
+                } else if (ret != frame.len) {
+                    error("Unable to forward correct number of bytes in WebSocket");
+                    return -4;
+                }
+            }
+        }
+    }
+
+    return 0;
+}

src/lib/websocket.h

@@ -0,0 +1,35 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief WebSocket reverse proxy (header file)
+ * @file src/lib/websocket.h
+ * @author Lorenz Stechauner
+ * @date 2022-08-16
+ */
+
+#ifndef SESIMOS_WEBSOCKET_H
+#define SESIMOS_WEBSOCKET_H
+
+#include "sock.h"
+
+#define WS_TIMEOUT 3600
+
+typedef struct {
+    unsigned char f_fin:1;
+    unsigned char f_rsv1:1;
+    unsigned char f_rsv2:1;
+    unsigned char f_rsv3:1;
+    unsigned char opcode:4;
+    unsigned char f_mask:1;
+    unsigned long len;
+    char masking_key[4];
+} ws_frame;
+
+int ws_calc_accept_key(const char *key, char *accept_key);
+
+int ws_recv_frame_header(sock *s, ws_frame *frame);
+
+int ws_send_frame_header(sock *s, ws_frame *frame);
+
+int ws_handle_connection(sock *s1, sock *s2);
+
+#endif //SESIMOS_WEBSOCKET_H

src/logger.c

@@ -0,0 +1,253 @@
+/**
+ * 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 8
+#define LOG_PREFIX_LEN 256
+
+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 volatile sig_atomic_t logger_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 "[%6s][logger] %s: %s" CLR_STR "\n", 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 (!logger_alive) {
+        // no logger thread running
+        // simply write to stdout without synchronization
+        printf("%s[%-6s][%-6s]%s%s ", color, level_keywords[level], (name != NULL) ? (char *) name : "", 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) {
+                goto try_again_free;
+            } else {
+                err("Unable to lock semaphore");
+            }
+            // cleanup
+            va_end(args);
+            return;
+        }
+
+        // try to lock buffer
+        try_again_buf:
+        if (sem_wait(&sem_buf) != 0) {
+            if (errno == EINTR) {
+                goto try_again_buf;
+            } else {
+                err("Unable to lock semaphore");
+            }
+            // 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_init(void) {
+    int ret;
+
+    // try to initialize all three semaphores
+    if (sem_init(&sem_buf, 0, 1) != 0 || sem_init(&sem_buf_free, 0, 1) != 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;
+    }
+
+    return 0;
+}
+
+static int logger_remaining(void) {
+    int val = 0;
+    sem_getvalue(&sem_buf_used, &val);
+    return val;
+}
+
+void logger_set_name(const char *restrict name) {
+    if (key_name == -1) {
+        // not initialized
+        strncpy(global_name, name, sizeof(global_name));
+    } 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;
+            }
+        }
+        strncpy(ptr, name, LOG_NAME_LEN);
+    }
+}
+
+void logger_set_prefix(const char *restrict prefix) {
+    if (key_name == -1) {
+        strncpy(global_prefix, prefix, sizeof(global_prefix));
+    } else {
+        int ret;
+        void *ptr = pthread_getspecific(key_name);
+        if (!ptr) {
+            ptr = malloc(LOG_PREFIX_LEN);
+            pthread_setspecific(key_prefix, ptr);
+            if ((ret = pthread_setspecific(key_prefix, ptr)) != 0) {
+                errno = ret;
+                err("Unable to set thread specific values");
+                return;
+            }
+        }
+        strncpy(ptr, prefix, LOG_PREFIX_LEN);
+    }
+}
+
+void logger_stop(void) {
+    logger_alive = 0;
+}
+
+void logger(void) {
+    if (logger_init() != 0)
+        return;
+
+    logger_set_name("logger");
+    logger_alive = 1;
+
+    while (logger_alive || logger_remaining() > 0) {
+        // wait for buffer to be filled
+        if (sem_wait(&sem_buf_used) != 0) {
+            if (errno == EINTR) {
+                continue;
+            } else {
+                err("Unable to lock semaphore");
+                break;
+            }
+        }
+
+        log_msg_t *msg = &buffer.msgs[buffer.wr];
+        buffer.wr = (buffer.wr + 1) % LOG_BUF_SIZE;
+
+        printf("[%s]%s %s\n", msg->name, (msg->prefix[0] != 0) ? msg->prefix : "", msg->txt);
+
+        // unlock slot in buffer
+        sem_post(&sem_buf_free);
+    }
+
+    logger_destroy();
+}

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 name);
+
+void logger_set_prefix(const char *restrict prefix);
+
+void logger(void);
+
+void logger_stop(void);
+
+#endif //SESIMOS_LOGGER_H

src/necronda-server.h

@@ -1,86 +0,0 @@
-/**
- * Necronda Web Server
- * Main executable (header file)
- * src/necronda-server.c
- * Lorenz Stechauner, 2020-12-03
- */
-
-#ifndef NECRONDA_SERVER_NECRONDA_SERVER_H
-#define NECRONDA_SERVER_NECRONDA_SERVER_H
-
-#include <stdio.h>
-#include <sys/socket.h>
-#include <signal.h>
-#include <unistd.h>
-#include <sys/select.h>
-#include <string.h>
-#include <errno.h>
-#include <arpa/inet.h>
-#include <wait.h>
-#include <sys/types.h>
-#include <stdio.h>
-#include <openssl/err.h>
-#include <openssl/pem.h>
-#include <openssl/ssl.h>
-#include <openssl/conf.h>
-#include <openssl/engine.h>
-#include <openssl/dh.h>
-#include <maxminddb.h>
-#include <dirent.h>
-
-
-#define NUM_SOCKETS 2
-#define MAX_CHILDREN 1024
-#define MAX_MMDB 3
-#define MAX_HOST_CONFIG 64
-#define LISTEN_BACKLOG 16
-#define REQ_PER_CONNECTION 100
-#define CLIENT_TIMEOUT 3600
-#define SERVER_TIMEOUT 4
-
-#define CHUNK_SIZE 8192
-#define CLIENT_MAX_HEADER_SIZE 8192
-#define FILE_CACHE_SIZE 1024
-#define GEOIP_MAX_SIZE 8192
-
-#define SHM_KEY_CACHE 255641
-#define SHM_KEY_CONFIG 255642
-
-#define ERR_STR "\x1B[1;31m"
-#define CLR_STR "\x1B[0m"
-#define BLD_STR "\x1B[1m"
-#define WRN_STR "\x1B[1;33m"
-#define BLUE_STR "\x1B[34m"
-#define HTTP_STR "\x1B[1;31m"
-#define HTTPS_STR "\x1B[1;32m"
-
-#define HTTP_1XX_STR "\x1B[1;32m"
-#define HTTP_2XX_STR "\x1B[1;32m"
-#define HTTP_3XX_STR "\x1B[1;33m"
-#define HTTP_4XX_STR "\x1B[1;31m"
-#define HTTP_5XX_STR "\x1B[1;31m"
-
-#define NECRONDA_VERSION "4.3"
-#define SERVER_STR "Necronda/" NECRONDA_VERSION
-#define NECRONDA_ZLIB_LEVEL 9
-
-#ifndef DEFAULT_HOST
-#define DEFAULT_HOST "www.necronda.net"
-#endif
-#ifndef MAGIC_FILE
-#define MAGIC_FILE "/usr/share/file/misc/magic.mgc"
-#endif
-#ifndef PHP_FPM_SOCKET
-#define PHP_FPM_SOCKET "/var/run/php-fpm/php-fpm.sock"
-#endif
-#ifndef DEFAULT_CONFIG_FILE
-#define DEFAULT_CONFIG_FILE "/etc/necronda-server/necronda-server.conf"
-#endif
-
-int sockets[NUM_SOCKETS];
-pid_t children[MAX_CHILDREN];
-MMDB_s mmdbs[MAX_MMDB];
-
-char *client_addr_str, *client_addr_str_ptr, *server_addr_str, *server_addr_str_ptr, *client_host_str;
-
-#endif //NECRONDA_SERVER_NECRONDA_SERVER_H

src/rev_proxy.c

@@ -1,406 +0,0 @@
-/**
- * Necronda Web Server
- * Reverse proxy
- * src/rev_proxy.c
- * Lorenz Stechauner, 2021-01-07
- */
-
-#include "rev_proxy.h"
-
-sock rev_proxy;
-char *rev_proxy_host = NULL;
-struct timeval server_timeout = {.tv_sec = SERVER_TIMEOUT, .tv_usec = 0};
-
-int rev_proxy_request_header(http_req *req, int enc) {
-    char buf1[256];
-    char buf2[256];
-    int p_len;
-    http_remove_header_field(&req->hdr, "Connection", HTTP_REMOVE_ALL);
-    http_add_header_field(&req->hdr, "Connection", "keep-alive");
-
-    char *via = http_get_header_field(&req->hdr, "Via");
-    sprintf(buf1, "HTTP/%s %s", req->version, DEFAULT_HOST);
-    if (via == NULL) {
-        http_add_header_field(&req->hdr, "Via", buf1);
-    } 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);
-            return -1;
-        }
-        http_remove_header_field(&req->hdr, "Via", HTTP_REMOVE_ALL);
-        http_add_header_field(&req->hdr, "Via", buf2);
-    }
-
-    char *host = http_get_header_field(&req->hdr, "Host");
-    char *forwarded = http_get_header_field(&req->hdr, "Forwarded");
-    int client_ipv6 = strchr(client_addr_str, ':') != NULL;
-    int server_ipv6 =  strchr(server_addr_str, ':') != 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 ? "]\"" : "",
-                     client_ipv6 ? "\"[" : "", client_addr_str, client_ipv6 ? "]\"" : "",
-                     host, enc ? "https" : "http");
-    if (p_len < 0 || p_len >= sizeof(buf1)) {
-        print(ERR_STR "Appended part of header field 'Forwarded' too long" CLR_STR);
-        return -1;
-    }
-    if (forwarded == NULL) {
-        http_add_header_field(&req->hdr, "Forwarded", buf1);
-    } 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);
-            return -1;
-        }
-        http_remove_header_field(&req->hdr, "Forwarded", HTTP_REMOVE_ALL);
-        http_add_header_field(&req->hdr, "Forwarded", buf2);
-    }
-
-    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);
-    } else {
-        sprintf(buf1, "%s, %s", xff, client_addr_str);
-        http_remove_header_field(&req->hdr, "X-Forwarded-For", HTTP_REMOVE_ALL);
-        http_add_header_field(&req->hdr, "X-Forwarded-For", buf1);
-    }
-
-    char *xfh = http_get_header_field(&req->hdr, "X-Forwarded-Host");
-    if (xfh == NULL) {
-        if (forwarded == NULL) {
-            http_add_header_field(&req->hdr, "X-Forwarded-Host", host);
-        } else {
-            char *ptr = strchr(forwarded, ',');
-            unsigned long len;
-            if (ptr != NULL) len = ptr - forwarded;
-            else len = strlen(forwarded);
-            ptr = strstr(forwarded, "host=");
-            if ((ptr - forwarded) < len) {
-                char *end = strchr(ptr, ';');
-                if (end == NULL) len -= (ptr - forwarded);
-                else len = (end - ptr);
-                len -= 5;
-                sprintf(buf1, "%.*s", (int) len, ptr + 5);
-                http_add_header_field(&req->hdr, "X-Forwarded-Host", buf1);
-            }
-        }
-    }
-
-    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");
-        } else {
-            char *ptr = strchr(forwarded, ',');
-            unsigned long len;
-            if (ptr != NULL) len = ptr - forwarded;
-            else len = strlen(forwarded);
-            ptr = strstr(forwarded, "proto=");
-            if ((ptr - forwarded) < len) {
-                char *end = strchr(ptr, ';');
-                if (end == NULL) len -= (ptr - forwarded);
-                else len = (end - ptr);
-                len -= 6;
-                sprintf(buf1, "%.*s", (int) len, ptr + 6);
-                http_add_header_field(&req->hdr, "X-Forwarded-Proto", buf1);
-            }
-        }
-    }
-
-    return 0;
-}
-
-int rev_proxy_response_header(http_req *req, http_res *res) {
-    char buf1[256];
-    char buf2[256];
-    int p_len;
-
-    char *via = http_get_header_field(&res->hdr, "Via");
-    p_len = snprintf(buf1, sizeof(buf1), "HTTP/%s %s", req->version, DEFAULT_HOST);
-    if (p_len < 0 || p_len >= sizeof(buf1)) {
-        print(ERR_STR "Appended part of header field 'Via' too long" CLR_STR);
-        return -1;
-    }
-    if (via == NULL) {
-        http_add_header_field(&res->hdr, "Via", buf1);
-    } 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);
-            return -1;
-        }
-        http_remove_header_field(&res->hdr, "Via", HTTP_REMOVE_ALL);
-        http_add_header_field(&res->hdr, "Via", buf2);
-    }
-
-    return 0;
-}
-
-int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client, http_status *custom_status,
-                   char *err_msg) {
-    char buffer[CHUNK_SIZE];
-    long ret;
-    int tries = 0;
-    int retry = 0;
-
-    if (rev_proxy.socket != 0 && strcmp(rev_proxy_host, conf->name) == 0 && sock_check(&rev_proxy) == 0) {
-        goto rev_proxy;
-    }
-
-    retry:
-    if (rev_proxy.socket != 0) {
-        print(BLUE_STR "Closing proxy connection" CLR_STR);
-        sock_close(&rev_proxy);
-    }
-    retry = 0;
-    tries++;
-
-    rev_proxy.socket = socket(AF_INET6, SOCK_STREAM, 0);
-    if (rev_proxy.socket  < 0) {
-        print(ERR_STR "Unable to create socket: %s" CLR_STR, strerror(errno));
-        res->status = http_get_status(500);
-        return -1;
-    }
-
-    server_timeout.tv_sec = SERVER_TIMEOUT;
-    server_timeout.tv_usec = 0;
-    if (setsockopt(client->socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
-        goto rev_proxy_timeout_err;
-    if (setsockopt(client->socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) {
-        rev_proxy_timeout_err:
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to set timeout for socket: %s" CLR_STR, strerror(errno));
-        sprintf(err_msg, "Unable to set timeout for socket: %s", strerror(errno));
-        goto proxy_err;
-    }
-
-    struct hostent *host_ent = gethostbyname(conf->rev_proxy.hostname);
-    if (host_ent == NULL) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to connect to server: Name or service not known" CLR_STR);
-        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)};
-    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) {
-        unsigned char addr[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0, 0, 0, 0};
-        memcpy(addr + 12, host_ent->h_addr_list[0], host_ent->h_length);
-        memcpy(&address.sin6_addr, addr, 16);
-    }
-
-    if (connect(rev_proxy.socket, (struct sockaddr *) &address, sizeof(address)) < 0) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to connect to server: %s" CLR_STR, strerror(errno));
-        sprintf(err_msg, "Unable to connect to server: %s.", strerror(errno));
-        goto proxy_err;
-    }
-
-    if (conf->rev_proxy.enc) {
-        rev_proxy.ssl = SSL_new(rev_proxy.ctx);
-        SSL_set_fd(rev_proxy.ssl, rev_proxy.socket);
-        SSL_set_connect_state(rev_proxy.ssl);
-
-        ret = SSL_do_handshake(rev_proxy.ssl);
-        rev_proxy._last_ret = ret;
-        rev_proxy._errno = errno;
-        rev_proxy._ssl_error = ERR_get_error();
-        rev_proxy.enc = 1;
-        if (ret < 0) {
-            res->status = http_get_status(502);
-            print(ERR_STR "Unable to perform handshake: %s" CLR_STR, sock_strerror(&rev_proxy));
-            sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&rev_proxy));
-            goto proxy_err;
-        }
-    }
-
-    rev_proxy_host = conf->name;
-    inet_ntop(address.sin6_family, (void *) &address.sin6_addr, buffer, sizeof(buffer));
-    print(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i" CLR_STR, buffer, conf->rev_proxy.port);
-
-    rev_proxy:
-    ret = rev_proxy_request_header(req, (int) client->enc);
-    if (ret != 0) {
-        res->status = http_get_status(500);
-        return -1;
-    }
-
-    ret = http_send_request(&rev_proxy, req);
-    if (ret < 0) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to send request to server (1): %s" CLR_STR, sock_strerror(&rev_proxy));
-        sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
-        retry = tries < 4;
-        goto proxy_err;
-    }
-
-    char *content_length = http_get_header_field(&req->hdr, "Content-Length");
-    if (content_length != NULL) {
-        unsigned long content_len = strtoul(content_length, NULL, 10);
-        if (client->buf_len - client->buf_off > 0) {
-            unsigned long len = client->buf_len - client->buf_off;
-            if (len > content_len) {
-                len = content_len;
-            }
-            ret = sock_send(&rev_proxy, client->buf, len, 0);
-            if (ret <= 0) {
-                res->status = http_get_status(502);
-                print(ERR_STR "Unable to send request to server (2): %s" CLR_STR, sock_strerror(&rev_proxy));
-                sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
-                retry = tries < 4;
-                goto proxy_err;
-            }
-            content_len -= len;
-        }
-        if (content_len > 0) {
-            ret = sock_splice(&rev_proxy, client, buffer, sizeof(buffer), content_len);
-            if (ret <= 0) {
-                if (ret == -1) {
-                    res->status = http_get_status(502);
-                    print(ERR_STR "Unable to send request to server (3): %s" CLR_STR, sock_strerror(&rev_proxy));
-                    sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
-                    goto proxy_err;
-                } else if (ret == -2) {
-                    res->status = http_get_status(400);
-                    print(ERR_STR "Unable to receive request from client: %s" CLR_STR, sock_strerror(client));
-                    sprintf(err_msg, "Unable to receive request from client: %s.", sock_strerror(client));
-                    return -1;
-                }
-                res->status = http_get_status(500);
-                print(ERR_STR "Unknown Error" CLR_STR);
-                return -1;
-            }
-        }
-    }
-
-    ret = sock_recv(&rev_proxy, buffer, sizeof(buffer), MSG_PEEK);
-    if (ret <= 0) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to receive response from server: %s" CLR_STR, sock_strerror(&rev_proxy));
-        sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&rev_proxy));
-        goto proxy_err;
-    }
-
-    char *buf = buffer;
-    unsigned short header_len = (unsigned short) (strstr(buffer, "\r\n\r\n") - buffer + 4);
-
-    if (header_len <= 0) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to parse header: End of header not found" CLR_STR);
-        sprintf(err_msg, "Unable to parser header: End of header not found.");
-        goto proxy_err;
-    }
-
-    for (int i = 0; i < header_len; i++) {
-        if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
-            res->status = http_get_status(502);
-            print(ERR_STR "Unable to parse header: Header contains illegal characters" CLR_STR);
-            sprintf(err_msg, "Unable to parse header: Header contains illegal characters.");
-            goto proxy_err;
-        }
-    }
-
-    char *ptr = buf;
-    while (header_len != (ptr - buf)) {
-        char *pos0 = strstr(ptr, "\r\n");
-        if (pos0 == NULL) {
-            res->status = http_get_status(502);
-            print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
-            sprintf(err_msg, "Unable to parse header: Invalid header format.");
-            goto proxy_err;
-        }
-        if (ptr == buf) {
-            if (strncmp(ptr, "HTTP/", 5) != 0) {
-                res->status = http_get_status(502);
-                print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
-                sprintf(err_msg, "Unable to parse header: Invalid header format.");
-                goto proxy_err;
-            }
-            int status_code = (int) strtol(ptr + 9, NULL, 10);
-            res->status = http_get_status(status_code);
-            if (res->status == NULL && status_code >= 100 && status_code <= 999) {
-                custom_status->code = status_code;
-                strcpy(custom_status->type, "");
-                strncpy(custom_status->msg, ptr + 13, strchr(ptr, '\r') - ptr - 13);
-                res->status = custom_status;
-            } else if (res->status == NULL) {
-                res->status = http_get_status(502);
-                print(ERR_STR "Unable to parse header: Invalid or unknown status code" CLR_STR);
-                sprintf(err_msg, "Unable to parse header: Invalid or unknown status code.");
-                goto proxy_err;
-            }
-        } else {
-            ret = http_parse_header_field(&res->hdr, ptr, pos0);
-            if (ret != 0) {
-                res->status = http_get_status(502);
-                print(ERR_STR "Unable to parse header" CLR_STR);
-                sprintf(err_msg, "Unable to parse header.");
-                goto proxy_err;
-            }
-        }
-        if (pos0[2] == '\r' && pos0[3] == '\n') {
-            break;
-        }
-        ptr = pos0 + 2;
-    }
-    sock_recv(&rev_proxy, buffer, header_len, 0);
-
-    ret = rev_proxy_response_header(req, res);
-    if (ret != 0) {
-        res->status = http_get_status(500);
-        return -1;
-    }
-
-    return 0;
-
-    proxy_err:
-    if (retry) goto retry;
-    return -1;
-}
-
-int rev_proxy_send(sock *client, int chunked, unsigned long len_to_send) {
-    long ret;
-    char buffer[CHUNK_SIZE];
-    long len, snd_len;
-    // TODO handle websockets
-    do {
-        if (chunked) {
-            ret = sock_recv(&rev_proxy, buffer, 16, MSG_PEEK);
-            if (ret <= 0) {
-                print("Unable to receive: %s", sock_strerror(&rev_proxy));
-                break;
-            }
-
-            len_to_send = strtol(buffer, NULL, 16);
-            char *pos = strstr(buffer, "\r\n");
-            len = pos - buffer + 2;
-            ret = sock_send(client, buffer, len, 0);
-
-            sock_recv(&rev_proxy, buffer, len, 0);
-            if (ret <= 0) break;
-        }
-        snd_len = 0;
-        while (snd_len < len_to_send) {
-            len = sock_recv(&rev_proxy, buffer, CHUNK_SIZE < (len_to_send - snd_len) ? CHUNK_SIZE : len_to_send - snd_len, 0);
-            ret = sock_send(client, buffer, len, 0);
-            if (ret <= 0) {
-                print(ERR_STR "Unable to send: %s" CLR_STR, sock_strerror(client));
-                break;
-            }
-            snd_len += ret;
-        }
-        if (ret <= 0) break;
-        if (chunked) {
-            sock_recv(&rev_proxy, buffer, 2, 0);
-            ret = sock_send(client, "\r\n", 2, 0);
-            if (ret <= 0) {
-                print(ERR_STR "Unable to send: %s" CLR_STR, sock_strerror(client));
-                break;
-            }
-        }
-    } while (chunked && len_to_send > 0);
-    return 0;
-}

src/rev_proxy.h

@@ -1,20 +0,0 @@
-/**
- * Necronda Web Server
- * Reverse proxy (header file)
- * src/rev_proxy.h
- * Lorenz Stechauner, 2021-01-07
- */
-
-#ifndef NECRONDA_SERVER_REV_PROXY_H
-#define NECRONDA_SERVER_REV_PROXY_H
-
-int rev_proxy_request_header(http_req *req, int enc);
-
-int rev_proxy_response_header(http_req *req, http_res *res);
-
-int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client, http_status *custom_status,
-                   char *err_msg);
-
-int rev_proxy_send(sock *client, int chunked, unsigned long len_to_send);
-
-#endif //NECRONDA_SERVER_REV_PROXY_H

src/server.c

@@ -1,38 +1,58 @@
 /**
- * Necronda Web Server
- * Main executable
- * src/necronda-server.c
- * Lorenz Stechauner, 2020-12-03
+ * Sesimos - secure, simple, modern web server
+ * @brief Main executable
+ * @file src/server.c
+ * @author Lorenz Stechauner
+ * @date 2020-12-03
  */
 
-#define _POSIX_C_SOURCE 199309L
+#include "defs.h"
+#include "server.h"
+#include "client.h"
+#include "logger.h"
 
-#include "necronda-server.h"
+#include "lib/cache.h"
+#include "lib/config.h"
+#include "lib/sock.h"
+#include "lib/rev_proxy.h"
+#include "lib/geoip.h"
+#include "lib/utils.h"
 
-#include "config.c"
-#include "utils.c"
-#include "uri.c"
-#include "cache.c"
-#include "sock.c"
-#include "http.c"
-#include "rev_proxy.c"
-#include "client.c"
-#include "fastcgi.c"
+#include <stdio.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>
 
 
-int active = 1;
+volatile sig_atomic_t active = 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() {
-    SSL_library_init();
-    SSL_load_error_strings();
-    ERR_load_BIO_strings();
-    OpenSSL_add_all_algorithms();
+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);
+        if (conf != NULL) SSL_set_SSL_CTX(ssl, contexts[conf->cert]);
+    }
+    return SSL_TLSEXT_ERR_OK;
 }
 
-void destroy() {
-    fprintf(stderr, "\n" ERR_STR "Terminating forcefully!" CLR_STR "\n");
+void destroy(int sig) {
+    critical("Terminating forcefully!");
     int status = 0;
     int ret;
     int kills = 0;
@@ -40,13 +60,11 @@ void destroy() {
         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));
+                error("Unable to wait for child process (PID %i)", children[i]);
             } 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);
+                    error("Child process with PID %i terminated with exit code %i", ret, status);
                 }
             } else {
                 kill(children[i], SIGKILL);
@@ -55,15 +73,16 @@ void destroy() {
         }
     }
     if (kills > 0) {
-        fprintf(stderr, ERR_STR "Killed %i child process(es)" CLR_STR "\n", kills);
+        critical("Killed %i child process(es)", kills);
     }
     cache_unload();
     config_unload();
     exit(2);
 }
 
-void terminate() {
-    fprintf(stderr, "\nTerminating gracefully...\n");
+void terminate(int sig) {
+    fprintf(stderr, "\n");
+    notice("Terminating gracefully...");
     active = 0;
 
     signal(SIGINT, destroy);
@@ -81,13 +100,11 @@ void terminate() {
         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));
+                critical("Unable to wait for child process (PID %i)", children[i]);
             } 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);
+                    critical("Child process with PID %i terminated with exit code %i", ret, status);
                 }
             } else {
                 kill(children[i], SIGTERM);
@@ -97,20 +114,18 @@ void terminate() {
     }
 
     if (wait_num > 0) {
-        fprintf(stderr, "Waiting for %i child process(es)...\n", wait_num);
+        notice("Waiting for %i child process(es)...", 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));
+                critical("Unable to wait for child process (PID %i)", children[i]);
             } 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);
+                    critical("Child process with PID %i terminated with exit code %i", ret, status);
                 }
             }
         }
@@ -122,10 +137,9 @@ void terminate() {
         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");
     }
+
+    info("Goodbye");
     cache_unload();
     config_unload();
     exit(0);
@@ -133,8 +147,7 @@ void terminate() {
 
 int main(int argc, const char *argv[]) {
     const int YES = 1;
-    fd_set socket_fds, read_socket_fds;
-    int max_socket_fd = 0;
+    struct pollfd poll_fds[NUM_SOCKETS];
     int ready_sockets_num;
     long client_num = 0;
     char buf[1024];
@@ -149,18 +162,18 @@ int main(int argc, const char *argv[]) {
     memset(children, 0, sizeof(children));
     memset(mmdbs, 0, sizeof(mmdbs));
 
-    struct timeval timeout;
-
     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) {
-        fprintf(stderr, ERR_STR "Unable to set stdout to line-buffered mode: %s" CLR_STR, strerror(errno));
+    logger_set_name("server");
+
+    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("Necronda Web Server " NECRONDA_VERSION "\n");
+    printf("Sesimos web server " SERVER_VERSION "\n");
 
     ret = config_init();
     if (ret != 0) {
@@ -171,7 +184,7 @@ int main(int argc, const char *argv[]) {
     for (int i = 1; i < argc; i++) {
         const char *arg = argv[i];
         if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
-            printf("Usage: necronda-server [-h] [-c <CONFIG-FILE>]\n"
+            printf("Usage: sesimos [-h] [-c <CONFIG-FILE>]\n"
                    "\n"
                    "Options:\n"
                    "  -c, --config <CONFIG-FILE>  path to the config file. If not provided, default will be used\n"
@@ -180,13 +193,13 @@ int main(int argc, const char *argv[]) {
             return 0;
         } else if (strcmp(arg, "-c") == 0 || strcmp(arg, "--config") == 0) {
             if (i == argc - 1) {
-                fprintf(stderr, ERR_STR "Unable to parse argument %s, usage: --config <CONFIG-FILE>" CLR_STR "\n", arg);
+                critical("Unable to parse argument %s, usage: --config <CONFIG-FILE>", arg);
                 config_unload();
                 return 1;
             }
             config_file = argv[++i];
         } else {
-            fprintf(stderr, ERR_STR "Unable to parse argument '%s'" CLR_STR "\n", arg);
+            critical("Unable to parse argument '%s'", arg);
             config_unload();
             return 1;
         }
@@ -203,14 +216,14 @@ int main(int argc, const char *argv[]) {
     sockets[1] = socket(AF_INET6, SOCK_STREAM, 0);
     if (sockets[1] < 0) {
         socket_err:
-        fprintf(stderr, ERR_STR "Unable to create socket: %s" CLR_STR "\n", strerror(errno));
+        critical("Unable to create socket");
         config_unload();
         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;
         }
@@ -219,7 +232,7 @@ int main(int argc, const char *argv[]) {
     if (bind(sockets[0], (struct sockaddr *) &addresses[0], sizeof(addresses[0])) < 0) goto bind_err;
     if (bind(sockets[1], (struct sockaddr *) &addresses[1], sizeof(addresses[1])) < 0) {
         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;
     }
@@ -230,7 +243,7 @@ int main(int argc, const char *argv[]) {
     if (geoip_dir[0] != 0) {
         DIR *geoip = opendir(geoip_dir);
         if (geoip == NULL) {
-            fprintf(stderr, ERR_STR "Unable to open GeoIP dir: %s" CLR_STR "\n", strerror(errno));
+            critical("Unable to open GeoIP dir");
             config_unload();
             return 1;
         }
@@ -239,100 +252,100 @@ int main(int argc, const char *argv[]) {
         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");
+                critical("Too many .mmdb files");
                 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));
+                critical("Unable to open .mmdb file: %s", 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);
+            critical("No .mmdb files found in %s", geoip_dir);
             config_unload();
             return 1;
         }
         closedir(geoip);
     }
 
-    openssl_init();
-
-    client.buf = NULL;
-    client.buf_len = 0;
-    client.buf_off = 0;
-    client.ctx = SSL_CTX_new(TLS_server_method());
-    SSL_CTX_set_options(client.ctx, SSL_OP_SINGLE_DH_USE);
-    SSL_CTX_set_verify(client.ctx, SSL_VERIFY_NONE, NULL);
-    SSL_CTX_set_min_proto_version(client.ctx, TLS1_VERSION);
-    SSL_CTX_set_mode(client.ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
-    SSL_CTX_set_cipher_list(client.ctx, "HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4");
-    SSL_CTX_set_ecdh_auto(client.ctx, 1);
-
-    rev_proxy.buf = NULL;
-    rev_proxy.buf_len = 0;
-    rev_proxy.buf_off = 0;
-    rev_proxy.ctx = SSL_CTX_new(TLS_client_method());
-
-    if (SSL_CTX_use_certificate_chain_file(client.ctx, cert_file) != 1) {
-        fprintf(stderr, ERR_STR "Unable to load certificate chain file: %s: %s" CLR_STR "\n",
-                ERR_reason_error_string(ERR_get_error()), cert_file);
-        config_unload();
-        return 1;
-    }
-    if (SSL_CTX_use_PrivateKey_file(client.ctx, key_file, 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()), key_file);
-        config_unload();
-        return 1;
-    }
-
-    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));
-            config_unload();
-            return 1;
-        }
-    }
-
-    FD_ZERO(&socket_fds);
-    for (int i = 0; i < NUM_SOCKETS; i++) {
-        FD_SET(sockets[i], &socket_fds);
-        if (sockets[i] > max_socket_fd) {
-            max_socket_fd = sockets[i];
-        }
-    }
-
     ret = cache_init();
     if (ret < 0) {
         config_unload();
         return 1;
     } else if (ret != 0) {
+        children[0] = ret;  // pid
+    } else {
         return 0;
     }
 
-    fprintf(stderr, "Ready to accept connections\n");
+    for (int i = 0; i < CONFIG_MAX_CERT_CONFIG; i++) {
+        const cert_config *conf = &config->certs[i];
+        if (conf->name[0] == 0) break;
+
+        contexts[i] = SSL_CTX_new(TLS_server_method());
+        SSL_CTX *ctx = contexts[i];
+        SSL_CTX_set_options(ctx, SSL_OP_SINGLE_DH_USE);
+        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
+        SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);
+        SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
+        SSL_CTX_set_cipher_list(ctx, "HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4");
+        SSL_CTX_set_ecdh_auto(ctx, 1);
+        SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
+
+        if (SSL_CTX_use_certificate_chain_file(ctx, conf->full_chain) != 1) {
+            critical("Unable to load certificate chain file: %s: %s", ERR_reason_error_string(ERR_get_error()), conf->full_chain);
+            config_unload();
+            cache_unload();
+            return 1;
+        }
+        if (SSL_CTX_use_PrivateKey_file(ctx, conf->priv_key, SSL_FILETYPE_PEM) != 1) {
+            critical("Unable to load private key file: %s: %s", ERR_reason_error_string(ERR_get_error()), conf->priv_key);
+            config_unload();
+            cache_unload();
+            return 1;
+        }
+    }
+
+    client.ctx = contexts[0];
+
+
+    rev_proxy_preload();
+
+    for (int i = 0; i < NUM_SOCKETS; i++) {
+        if (listen(sockets[i], LISTEN_BACKLOG) < 0) {
+            critical("Unable to listen on socket %i", i);
+            config_unload();
+            cache_unload();
+            return 1;
+        }
+    }
+
+    for (int i = 0; i < NUM_SOCKETS; i++) {
+        poll_fds[i].fd = sockets[i];
+        poll_fds[i].events = POLLIN;
+    }
+
+    errno = 0;
+    notice("Ready to accept connections");
 
     while (active) {
-        timeout.tv_sec = 1;
-        timeout.tv_usec = 0;
-        read_socket_fds = socket_fds;
-        ready_sockets_num = select(max_socket_fd + 1, &read_socket_fds, NULL, NULL, &timeout);
+        ready_sockets_num = poll(poll_fds, NUM_SOCKETS, 1000);
         if (ready_sockets_num < 0) {
-            fprintf(stderr, ERR_STR "Unable to select sockets: %s" CLR_STR "\n", strerror(errno));
-            terminate();
+            critical("Unable to poll sockets");
+            terminate(0);
             return 1;
         }
 
         for (int i = 0; i < NUM_SOCKETS; i++) {
-            if (FD_ISSET(sockets[i], &read_socket_fds)) {
+            if (poll_fds[i].revents & POLLIN) {
                 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));
+                    critical("Unable to accept connection");
                     continue;
                 }
 
@@ -343,7 +356,7 @@ int main(int argc, const char *argv[]) {
                     signal(SIGTERM, SIG_IGN);
 
                     client.socket = client_fd;
-                    client.enc = i == 1;
+                    client.enc = (i == 1);
                     return client_handler(&client, client_num, &client_addr);
                 } else if (pid > 0) {
                     // parent
@@ -356,28 +369,29 @@ int main(int argc, const char *argv[]) {
                         }
                     }
                 } else {
-                    fprintf(stderr, ERR_STR "Unable to create child process: %s" CLR_STR "\n", strerror(errno));
+                    critical("Unable to create child process");
                 }
             }
         }
 
+        // 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));
+                    critical("Unable to wait for child process (PID %i)", children[i]);
                 } 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);
+                        critical("Child process with PID %i terminated with exit code %i", ret, status);
                     }
                 }
             }
         }
     }
 
+    config_unload();
+    cache_unload();
     return 0;
 }

src/server.h

@@ -0,0 +1,32 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Main executable (header file)
+ * @file src/server.h
+ * @author Lorenz Stechauner
+ * @date 2020-12-03
+ */
+
+#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
+
+extern int sockets[NUM_SOCKETS];
+extern pid_t children[MAX_CHILDREN];
+extern MMDB_s mmdbs[MAX_MMDB];
+
+extern volatile sig_atomic_t server_keep_alive;
+extern struct timeval client_timeout;
+
+#endif //SESIMOS_SERVER_H

src/sock.c

@@ -1,109 +0,0 @@
-/**
- * Necronda Web Server
- * Basic TCP and TLS socket
- * src/sock.c
- * Lorenz Stechauner, 2021-01-07
- */
-
-#include "sock.h"
-
-const char *sock_strerror(sock *s) {
-    if (s->_last_ret == 0) {
-        return "closed";
-    } else if (s->enc) {
-        if (s->_last_ret > 0) {
-            return NULL;
-        }
-        const char *err1 = ERR_reason_error_string(s->_ssl_error);
-        const char *err2 = strerror(errno);
-        switch (SSL_get_error(s->ssl, (int) s->_last_ret)) {
-            case SSL_ERROR_NONE:
-                return NULL;
-            case SSL_ERROR_ZERO_RETURN:
-                return "closed";
-            case SSL_ERROR_WANT_READ:
-                return "want read";
-            case SSL_ERROR_WANT_WRITE:
-                return "want write";
-            case SSL_ERROR_WANT_CONNECT:
-                return "want connect";
-            case SSL_ERROR_WANT_ACCEPT:
-                return "want accept";
-            case SSL_ERROR_WANT_X509_LOOKUP:
-                return "want x509 lookup";
-            case SSL_ERROR_SYSCALL:
-                return ((s->_ssl_error == 0) ? ((s->_last_ret == 0) ? "protocol violation" : err2) : err1);
-            case SSL_ERROR_SSL:
-                return err1;
-            default:
-                return "unknown error";
-        }
-    } else {
-        return strerror(s->_errno);
-    }
-}
-
-long sock_send(sock *s, void *buf, unsigned long len, int flags) {
-    long ret;
-    if (s->enc) {
-        ret = SSL_write(s->ssl, buf, (int) len);
-    } else {
-        ret = send(s->socket, buf, len, flags);
-    }
-    s->_last_ret = ret;
-    s->_errno = errno;
-    s->_ssl_error = ERR_get_error();
-    return ret >= 0 ? ret : -1;
-}
-
-long sock_recv(sock *s, void *buf, unsigned long len, int flags) {
-    long ret;
-    if (s->enc) {
-        if (flags & MSG_PEEK) {
-            ret = SSL_peek(s->ssl, buf, (int) len);
-        } else {
-            ret = SSL_read(s->ssl, buf, (int) len);
-        }
-    } else {
-        ret = recv(s->socket, buf, len, flags);
-    }
-    s->_last_ret = ret;
-    s->_errno = errno;
-    s->_ssl_error = ERR_get_error();
-    return ret >= 0 ? ret : -1;
-}
-
-long sock_splice(sock *dst, sock *src, void *buf, unsigned long buf_len, unsigned long len) {
-    long ret;
-    unsigned long send_len = 0;
-    unsigned long next_len;
-    while (send_len < len) {
-        next_len = (buf_len < (len - send_len)) ? buf_len : (len - send_len);
-        ret = sock_recv(src, buf, next_len, 0);
-        if (ret < 0) return -2;
-        next_len = ret;
-        ret = sock_send(dst, buf, next_len, send_len + next_len < len ? MSG_MORE : 0);
-        if (ret < 0) return -1;
-        if (ret != next_len) return -3;
-        send_len += next_len;
-    }
-    return (long) send_len;
-}
-
-int sock_close(sock *s) {
-    if ((int) s->enc && s->ssl != NULL) {
-        SSL_shutdown(s->ssl);
-        SSL_free(s->ssl);
-    }
-    shutdown(s->socket, SHUT_RDWR);
-    close(s->socket);
-    s->socket = 0;
-    s->enc = 0;
-    s->ssl = NULL;
-    return 0;
-}
-
-int sock_check(sock *s) {
-    char buf;
-    return recv(s->socket, &buf, 1, MSG_PEEK | MSG_DONTWAIT) == 1;
-}

src/sock.h

@@ -1,43 +0,0 @@
-/**
- * Necronda Web Server
- * Basic TCP and TLS socket (header file)
- * src/sock.h
- * Lorenz Stechauner, 2021-01-07
- */
-
-#ifndef NECRONDA_SERVER_SOCK_H
-#define NECRONDA_SERVER_SOCK_H
-
-#include <openssl/err.h>
-#include <openssl/pem.h>
-#include <openssl/ssl.h>
-#include <openssl/conf.h>
-#include <openssl/engine.h>
-#include <openssl/dh.h>
-
-typedef struct {
-    unsigned int enc:1;
-    int socket;
-    SSL_CTX *ctx;
-    SSL *ssl;
-    char *buf;
-    unsigned long buf_len;
-    unsigned long buf_off;
-    long _last_ret;
-    int _errno;
-    unsigned long _ssl_error;
-} sock;
-
-const char *sock_strerror(sock *s);
-
-long sock_send(sock *s, void *buf, unsigned long len, int flags);
-
-long sock_recv(sock *s, void *buf, unsigned long len, int flags);
-
-long sock_splice(sock *dst, sock *src, void *buf, unsigned long buf_len, unsigned long len);
-
-int sock_close(sock *s);
-
-int sock_check(sock *s);
-
-#endif //NECRONDA_SERVER_SOCK_H

src/utils.c

@@ -1,161 +0,0 @@
-/**
- * Necronda Web Server
- * Utilities
- * src/utils.c
- * Lorenz Stechauner, 2020-12-03
- */
-
-#include "utils.h"
-
-
-char *format_duration(unsigned long micros, char *buf) {
-    if (micros < 10000) {
-        sprintf(buf, "%.1f ms", (double) micros / 1000);
-    } else if (micros < 1000000) {
-        sprintf(buf, "%li ms", micros / 1000);
-    } else if (micros < 60000000) {
-        sprintf(buf, "%.1f s", (double) micros / 1000000);
-    } else if (micros < 6000000000) {
-        sprintf(buf, "%.1f min", (double) micros / 1000000 / 60);
-    } else {
-        sprintf(buf, "%li min", micros / 1000000 / 60);
-    }
-    return buf;
-}
-
-int url_encode_component(const char *str, char *enc, ssize_t *size) {
-    char *ptr = enc;
-    char ch;
-    memset(enc, 0, *size);
-    for (int i = 0; i < strlen(str); i++, ptr++) {
-        if ((ptr - enc) >= *size) {
-            return -1;
-        }
-        ch = str[i];
-        if (ch == ':' || ch == '/' || ch == '?' || ch == '#' || ch == '[' || ch == ']' || ch == '@' || ch == '!' ||
-            ch == '$' || ch == '&' || ch == '\'' || ch == '(' || ch == ')' || ch == '*' || ch == '+' || ch == ',' ||
-            ch == ';' || ch == '=' || ch < ' ' || ch > '~') {
-            if ((ptr - enc + 2) >= *size) {
-                return -1;
-            }
-            sprintf(ptr, "%%%02X", ch);
-            ptr += 2;
-        } else if (ch == ' ') {
-            ptr[0] = '+';
-        } else {
-            ptr[0] = ch;
-        }
-    }
-    *size = ptr - enc;
-    return 0;
-}
-
-int url_encode(const char *str, char *enc, ssize_t *size) {
-    char *ptr = enc;
-    unsigned char ch;
-    memset(enc, 0, *size);
-    for (int i = 0; i < strlen(str); i++, ptr++) {
-        if ((ptr - enc) >= *size) {
-            return -1;
-        }
-        ch = str[i];
-        if (ch > 0x7F || ch == ' ') {
-            if ((ptr - enc + 2) >= *size) {
-                return -1;
-            }
-            sprintf(ptr, "%%%02X", ch);
-            ptr += 2;
-        } else {
-            ptr[0] = (char) ch;
-        }
-    }
-    *size = ptr - enc;
-    return 0;
-}
-
-int url_decode(const char *str, char *dec, ssize_t *size) {
-    char *ptr = dec;
-    char ch, buf[3];
-    memset(dec, 0, *size);
-    for (int i = 0; i < strlen(str); i++, ptr++) {
-        if ((ptr - dec) >= *size) {
-            return -1;
-        }
-        ch = str[i];
-        if (ch == '+') {
-            ch = ' ';
-        } else if (ch == '%') {
-            memcpy(buf, str + i + 1, 2);
-            buf[2] = 0;
-            ch = (char) strtol(buf, NULL, 16);
-            i += 2;
-        } else if (ch == '?') {
-            strcpy(ptr, str + i);
-            break;
-        }
-        ptr[0] = ch;
-    }
-    *size = ptr - dec;
-    return 0;
-}
-
-MMDB_entry_data_list_s *mmdb_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, "{");
-            break;
-        case MMDB_DATA_TYPE_ARRAY:
-            *str_off += sprintf(str + *str_off, "[");
-            break;
-        case MMDB_DATA_TYPE_UTF8_STRING:
-            *str_off += sprintf(str + *str_off, "\"%.*s\"", list->entry_data.data_size, list->entry_data.utf8_string);
-            break;
-        case MMDB_DATA_TYPE_UINT16:
-            *str_off += sprintf(str + *str_off, "%u", list->entry_data.uint16);
-            break;
-        case MMDB_DATA_TYPE_UINT32:
-            *str_off += sprintf(str + *str_off, "%u", list->entry_data.uint32);
-            break;
-        case MMDB_DATA_TYPE_UINT64:
-            *str_off += sprintf(str + *str_off, "%lu", list->entry_data.uint64);
-            break;
-        case MMDB_DATA_TYPE_UINT128:
-            *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);
-            break;
-        case MMDB_DATA_TYPE_BOOLEAN:
-            *str_off += sprintf(str + *str_off, "%s", list->entry_data.boolean ? "true" : "false");
-            break;
-        case MMDB_DATA_TYPE_FLOAT:
-            *str_off += sprintf(str + *str_off, "%f", list->entry_data.float_value);
-            break;
-        case MMDB_DATA_TYPE_DOUBLE:
-            *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) {
-        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);
-        if (list->entry_data.type == MMDB_DATA_TYPE_MAP) {
-            stat = !stat;
-            if (stat) {
-                i--;
-                *str_off += sprintf(str + *str_off, ":");
-                continue;
-            }
-        }
-        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, "]");
-    }
-    return next;
-}

src/utils.h

@@ -1,31 +0,0 @@
-/**
- * Necronda Web Server
- * Utilities (header file)
- * src/utils.h
- * Lorenz Stechauner, 2020-12-03
- */
-
-#ifndef NECRONDA_SERVER_UTILS_H
-#define NECRONDA_SERVER_UTILS_H
-
-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 char *str, char *enc, ssize_t *size);
-
-int url_encode(const char *str, char *enc, ssize_t *size);
-
-int url_decode(const char *str, char *dec, ssize_t *size);
-
-#endif //NECRONDA_SERVER_UTILS_H

test/mock_socket.c

@@ -0,0 +1,28 @@
+
+#include <stdio.h>
+#include <errno.h>
+
+#include "mock_socket.h"
+
+int mock_socket_send_mode;
+
+static int sockets[256] = {0};
+static int n_sockets = 0;
+
+int mock_socket(int domain, int type, int protocol) {
+    printf("SOCKET\n");
+    return (n_sockets++) + 100;
+}
+
+ssize_t mock_send(int fd, const void *buf, size_t n, int flags) {
+    printf("SEND\n");
+    if (mock_socket_send_mode == MOCK_SOCKET_MODE_EINTR) {
+        errno = EINTR;
+        return rand() % ((ssize_t) n) - 1;
+    } else if (mock_socket_send_mode == MOCK_SOCKET_MODE_CLOSED) {
+        errno = 0; // TODO
+        return -1;
+    }
+
+    return (ssize_t) n;
+}

test/mock_socket.h

@@ -0,0 +1,20 @@
+
+#ifndef SESIMOS_MOCK_SOCKET_H
+#define SESIMOS_MOCK_SOCKET_H
+
+#include <stdlib.h>
+
+#define MOCK_SOCKET_MODE_SUCCESS 0
+#define MOCK_SOCKET_MODE_EINTR 1
+#define MOCK_SOCKET_MODE_CLOSED 2
+
+#define socket(args...) mock_socket(args)
+#define send(args...) mock_send(args)
+
+extern int mock_socket_send_mode;
+
+int mock_socket(int domain, int type, int protocol);
+
+ssize_t mock_send(int fd, const void *buf, size_t n, int flags);
+
+#endif //SESIMOS_MOCK_SOCKET_H

test/mock_ssl.c

@@ -0,0 +1,33 @@
+
+#include <openssl/crypto.h>
+
+
+int SSL_write(SSL *ssl, const void *buf, int num) {
+    return num;
+}
+
+int SSL_read(SSL *ssl, void *buf, int num) {
+    return num;
+}
+
+int SSL_peek(SSL *ssl, void *buf, int num) {
+    return num;
+}
+
+int SSL_get_error(const SSL *s, int ret_code) {
+    return 0;
+}
+
+const char *ERR_reason_error_string(unsigned long e) {
+    return "";
+}
+
+int SSL_shutdown(SSL *s) {
+    return 0;
+}
+
+void SSL_free(SSL *ssl) {}
+
+unsigned long ERR_get_error(void) {
+    return 0;
+}

test/test_sock.c

@@ -0,0 +1,15 @@
+
+#include <criterion/criterion.h>
+#include "mock_socket.h"
+#include "../src/lib/sock.h"
+
+
+Test(sock, sock_send_1) {
+    int fd = socket(AF_INET6, SOCK_STREAM, 0);
+    sock s;
+    s.enc = 0;
+    s.socket = fd;
+
+    long ret = sock_send(&s, "Hello", 5, 0);
+    cr_assert_eq(ret, 5);
+}

test/test_utils.c

@@ -0,0 +1,86 @@
+
+#include <criterion/criterion.h>
+#include <criterion/parameterized.h>
+
+#include "../src/lib/utils.h"
+
+struct url_encode_t {
+    long in_size;
+    char in[256];
+    long exp_size;
+    char exp[256];
+};
+
+struct format_duration_t {
+    unsigned long micros;
+    char exp[16];
+};
+
+ParameterizedTestParameters(utils, url_encode) {
+    static struct url_encode_t params[] = {
+            {0, "", 0, ""},
+            {9, "Test Text", 11, "Test%20Text"},
+            {21, "Text\0with\0null\0bytes\0", 29, "Text%00with%00null%00bytes%00"},
+            {59, "Text&with+some/strange_symbols-or#something?I%don't|know...", 59, "Text&with+some/strange_symbols-or#something?I%don't|know..."},
+            {33, "Data\x12With\x13Some" "\xFF" "Control" "\xFE" "Characters", 41, "Data%12With%13Some%FFControl%FECharacters"}
+    };
+    return cr_make_param_array(struct url_encode_t, params, sizeof(params) / sizeof(struct url_encode_t));
+}
+
+ParameterizedTest(struct url_encode_t *param, utils, url_encode) {
+    char out[256];
+    cr_assert_eq(url_encode(param->in, param->in_size, out, sizeof(out)), param->exp_size);
+    cr_assert_arr_eq(out, param->exp, param->exp_size + 1);
+}
+
+Test(utils, url_encode_bytes) {
+    char out[4];
+    char exp[4];
+
+    for (int i = 0; i < 256; i++) {
+        unsigned char ch = i;
+        if (ch <= 0x20 || ch >= 0x7F) {
+            cr_assert_eq(url_encode(&ch, 1, out, sizeof(out)), 3);
+            sprintf(exp, "%%%02X", ch);
+            cr_assert_str_eq(out, exp);
+        } else {
+            cr_assert_eq(url_encode(&ch, 1, out, sizeof(out)), 1);
+            sprintf(exp, "%c", ch);
+            cr_assert_str_eq(out, exp);
+        }
+    }
+}
+
+Test(utils, url_encode_invalid) {
+    cr_assert_eq(url_encode("Hello", 5, NULL, 0), 5);
+}
+
+ParameterizedTestParameters(utils, format_duration) {
+    static struct format_duration_t params[] = {
+            {0, "0.0 ms"},
+            {1, "0.0 ms"},
+            {90, "0.1 ms"},
+            {100, "0.1 ms"},
+            {110, "0.1 ms"},
+            {900, "0.9 ms"},
+            {1000, "1.0 ms"},
+            {9000, "9.0 ms"},
+            {9899, "9.9 ms"},
+            {9999, "10.0 ms"},
+            {10000, "10 ms"},
+            {11999, "12 ms"},
+            {999999, "1.0 s"},
+            {1000000, "1.0 s"},
+            {3000000, "3.0 s"},
+            {1000000 * 60, "1.0 min"},
+            {1000000 * 60 * 30L - 30000000, "29.5 min"},
+            {1000000 * 60 * 60L, "60.0 min"},
+            {1000000 * 60 * 120L, "120 min"},
+    };
+    return cr_make_param_array(struct format_duration_t, params, sizeof(params) / sizeof(struct format_duration_t));
+}
+
+ParameterizedTest(struct format_duration_t *param, utils, format_duration) {
+    char buf[16];
+    cr_assert_str_eq(format_duration(param->micros, buf), param->exp);
+}