Rework error interface

Fix echo Makefile bug
Add status_code_t in http.h
2023-01-12 12:54:23 +01:00 · 2023-01-12 11:47:48 +01:00 · 2023-01-12 10:22:27 +01:00 · 2023-01-12 10:21:57 +01:00 · 2023-01-12 01:58:14 +01:00 · 2023-01-12 00:34:04 +01:00
30 changed files with 857 additions and 445 deletions
--- a/8
+++ b/8
@@ -1,7 +1,7 @@

 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
+CFLAGS=-std=gnu11 -Wno-unused-but-set-variable -D_DEFAULT_SOURCE -D_GNU_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_POSIX_C_SOURCE=200809L
+LDFLAGS=-pthread -lssl -lcrypto -lmagic -lz -lmaxminddb -lbrotlienc

 DEBIAN_OPTS=-D CACHE_MAGIC_FILE="\"/usr/share/file/magic.mgc\"" -D PHP_FPM_SOCKET="\"/var/run/php/php7.4-fpm.sock\""

@@ -36,7 +36,7 @@ bin/res:
 	mkdir -p bin/res

 bin/test: test/mock_*.c test/test_*.c \
-          src/lib/utils.c src/lib/sock.c src/lib/list.c src/lib/http.c src/lib/http_static.c src/logger.c
+          src/lib/utils.c src/lib/sock.c src/lib/list.c src/lib/http.c src/lib/http_static.c src/logger.c src/lib/error.c
 	$(CC) -o $@ $(CFLAGS) $^ -lcriterion


@@ -54,7 +54,7 @@ bin/res/%.o: bin/res/%.txt

 bin/res/%.txt: res/%.*
 	cp $^ $@
-	echo -ne "\x00" >> $@
+	/bin/echo -ne "\x00" >> $@

 bin/sesimos: bin/server.o bin/logger.o bin/cache_handler.o bin/async.o bin/workers.o \
             bin/worker/request_handler.o bin/worker/tcp_acceptor.o \
--- a/src/cache_handler.c
+++ b/src/cache_handler.c
@@ -25,10 +25,9 @@

 #define CACHE_BUF_SIZE 16

-
 static magic_t magic;
 static pthread_t thread;
-static sem_t sem_free, sem_used, sem_lock;
+static sem_t sem_free, sem_used, sem_lock, sem_cache;
 volatile sig_atomic_t alive = 1;

 typedef struct {
@@ -61,6 +60,13 @@ static void cache_free(void) {

        munmap(hc->cache, sizeof(cache_t));
    }
+
+    magic_close(magic);
+
+    sem_destroy(&sem_lock);
+    sem_destroy(&sem_free);
+    sem_destroy(&sem_used);
+    sem_destroy(&sem_cache);
 }

 static cache_entry_t *cache_get_entry(cache_t *cache, const char *filename) {
@@ -69,7 +75,7 @@ static cache_entry_t *cache_get_entry(cache_t *cache, const char *filename) {
    for (int i = 0; i < CACHE_ENTRIES; i++) {
        entry = &cache->entries[i];
        if (entry->filename[0] == 0) break;
-        if (strcmp(entry->filename, filename) == 0) {
+        if (streq(entry->filename, filename)) {
            // found
            return entry;
        }
@@ -80,13 +86,29 @@ static cache_entry_t *cache_get_entry(cache_t *cache, const char *filename) {
 }

 static cache_entry_t *cache_get_new_entry(cache_t *cache) {
+    // globally lock cache
+    retry:
+    if (sem_wait(&sem_cache) != 0) {
+        if (errno == EINTR) {
+            goto retry;
+        } else {
+            return NULL;
+        }
+    }
+
    // search empty slot
    cache_entry_t *entry;
    for (int i = 0; i < CACHE_ENTRIES; i++) {
        entry = &cache->entries[i];
-        if (entry->filename[0] == 0)
+        if (entry->filename[0] == 0) {
+            // unlock cache
+            sem_post(&sem_cache);
            return entry;
        }
+    }
+
+    // unlock cache
+    sem_post(&sem_cache);

    // not found
    return NULL;
@@ -98,7 +120,7 @@ static void cache_process_entry(cache_entry_t *entry) {
    info("Hashing file %s", entry->filename);

    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
-    EVP_DigestInit(ctx, EVP_sha1());
+    EVP_DigestInit(ctx, EVP_sha256());
    FILE *file = fopen(entry->filename, "rb");
    int compress = mime_is_compressible(entry->meta.type);

@@ -120,9 +142,7 @@ static void cache_process_entry(cache_entry_t *entry) {

        char *rel_path = entry->filename + entry->webroot_len + 1;
        for (int j = 0; j < strlen(rel_path); j++) {
-            char ch = rel_path[j];
-            if (ch == '/') ch = '_';
-            buf[j] = ch;
+            buf[j] = (char) ((rel_path[j] == '/') ? '_' : rel_path[j]);
        }
        buf[strlen(rel_path)] = 0;

@@ -243,6 +263,13 @@ int cache_init(void) {
        if (hc->type == CONFIG_TYPE_UNSET) break;
        if (hc->type != CONFIG_TYPE_LOCAL) continue;

+        sprintf(buf, "%s/.sesimos", hc->local.webroot);
+        if (mkdir(buf, 0755) != 0 && errno != EEXIST) {
+            critical("Unable to create directory %s", buf);
+            return 1;
+        }
+        errno = 0;
+
        sprintf(buf, "%s/.sesimos/metadata", hc->local.webroot);
        if ((fd = open(buf, O_CREAT | O_RDWR, 0600)) == -1) {
            critical("Unable to open file %s", buf);
@@ -267,7 +294,8 @@ int cache_init(void) {
    // try to initialize all three semaphores
    if (sem_init(&sem_lock, 0, 1) != 0 ||
        sem_init(&sem_free, 0, 1) != 0 ||
-        sem_init(&sem_used, 0, 0) != 0)
+        sem_init(&sem_used, 0, 0) != 0 ||
+        sem_init(&sem_cache, 0, 1) != 0)
    {
        critical("Unable to initialize semaphore");
        return -1;
@@ -337,9 +365,7 @@ static void cache_mark_entry_dirty(cache_entry_t *entry) {
 }

 static void cache_update_entry(cache_entry_t *entry, const char *filename, const char *webroot) {
-    struct stat statbuf;
-    stat(filename, &statbuf);
-    memcpy(&entry->meta.stat, &statbuf, sizeof(statbuf));
+    entry->meta.mtime = stat_mtime(filename);

    entry->webroot_len = (unsigned char) strlen(webroot);
    strcpy(entry->filename, filename);
@@ -348,10 +374,10 @@ static void cache_update_entry(cache_entry_t *entry, const char *filename, const
    const char *type = magic_file(magic, filename);
    char type_new[URI_TYPE_SIZE];
    sprintf(type_new, "%s", type);
-    if (strncmp(type, "text/", 5) == 0) {
-        if (strcmp(filename + strlen(filename) - 4, ".css") == 0) {
+    if (strstarts(type, "text/")) {
+        if (strends(filename, ".css")) {
            sprintf(type_new, "text/css");
-        } else if (strcmp(filename + strlen(filename) - 3, ".js") == 0) {
+        } else if (strends(filename, ".js")) {
            sprintf(type_new, "application/javascript");
        }
    }
@@ -387,9 +413,7 @@ void cache_init_uri(cache_t *cache, http_uri *uri) {
            return;

        // check, if file has changed
-        struct stat statbuf;
-        stat(uri->filename, &statbuf);
-        if (memcmp(&uri->meta->stat.st_mtime, &statbuf.st_mtime, sizeof(statbuf.st_mtime)) != 0) {
+        if (uri->meta->mtime != stat_mtime(uri->filename)) {
            // modify time has changed
            cache_update_entry(entry, uri->filename, uri->webroot);
        }
--- a/src/defs.h
+++ b/src/defs.h
@@ -15,6 +15,7 @@

 #define CHUNK_SIZE 8192
 #define MAX_PROXY_CNX_PER_HOST 16
+#define ADDRSTRLEN 39

 #ifndef DEFAULT_HOST
 #   define DEFAULT_HOST "www.necronda.net"
--- a/src/lib/compress.c
+++ b/src/lib/compress.c
@@ -69,6 +69,9 @@ int compress_free(compress_ctx *ctx) {
        BrotliEncoderDestroyInstance(ctx->brotli);
        ctx->brotli = NULL;
    }
+    if (ctx->mode & COMPRESS_GZ) {
+        deflateEnd(&ctx->gzip);
+    }
    ctx->mode = 0;
    return 0;
 }
--- a/src/lib/config.c
+++ b/src/lib/config.c
@@ -8,6 +8,7 @@

 #include "../logger.h"
 #include "config.h"
+#include "utils.h"

 #include <stdio.h>
 #include <string.h>
@@ -41,7 +42,7 @@ int config_load(const char *filename) {
        if (comment != NULL) comment[0] = 0;

        unsigned long len = strlen(ptr);
-        char *end_ptr = ptr + len - 1;
+        char *end_ptr = (len > 0) ? ptr + len - 1 : ptr;
        while (end_ptr[0] == ' ' || end_ptr[0] == '\t') {
            end_ptr[0] = 0;
            end_ptr--;
@@ -133,7 +134,7 @@ int config_load(const char *filename) {
                } else {
                    hc->type = CONFIG_TYPE_REVERSE_PROXY;
                }
-            } else if (strcmp(ptr, "http") == 0) {
+            } else if (streq(ptr, "http")) {
                if (hc->type != 0 && hc->type != CONFIG_TYPE_REVERSE_PROXY) {
                    goto err;
                } else {
@@ -141,7 +142,7 @@ int config_load(const char *filename) {
                    hc->proxy.enc = 0;
                }
                continue;
-            } else if (strcmp(ptr, "https") == 0) {
+            } else if (streq(ptr, "https")) {
                if (hc->type != 0 && hc->type != CONFIG_TYPE_REVERSE_PROXY) {
                    goto err;
                } else {
@@ -160,17 +161,19 @@ int config_load(const char *filename) {
        if (strlen(source) == 0) {
            err:
            critical("Unable to parse config file (line %i)", line);
+            free(line);
+            fclose(file);
            return -2;
        }

        if (target != NULL) {
            strcpy(target, source);
        } else if (mode == 1) {
-            if (strcmp(source, "forbidden") == 0) {
+            if (streq(source, "forbidden")) {
                config.hosts[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
-            } else if (strcmp(source, "info") == 0) {
+            } else if (streq(source, "info")) {
                config.hosts[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
-            } else if (strcmp(source, "list") == 0) {
+            } else if (streq(source, "list")) {
                config.hosts[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
            } else {
                goto err;
@@ -181,6 +184,7 @@ int config_load(const char *filename) {
    }

    free(line);
+    fclose(file);

    for (int k = 0; k < i; k++) {
        host_config_t *hc = &config.hosts[k];
@@ -193,7 +197,7 @@ int config_load(const char *filename) {
        if (hc->cert_name[0] == 0) goto err2;
        int found = 0;
        for (int m = 0; m < j; m++) {
-            if (strcmp(config.certs[m].name, hc->cert_name) == 0) {
+            if (streq(config.certs[m].name, hc->cert_name)) {
                hc->cert = m;
                found = 1;
                break;
@@ -213,7 +217,7 @@ host_config_t *get_host_config(const char *host) {
    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
        host_config_t *hc = &config.hosts[i];
        if (hc->type == CONFIG_TYPE_UNSET) break;
-        if (strcmp(hc->name, host) == 0) return hc;
+        if (streq(hc->name, host)) 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;
--- a/src/lib/error.c
+++ b/src/lib/error.c
@@ -7,58 +7,23 @@
 */

 #include "error.h"
-#include "http.h"
+#include "../logger.h"

 #include <errno.h>
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#include <maxminddb.h>
+#include <string.h>

-static const char *error_ssl_strerror(int err) {
-    switch (err) {
-        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_WANT_ASYNC:
-            return "want async";
-        case SSL_ERROR_WANT_ASYNC_JOB:
-            return "want async job";
-        case SSL_ERROR_WANT_CLIENT_HELLO_CB:
-            return "want client hello callback";
-        case SSL_ERROR_WANT_RETRY_VERIFY:
-            return "want retry verify";
-        case SSL_ERROR_SSL:
-            return ERR_reason_error_string(ERR_get_error());
-        default:
-            return "unknown error";
-    }
+extern const char *sock_error_str(unsigned long err);
+extern const char *http_error_str(int err);
+extern const char *MMDB_strerror(int err);
+extern const char *ERR_reason_error_string(unsigned long err);
+
+static int error_compress(unsigned long err) {
+    if (err & 0xFF0000) warning("Lossy error code compression!");
+    return ((int) err & 0xFFFF) | (((int) err >> 8) & 0xFF0000);
 }

-static const char *error_http_strerror(int err) {
-    switch (err) {
-        case HTTP_ERROR_TOO_MANY_HEADER_FIELDS:
-            return "too many header fields";
-        case HTTP_ERROR_EOH_NOT_FOUND:
-            return "end of http header not found";
-        case HTTP_ERROR_HEADER_MALFORMED:
-            return "http header malformed";
-        case HTTP_ERROR_INVALID_VERSION:
-            return "invalid http version";
-        case HTTP_ERROR_URI_TOO_LONG:
-            return "uri too long";
-        case HTTP_ERROR_GENERAL:
-        default:
-            return "unknown error";
-    }
+static unsigned long error_decompress(int err) {
+    return (err & 0xFFFF) | ((err << 8) & 0xFF000000);
 }

 const char *error_str(int err_no, char *buf, int buf_len) {
@@ -71,46 +36,34 @@ const char *error_str(int err_no, char *buf, int buf_len) {
        return buf;
    } else if (mode == 0x01) {
        // ssl
-        return error_ssl_strerror(e);
+        return sock_error_str(error_decompress(e));
    } else if (mode == 0x02) {
+        // ssl err
+        return ERR_reason_error_string(error_decompress(e));
+    } else if (mode == 0x03) {
        // mmdb
        return MMDB_strerror(e);
-    } else if (mode == 0x03) {
+    } else if (mode == 0x04) {
        // http
-        return error_http_strerror(e);
+        return http_error_str(e);
    }
    return buf;
 }

-void error_ssl(int err) {
-    if (err == SSL_ERROR_NONE) {
-        errno = 0;
-    } else if (err == SSL_ERROR_SYSCALL) {
-        // errno already set
-    } else {
-        errno = 0x01000000 | err;
+void error_ssl(unsigned long err) {
+    errno = 0x01000000 | error_compress(err);
 }
+
+void error_ssl_err(unsigned long err) {
+    errno = 0x02000000 | error_compress(err);
 }

 void error_mmdb(int err) {
-    if (err == MMDB_SUCCESS) {
-        errno = 0;
-    } else if (err == MMDB_IO_ERROR) {
-        // errno already set
-    } else {
-        errno = 0x02000000 | err;
-    }
-}
-
-int error_http(int err) {
-    if (err == 0) {
-        errno = 0;
-    } else if (err == HTTP_ERROR_SYSCALL) {
-        // errno already set
-    } else {
    errno = 0x03000000 | err;
 }
-    return -1;
+
+void error_http(int err) {
+    errno = 0x04000000 | err;
 }

 static int error_get(unsigned char prefix) {
@@ -125,10 +78,14 @@ int error_get_ssl() {
    return error_get(0x01);
 }

-int error_get_mmdb() {
+int error_get_ssl_err() {
    return error_get(0x02);
 }

-int error_get_http() {
+int error_get_mmdb() {
    return error_get(0x03);
 }
+
+int error_get_http() {
+    return error_get(0x04);
+}
--- a/src/lib/error.h
+++ b/src/lib/error.h
@@ -11,11 +11,13 @@

 const char *error_str(int err_no, char *buf, int buf_len);

-void error_ssl(int err);
+void error_ssl(unsigned long err);
+
+void error_ssl_err(unsigned long err);

 void error_mmdb(int err);

-int error_http(int err);
+void error_http(int err);

 int error_get_sys();

--- a/src/lib/fastcgi.c
+++ b/src/lib/fastcgi.c
@@ -6,6 +6,7 @@
 * @date 2020-12-26
 */

+#include "../defs.h"
 #include "fastcgi.h"
 #include "utils.h"
 #include "compress.h"
@@ -16,13 +17,11 @@
 #include <sys/socket.h>
 #include <string.h>

-
 char *fastcgi_add_param(char *buf, const char *key, const char *value) {
    char *ptr = buf;
    unsigned long key_len = strlen(key);
    unsigned long val_len = strlen(value);

-
    if (key_len <= 127) {
        ptr[0] = (char) (key_len & 0x7F);
        ptr++;
@@ -44,9 +43,9 @@ char *fastcgi_add_param(char *buf, const char *key, const char *value) {
        ptr += 4;
    }

-    strcpy(ptr, key);
+    memcpy(ptr, key, key_len);
    ptr += key_len;
-    strcpy(ptr, value);
+    memcpy(ptr, value, val_len);
    ptr += val_len;

    return ptr;
@@ -117,13 +116,13 @@ int fastcgi_init(fastcgi_cnx_t *conn, int mode, unsigned int req_num, const sock
    socklen_t len = sizeof(addr_storage);
    getsockname(client->socket, (struct sockaddr *) &addr_storage, &len);
    addr = (struct sockaddr_in6 *) &addr_storage;
-    sprintf(buf0, "%i", addr->sin6_port);
+    sprintf(buf0, "%i", ntohs(addr->sin6_port));
    param_ptr = fastcgi_add_param(param_ptr, "SERVER_PORT", buf0);

    len = sizeof(addr_storage);
    getpeername(client->socket, (struct sockaddr *) &addr_storage, &len);
    addr = (struct sockaddr_in6 *) &addr_storage;
-    sprintf(buf0, "%i", addr->sin6_port);
+    sprintf(buf0, "%i", ntohs(addr->sin6_port));
    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_PORT", buf0);
    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_ADDR", conn->r_addr);
    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_HOST", conn->r_host != NULL ? conn->r_host : conn->r_addr);
@@ -153,7 +152,7 @@ int fastcgi_init(fastcgi_cnx_t *conn, int mode, unsigned int req_num, const sock
    //    param_ptr = fastcgi_add_param(param_ptr, "REMOTE_INFO", conn->ctx->geoip);
    //}

-    for (int i = 0; i < list_size(&req->hdr); i++) {
+    for (int i = 0; i < list_size(req->hdr.fields); i++) {
        const http_field *f = &req->hdr.fields[i];
        const char *name = http_field_get_name(f);
        char *ptr = buf0;
@@ -237,16 +236,16 @@ int fastcgi_php_error(const fastcgi_cnx_t *conn, const char *msg, int msg_len, c
            goto next;
        }

-        if (len >= 14 && strncmp(ptr0, "PHP Warning:  ", 14) == 0) {
+        if (len >= 14 && strstarts(ptr0, "PHP Warning:  ")) {
            msg_type = LOG_WARNING;
            msg_pre_len = 14;
-        } else if (len >= 18 && strncmp(ptr0, "PHP Fatal error:  ", 18) == 0) {
+        } else if (len >= 18 && strstarts(ptr0, "PHP Fatal error:  ")) {
            msg_type = LOG_ERROR;
            msg_pre_len = 18;
-        } else if (len >= 18 && strncmp(ptr0, "PHP Parse error:  ", 18) == 0) {
+        } else if (len >= 18 && strstarts(ptr0, "PHP Parse error:  ")) {
            msg_type = LOG_ERROR;
            msg_pre_len = 18;
-        } else if (len >= 18 && strncmp(ptr0, "PHP Notice:  ", 13) == 0) {
+        } else if (len >= 18 && strstarts(ptr0, "PHP Notice:  ")) {
            msg_type = LOG_NOTICE;
            msg_pre_len = 13;
        }
--- a/src/lib/geoip.c
+++ b/src/lib/geoip.c
@@ -9,12 +9,24 @@
 #include "geoip.h"
 #include "../logger.h"
 #include "error.h"
+#include "utils.h"
+
 #include <memory.h>
 #include <dirent.h>
-
+#include <errno.h>

 static MMDB_s mmdbs[GEOIP_MAX_MMDB];

+static void mmdb_error(int err) {
+    if (err == MMDB_SUCCESS) {
+        errno = 0;
+    } else if (err == MMDB_IO_ERROR) {
+        // errno already set
+    } else {
+        error_mmdb(err);
+    }
+}
+
 static MMDB_entry_data_list_s *geoip_json(MMDB_entry_data_list_s *list, char *str, long *str_off, long str_len) {
    switch (list->entry_data.type) {
        case MMDB_DATA_TYPE_MAP:
@@ -91,7 +103,7 @@ int geoip_init(const char *directory) {
    struct dirent *entry;
    int i = 0, status;
    while ((entry = readdir(geoip_dir)) != NULL) {
-        if (strcmp(entry->d_name + strlen(entry->d_name) - 5, ".mmdb") != 0)
+        if (!strends(entry->d_name, ".mmdb"))
            continue;

        if (i >= GEOIP_MAX_MMDB) {
@@ -102,7 +114,7 @@ int geoip_init(const char *directory) {

        sprintf(buf, "%s/%s", directory, entry->d_name);
        if ((status = MMDB_open(buf, 0, &mmdbs[i])) != MMDB_SUCCESS) {
-            error_mmdb(status);
+            mmdb_error(status);
            critical("Unable to initialize geoip: Unable to open .mmdb file");
            closedir(geoip_dir);
            return 1;
@@ -166,7 +178,7 @@ int geoip_lookup_json(struct sockaddr *addr, char *json, long len) {
        int mmdb_res;
        MMDB_lookup_result_s result = MMDB_lookup_sockaddr(&mmdbs[i], addr, &mmdb_res);
        if (mmdb_res != MMDB_SUCCESS) {
-            error_mmdb(mmdb_res);
+            mmdb_error(mmdb_res);
            error("Unable to lookup geoip info");
            continue;
        } else if (!result.found_entry) {
@@ -175,7 +187,7 @@ int geoip_lookup_json(struct sockaddr *addr, char *json, long len) {

        MMDB_entry_data_list_s *list;
        if ((mmdb_res = MMDB_get_entry_data_list(&result.entry, &list)) != MMDB_SUCCESS) {
-            error_mmdb(mmdb_res);
+            mmdb_error(mmdb_res);
            error("Unable to lookup geoip info");
            continue;
        }
--- a/src/lib/http.c
+++ b/src/lib/http.c
@@ -13,7 +13,36 @@
 #include "error.h"

 #include <string.h>
+#include <errno.h>

+static int http_error(int err) {
+    if (err == 0) {
+        errno = 0;
+    } else if (err == HTTP_ERROR_SYSCALL) {
+        // errno already set
+    } else {
+        error_http(err);
+    }
+    return -1;
+}
+
+const char *http_error_str(int err) {
+    switch (err) {
+        case HTTP_ERROR_TOO_MANY_HEADER_FIELDS:
+            return "too many header fields";
+        case HTTP_ERROR_EOH_NOT_FOUND:
+            return "end of http header not found";
+        case HTTP_ERROR_HEADER_MALFORMED:
+            return "http header malformed";
+        case HTTP_ERROR_INVALID_VERSION:
+            return "invalid http version";
+        case HTTP_ERROR_URI_TOO_LONG:
+            return "uri too long";
+        case HTTP_ERROR_GENERAL:
+        default:
+            return "unknown error";
+    }
+}

 void http_to_camel_case(char *str, int mode) {
    if (mode == HTTP_PRESERVE)
@@ -88,21 +117,22 @@ void http_free_res(http_res *res) {
 }

 int http_init_hdr(http_hdr *hdr) {
+    hdr->last_field_num = -1;
    hdr->fields = list_create(sizeof(http_field), HTTP_INIT_HEADER_FIELD_NUM);
    if (hdr->fields == NULL)
-        return error_http(HTTP_ERROR_SYSCALL);
+        return http_error(HTTP_ERROR_SYSCALL);

    return 0;
 }

 int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags) {
    if (hdr->last_field_num > list_size(hdr->fields))
-        return error_http(HTTP_ERROR_GENERAL);
+        return http_error(HTTP_ERROR_GENERAL);

    char *pos1 = (char *) buf, *pos2 = (char *) end_ptr;
    if (buf[0] == ' ' || buf[0] == '\t') {
        if (hdr->last_field_num == -1)
-            return error_http(HTTP_ERROR_GENERAL);
+            return http_error(HTTP_ERROR_GENERAL);

        http_field *f = &hdr->fields[(int) hdr->last_field_num];

@@ -114,7 +144,7 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,

    pos1 = memchr(buf, ':', end_ptr - buf);
    if (pos1 == NULL)
-        return error_http(HTTP_ERROR_GENERAL);
+        return http_error(HTTP_ERROR_GENERAL);

    long len1 = pos1 - buf;

@@ -122,11 +152,14 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,
    str_trim_lws(&pos1, &pos2);
    long len2 = pos2 - pos1;

+    char header_name[256];
+    sprintf(header_name, "%.*s", (int) len1, buf);
+
    int field_num = list_size(hdr->fields);
-    int found = http_get_header_field_num_len(hdr, buf, len1);
+    int found = http_get_header_field_num(hdr, header_name);
    if (!(flags & HTTP_MERGE_FIELDS) || found == -1) {
        if (http_add_header_field_len(hdr, buf, len1, pos1, len2 < 0 ? 0 : len2) != 0)
-            return error_http(HTTP_ERROR_TOO_MANY_HEADER_FIELDS);
+            return http_error(HTTP_ERROR_TOO_MANY_HEADER_FIELDS);
    } else {
        field_num = found;
        http_append_to_header_field(&hdr->fields[found], ", ", 2);
@@ -143,44 +176,44 @@ int http_parse_request(char *buf, http_req *req) {

    unsigned long header_len = strstr(buf, "\r\n\r\n") - buf + 4;
    if (header_len <= 0)
-        return error_http(HTTP_ERROR_EOH_NOT_FOUND);
+        return http_error(HTTP_ERROR_EOH_NOT_FOUND);

    for (int i = 0; i < header_len; i++) {
        if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F)
-            return error_http(HTTP_ERROR_HEADER_MALFORMED);
+            return http_error(HTTP_ERROR_HEADER_MALFORMED);
    }

    ptr = buf;
    while (header_len > (ptr - buf + 2)) {
        pos0 = strstr(ptr, "\r\n");
        if (pos0 == NULL)
-            return error_http(HTTP_ERROR_HEADER_MALFORMED);
+            return http_error(HTTP_ERROR_HEADER_MALFORMED);

        if (req->version[0] == 0) {
            pos1 = (char *) strchr(ptr, ' ') + 1;
            if (pos1 == NULL) goto err_hdr_fmt;

            if (pos1 - ptr - 1 >= sizeof(req->method))
-                return error_http(HTTP_ERROR_HEADER_MALFORMED);
+                return http_error(HTTP_ERROR_HEADER_MALFORMED);

            for (int i = 0; i < (pos1 - ptr - 1); i++) {
                if (ptr[i] < 'A' || ptr[i] > 'Z')
-                    return error_http(HTTP_ERROR_HEADER_MALFORMED);
+                    return http_error(HTTP_ERROR_HEADER_MALFORMED);
            }
            snprintf(req->method, sizeof(req->method), "%.*s", (int) (pos1 - ptr - 1), ptr);

            pos2 = (char *) strchr(pos1, ' ') + 1;
            if (pos2 == NULL) {
                err_hdr_fmt:
-                return error_http(HTTP_ERROR_HEADER_MALFORMED);
+                return http_error(HTTP_ERROR_HEADER_MALFORMED);
            }

            if (memcmp(pos2, "HTTP/", 5) != 0 || memcmp(pos2 + 8, "\r\n", 2) != 0)
-                return error_http(HTTP_ERROR_INVALID_VERSION);
+                return http_error(HTTP_ERROR_INVALID_VERSION);

            len = pos2 - pos1 - 1;
            if (len >= 2048)
-                return error_http(HTTP_ERROR_URI_TOO_LONG);
+                return http_error(HTTP_ERROR_URI_TOO_LONG);

            req->uri = malloc(len + 1);
            sprintf(req->uri, "%.*s", (int) len, pos1);
@@ -196,7 +229,7 @@ int http_parse_request(char *buf, http_req *req) {
        return (int) header_len;
    }

-    return error_http(HTTP_ERROR_GENERAL);
+    return http_error(HTTP_ERROR_GENERAL);
 }

 int http_receive_request(sock *client, http_req *req) {
@@ -206,7 +239,6 @@ int http_receive_request(sock *client, http_req *req) {
    memset(req->method, 0, sizeof(req->method));
    memset(req->version, 0, sizeof(req->version));
    req->uri = NULL;
-    req->hdr.last_field_num = -1;
    http_init_hdr(&req->hdr);

    rcv_len = sock_recv(client, buf, CLIENT_MAX_HEADER_SIZE - 1, MSG_PEEK);
@@ -227,21 +259,13 @@ int http_receive_request(sock *client, http_req *req) {
 }

 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);
+    int num = http_get_header_field_num(hdr, field_name);
    return (num >= 0 && num < list_size(hdr->fields)) ? 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) {
    for (int i = 0; i < list_size(hdr->fields); i++) {
-        if (strncasecmp(field_name, http_field_get_name(&hdr->fields[i]), len) == 0)
+        if (strcasecmp(field_name, http_field_get_name(&hdr->fields[i])) == 0)
            return i;
    }

@@ -354,7 +378,7 @@ int http_send_request(sock *server, http_req *req) {
    return 0;
 }

-const http_status *http_get_status(unsigned short status_code) {
+const http_status *http_get_status(status_code_t status_code) {
    for (int i = 0; i < http_statuses_size; i++) {
        if (http_statuses[i].code == status_code) {
            return &http_statuses[i];
@@ -363,62 +387,55 @@ const http_status *http_get_status(unsigned short status_code) {
    return NULL;
 }

-const http_status_msg *http_get_error_msg(const http_status *status) {
-    unsigned short code = status->code;
+const http_status_msg *http_get_error_msg(status_code_t status_code) {
    for (int i = 0; i < http_status_messages_size; i++) {
-        if (http_status_messages[i].code == code) {
+        if (http_status_messages[i].code == status_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;
+const char *http_get_status_color(status_code_t status_code) {
+    if (status_code == 304) return HTTP_2XX_STR;
+    switch (status_code / 100) {
+        case 1: return HTTP_1XX_STR;
+        case 2: return HTTP_2XX_STR;
+        case 3: return HTTP_3XX_STR;
+        case 4: return HTTP_4XX_STR;
+        case 5: return HTTP_5XX_STR;
+        default: return "";
    }
-    return "";
 }

 char *http_format_date(time_t time, char *buf, size_t size) {
-    struct tm timeinfo;
-    strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", gmtime_r(&time, &timeinfo));
+    struct tm time_info;
+    strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", gmtime_r(&time, &time_info));
    return buf;
 }

 char *http_get_date(char *buf, size_t size) {
-    time_t rawtime;
-    time(&rawtime);
-    return http_format_date(rawtime, buf, size);
+    time_t raw_time;
+    time(&raw_time);
+    return http_format_date(raw_time, buf, size);
 }

-const http_doc_info *http_get_status_info(const http_status *status) {
-    unsigned short code = status->code;
-    static http_doc_info info[] = {
+const http_doc_info *http_get_status_info(status_code_t status_code) {
+    static const http_doc_info info[] = {
            {"info",    HTTP_COLOR_INFO,    "/.sesimos/res/icon-info.svg",    http_info_doc},
            {"success", HTTP_COLOR_SUCCESS, "/.sesimos/res/icon-success.svg", http_success_doc},
            {"warning", HTTP_COLOR_WARNING, "/.sesimos/res/icon-warning.svg", http_warning_doc},
            {"error",   HTTP_COLOR_ERROR,   "/.sesimos/res/icon-error.svg",   http_error_doc}
    };
-    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];
+    if (status_code == 304) return &info[1];
+    switch (status_code / 100) {
+        case 1: return &info[0];
+        case 2: return &info[1];
+        case 3: return &info[2];
+        case 4: // see case 5
+        case 5: return &info[3];
+        default: return NULL;
    }
-    return NULL;
 }

 int http_get_compression(const http_req *req, const http_res *res) {
@@ -426,9 +443,9 @@ int http_get_compression(const http_req *req, const http_res *res) {
    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) {
+        if (strcontains(accept_encoding, "br")) {
            return COMPRESS_BR;
-        } else if (strstr(accept_encoding, "gzip") != NULL) {
+        } else if (strcontains(accept_encoding, "gzip")) {
            return COMPRESS_GZ;
        }
    }
--- a/src/lib/http.h
+++ b/src/lib/http.h
@@ -52,7 +52,6 @@
 #define HTTP_ERROR_HEADER_MALFORMED 5
 #define HTTP_ERROR_INVALID_VERSION 6
 #define HTTP_ERROR_URI_TOO_LONG 7
-#define HTTP_ERROR_

 #ifndef SERVER_STR
 #   define SERVER_STR "sesimos"
@@ -62,14 +61,16 @@
 #   define SERVER_STR_HTML "sesimos&nbsp;web&nbsp;server"
 #endif

+typedef unsigned short status_code_t;
+
 typedef struct {
-    unsigned short code:10;
+    status_code_t code:10;
    unsigned char type:3;
    char msg[64];
 } http_status;

 typedef struct {
-    unsigned short code:10;
+    status_code_t code:10;
    const char *msg;
 } http_status_msg;

@@ -121,7 +122,7 @@ typedef enum {
 } http_error_origin;

 typedef struct {
-    unsigned short status;
+    status_code_t status;
    http_error_origin origin;
    const char* ws_key;
 } http_status_ctx;
@@ -133,6 +134,8 @@ extern const int http_status_messages_size;

 extern const char http_error_doc[], http_warning_doc[], http_success_doc[], http_info_doc[];

+const char *http_error_str(int err);
+
 void http_to_camel_case(char *str, int mode);

 const char *http_field_get_name(const http_field *field);
@@ -157,12 +160,8 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,

 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);
@@ -175,17 +174,17 @@ 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 *http_get_status(status_code_t status_code);

-const http_status_msg *http_get_error_msg(const http_status *status);
+const http_status_msg *http_get_error_msg(status_code_t status_code);

-const char *http_get_status_color(const http_status *status);
+const char *http_get_status_color(status_code_t status_code);

 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);
+const http_doc_info *http_get_status_info(status_code_t status_code);

 int http_get_compression(const http_req *req, const http_res *res);

--- a/src/lib/list.c
+++ b/src/lib/list.c
@@ -6,6 +6,8 @@
 #include <errno.h>

 #define FACTOR 4
+#define meta(ptr) ((list_meta_t *) ((unsigned char *) (ptr) - sizeof(list_meta_t)))
+#define data(ptr) ((unsigned char *) (ptr) + sizeof(list_meta_t))

 typedef struct {
    int init_size, elem_size, max_size, size;
@@ -30,21 +32,24 @@ void *list_create(int elem_size, int init_elem_n) {
    }

    void *list_ptr = malloc(sizeof(list_meta_t) + elem_size * init_elem_n);
+    if (list_ptr == NULL)
+        return NULL;
+
+    memset(list_ptr, 0, sizeof(list_meta_t) + elem_size * init_elem_n);
    list_meta_t *list = list_ptr;
    list->init_size = init_elem_n;
    list->elem_size = elem_size;
    list->max_size = init_elem_n;
    list->size = 0;
-    return (unsigned char *) list_ptr + sizeof(list_meta_t);
+    return data(list_ptr);
 }

 int list_size(const void *list_ptr) {
-    list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
-    return list->size;
+    return meta(list_ptr)->size;
 }

 int list_find(void *list_ptr, void *elem) {
-    list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
+    list_meta_t *list = meta(list_ptr);
    unsigned char *array = list_ptr;

    for (int i = 0; i < list->size; i++) {
@@ -60,32 +65,31 @@ void *list_insert(void *list_ptr, void *elem, int n) {
    void *ptr = NULL;
    list_ptr = list_insert_ptr(list_ptr, &ptr, n);
    if (list_ptr != NULL && ptr != NULL) {
-        list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
-        memcpy(ptr, elem, list->elem_size);
+        memcpy(ptr, elem, meta(list_ptr)->elem_size);
    }

    return list_ptr;
 }

 void *list_insert_ptr(void *list_ptr, void **elem, int n) {
-    list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
+    list_meta_t *list = meta(list_ptr);
    if (n < 0)
        n = list->size + n + 1;

    if (list->size >= list->max_size) {
-        if ((list = list_resize(list, list->max_size * FACTOR)) == NULL) {
+        if ((list = list_resize(list, list->max_size * FACTOR)) == NULL)
            return NULL;
    }
-    }

-    unsigned char *array = (unsigned char *) list + sizeof(list_meta_t);
+    unsigned char *array = data(list);

    if (n < list->size)
        memmove(array + (n + 1) * list->elem_size, array + n * list->elem_size, (list->size - n) * list->elem_size);
    *elem = array + n * list->elem_size;
+    memset(*elem, 0, list->elem_size);

    list->size++;
-    return (unsigned char *) list + sizeof(list_meta_t);
+    return array;
 }

 void *list_append(void *list_ptr, void *elem) {
@@ -97,7 +101,7 @@ void *list_append_ptr(void *list_ptr, void **elem) {
 }

 void *list_remove(void *list_ptr, int n) {
-    list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
+    list_meta_t *list = meta(list_ptr);
    if (n < 0)
        n = list->size + n;

@@ -107,13 +111,15 @@ void *list_remove(void *list_ptr, int n) {
        memmove(array + n * list->elem_size, array + (n + 1) * list->elem_size, (list->size - n - 1) * list->elem_size);

    list->size--;
-    if (list->size < list->max_size / FACTOR / 2 && list->max_size / FACTOR >= list->init_size) {
+    memset(array + list->size * list->elem_size, 0, list->elem_size);
+
+    if (list->size <= list->max_size / FACTOR * 3 / 4 && list->max_size / FACTOR >= list->init_size) {
        if ((list = list_resize(list, list->max_size / FACTOR)) == NULL) {
            return NULL;
        }
    }

-    return (unsigned char *) list + sizeof(list_meta_t);
+    return data(list);
 }

 void *list_delete(void *list_ptr, void *elem) {
@@ -126,14 +132,12 @@ void *list_delete(void *list_ptr, void *elem) {
 }

 void *list_clear(void *list_ptr) {
-    list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
+    list_meta_t *list = meta(list_ptr);
    list->size = 0;
    memset(list_ptr, 0, list->max_size * list->elem_size);
-    list->max_size = list->init_size;
-    return (unsigned char *) list_resize(list, list->max_size * list->elem_size) + sizeof(list_meta_t);
+    return data(list_resize(list, list->init_size));
 }

 void list_free(void *list_ptr) {
-    list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
-    free(list);
+    free(meta(list_ptr));
 }
--- a/src/lib/proxy.c
+++ b/src/lib/proxy.c
@@ -89,8 +89,10 @@ void proxy_unload(void) {
 void proxy_close_all(void) {
    proxy_ctx_t *ptr = proxies;
    for (int i = 0; i < MAX_PROXY_CNX_PER_HOST * num_proxy_hosts; i++, ptr++) {
-        if (ptr->initialized)
+        if (ptr->initialized) {
            proxy_close(ptr);
+            logger_set_prefix("");
+        }
    }
 }

@@ -161,20 +163,19 @@ int proxy_request_header(http_req *req, sock *sock) {
        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(sock->addr, ':') != NULL;
    int server_ipv6 = strchr(sock->s_addr, ':') != NULL;

    p_len = snprintf(buf1, sizeof(buf1), "by=%s%s%s;for=%s%s%s;host=%s;proto=%s",
                     server_ipv6 ? "\"[" : "", sock->s_addr, server_ipv6 ? "]\"" : "",
                     client_ipv6 ? "\"[" : "", sock->addr, client_ipv6 ? "]\"" : "",
-                     host, sock->enc ? "https" : "http");
+                     http_get_header_field(&req->hdr, "Host"), sock->enc ? "https" : "http");
    if (p_len < 0 || p_len >= sizeof(buf1)) {
        error("Appended part of header field 'Forwarded' too long");
        return -1;
    }

+    const char *forwarded = http_get_header_field(&req->hdr, "Forwarded");
    if (forwarded == NULL) {
        http_add_header_field(&req->hdr, "Forwarded", buf1);
    } else {
@@ -197,9 +198,10 @@ int proxy_request_header(http_req *req, sock *sock) {
    }

    const char *xfh = http_get_header_field(&req->hdr, "X-Forwarded-Host");
+    forwarded = http_get_header_field(&req->hdr, "Forwarded");
    if (xfh == NULL) {
        if (forwarded == NULL) {
-            http_add_header_field(&req->hdr, "X-Forwarded-Host", host);
+            http_add_header_field(&req->hdr, "X-Forwarded-Host", http_get_header_field(&req->hdr, "Host"));
        } else {
            char *ptr = strchr(forwarded, ',');
            unsigned long len;
@@ -218,6 +220,7 @@ int proxy_request_header(http_req *req, sock *sock) {
    }

    const char *xfp = http_get_header_field(&req->hdr, "X-Forwarded-Proto");
+    forwarded = http_get_header_field(&req->hdr, "Forwarded");
    if (xfp == NULL) {
        if (forwarded == NULL) {
            http_add_header_field(&req->hdr, "X-Forwarded-Proto", sock->enc ? "https" : "http");
@@ -307,11 +310,9 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
        goto proxy;

    retry:
-    if (proxy->initialized) {
-        info(BLUE_STR "Closing proxy connection");
-        sock_close(&proxy->proxy);
-        proxy->initialized = 0;
-    }
+    if (proxy->initialized)
+        proxy_close(proxy);
+
    retry = 0;
    tries++;

@@ -323,7 +324,7 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
        return -1;
    }

-    if (sock_set_timeout(&proxy->proxy, SERVER_TIMEOUT_INIT) != 0)
+    if (sock_set_socket_timeout(&proxy->proxy, 1) != 0 || sock_set_timeout(&proxy->proxy, SERVER_TIMEOUT_INIT) != 0)
        goto proxy_timeout_err;

    struct hostent *host_ent = gethostbyname2(conf->proxy.hostname, AF_INET6);
@@ -382,7 +383,8 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu

        ret = SSL_do_handshake(proxy->proxy.ssl);
        if (ret != 1) {
-            error_ssl(SSL_get_error(proxy->proxy.ssl, (int) ret));
+            sock_error(&proxy->proxy, ret);
+            SSL_free(proxy->proxy.ssl);
            res->status = http_get_status(502);
            ctx->origin = SERVER_REQ;
            error("Unable to perform handshake");
@@ -398,10 +400,10 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu

    proxy:
    connection = http_get_header_field(&req->hdr, "Connection");
-    if (connection != NULL && (strstr(connection, "upgrade") != NULL || strstr(connection, "Upgrade") != NULL)) {
+    if (strcontains(connection, "upgrade") || strcontains(connection, "Upgrade")) {
        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) {
+        if (streq(upgrade, "websocket") && streq(ws_version, "13")) {
            ctx->ws_key = http_get_header_field(&req->hdr, "Sec-WebSocket-Key");
        } else {
            res->status = http_get_status(501);
@@ -437,7 +439,7 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
    ret = 0;
    if (content_len > 0) {
        ret = sock_splice(&proxy->proxy, client, buffer, sizeof(buffer), content_len);
-    } else if (transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL) {
+    } else if (strcontains(transfer_encoding, "chunked")) {
        ret = sock_splice_chunked(&proxy->proxy, client, buffer, sizeof(buffer));
    }

@@ -462,7 +464,7 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
        return -1;
    }

-    ret = sock_recv(&proxy->proxy, buffer, sizeof(buffer), MSG_PEEK);
+    ret = sock_recv(&proxy->proxy, buffer, sizeof(buffer) - 1, MSG_PEEK);
    if (ret <= 0) {
        int e_sys = error_get_sys(), e_ssl = error_get_ssl();
        if (e_sys == EAGAIN || e_sys == EINPROGRESS || e_ssl == SSL_ERROR_WANT_READ || e_ssl == SSL_ERROR_WANT_WRITE) {
@@ -477,6 +479,7 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
        retry = tries < 4;
        goto proxy_err;
    }
+    buffer[ret] = 0;

    char *buf = buffer;
    unsigned short header_len = (unsigned short) (strstr(buffer, "\r\n\r\n") - buffer + 4);
@@ -510,7 +513,7 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
            goto proxy_err;
        }
        if (ptr == buf) {
-            if (strncmp(ptr, "HTTP/", 5) != 0) {
+            if (!strstarts(ptr, "HTTP/")) {
                res->status = http_get_status(502);
                ctx->origin = SERVER_RES;
                error("Unable to parse header: Invalid header format");
@@ -668,6 +671,21 @@ int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int
 }

 int proxy_dump(proxy_ctx_t *proxy, char *buf, long len) {
-    sock_recv(&proxy->proxy, buf, len, 0);
+    long ret = sock_recv(&proxy->proxy, buf, len, 0);
+    if (ret == -1) return -1;
+    buf[ret] = 0;
    return 0;
 }
+
+void proxy_close(proxy_ctx_t *ctx) {
+    client_ctx_t *cctx = ctx->client;
+    if (cctx) {
+        logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, cctx->req_host, CLR_STR, cctx->log_prefix);
+    }
+
+    info(BLUE_STR "Closing proxy connection");
+    sock_close(&ctx->proxy);
+
+    memset(ctx, 0, sizeof(*ctx));
+    errno = 0;
+}
--- a/src/lib/proxy.h
+++ b/src/lib/proxy.h
@@ -48,4 +48,6 @@ int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int

 int proxy_dump(proxy_ctx_t *proxy, char *buf, long len);

+void proxy_close(proxy_ctx_t *ctx);
+
 #endif //SESIMOS_PROXY_H
--- a/src/lib/sock.c
+++ b/src/lib/sock.c
@@ -15,6 +15,50 @@
 #include <string.h>
 #include <sys/socket.h>
 #include <unistd.h>
+#include <openssl/err.h>
+
+static void ssl_error(unsigned long err) {
+    if (err == SSL_ERROR_NONE) {
+        errno = 0;
+    } else if (err == SSL_ERROR_SYSCALL) {
+        // errno already set
+    } else if (err == SSL_ERROR_SSL) {
+        error_ssl_err(ERR_get_error());
+    } else {
+        error_ssl(err);
+    }
+}
+
+void sock_error(sock *s, int ret) {
+    ssl_error(SSL_get_error(s->ssl, ret));
+}
+
+const char *sock_error_str(unsigned long err) {
+    switch (err) {
+        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_WANT_ASYNC:
+            return "want async";
+        case SSL_ERROR_WANT_ASYNC_JOB:
+            return "want async job";
+        case SSL_ERROR_WANT_CLIENT_HELLO_CB:
+            return "want client hello callback";
+            //case SSL_ERROR_WANT_RETRY_VERIFY:
+            //    return "want retry verify";
+        default:
+            return "unknown error";
+    }
+}

 int sock_set_socket_timeout_micros(sock *s, long recv_micros, long send_micros) {
    struct timeval recv_to = {.tv_sec = recv_micros / 1000000, .tv_usec = recv_micros % 1000000},
@@ -49,7 +93,7 @@ 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);
-        if (ret <= 0) error_ssl(SSL_get_error(s->ssl, (int) ret));
+        if (ret <= 0) sock_error(s, (int) ret);
    } else {
        ret = send(s->socket, buf, len, flags);
    }
@@ -67,7 +111,7 @@ long sock_recv(sock *s, void *buf, unsigned long len, int flags) {
    if (s->enc) {
        int (*func)(SSL*, void*, int) = (flags & MSG_PEEK) ? SSL_peek : SSL_read;
        ret = func(s->ssl, buf, (int) len);
-        if (ret <= 0) error_ssl(SSL_get_error(s->ssl, (int) ret));
+        if (ret <= 0) sock_error(s, (int) ret);
    } else {
        ret = recv(s->socket, buf, len, flags);
    }
--- a/src/lib/sock.h
+++ b/src/lib/sock.h
@@ -26,6 +26,10 @@ typedef struct {
    long ts_start, ts_last, timeout_us;
 } sock;

+void sock_error(sock *s, int ret);
+
+const char *sock_error_str(unsigned long err);
+
 int sock_set_socket_timeout_micros(sock *s, long recv_micros, long send_micros);

 int sock_set_socket_timeout(sock *s, double sec);
--- a/src/lib/uri.c
+++ b/src/lib/uri.c
@@ -15,21 +15,26 @@


 int path_is_directory(const char *path) {
-    struct stat statbuf;
-    return stat(path, &statbuf) == 0 && S_ISDIR(statbuf.st_mode) != 0;
+    int e = errno;
+    struct stat stat_buf;
+    int ret = stat(path, &stat_buf);
+    errno = e;
+    return ret == 0 && S_ISDIR(stat_buf.st_mode) != 0;
 }

 int path_is_file(const char *path) {
-    struct stat statbuf;
-    int ret = stat(path, &statbuf);
-    errno = 0;
-    return ret == 0 && S_ISDIR(statbuf.st_mode) == 0;
+    int e = errno;
+    struct stat stat_buf;
+    int ret = stat(path, &stat_buf);
+    errno = e;
+    return ret == 0 && S_ISDIR(stat_buf.st_mode) == 0;
 }

 int path_exists(const char *path) {
-    struct stat statbuf;
-    int ret = stat(path, &statbuf);
-    errno = 0;
+    int e = errno;
+    struct stat stat_buf;
+    int ret = stat(path, &stat_buf);
+    errno = e;
    return ret == 0;
 }

@@ -73,7 +78,7 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
    if (query != NULL) {
        query[-1] = '?';
    }
-    if (strstr(uri->req_path, "/../") != NULL || strstr(uri->req_path, "/./") != NULL) {
+    if (strcontains(uri->req_path, "/../") || strcontains(uri->req_path, "/./")) {
        return 2;
    }

@@ -140,10 +145,10 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
        uri->filename = malloc(strlen(buf0) + 1);
        strcpy(uri->filename, buf0);
        long len = (long) strlen(uri->path);
-        if (strcmp(uri->path + len - 4, ".ncr") == 0 || strcmp(uri->path + len - 4, ".php") == 0) {
+        if (strends(uri->path, ".ncr") || strends(uri->path, ".php")) {
            uri->path[len - 4] = 0;
            uri->is_static = 0;
-        } else if (strcmp(uri->path + len - 5, ".html") == 0) {
+        } else if (strends(uri->path, ".html")) {
            uri->path[len - 5] = 0;
        }
    } else if (path_is_file(buf1)) {
@@ -190,12 +195,12 @@ 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) {
+    if (strends(uri->path + strlen(uri->path), "index")) {
        uri->path[strlen(uri->path) - 5] = 0;
    }
-    if (strcmp(uri->pathinfo, "index.ncr") == 0 ||
-        strcmp(uri->pathinfo, "index.php") == 0 ||
-        strcmp(uri->pathinfo, "index.html") == 0) {
+    if (streq(uri->pathinfo, "index.ncr") ||
+        streq(uri->pathinfo, "index.php") ||
+        streq(uri->pathinfo, "index.html")) {
        uri->pathinfo[0] = 0;
    }

--- a/src/lib/uri.h
+++ b/src/lib/uri.h
@@ -26,7 +26,7 @@ typedef struct {
    char charset[URI_CHARSET_SIZE];
    char filename_comp_gz[256];
    char filename_comp_br[256];
-    struct stat stat;
+    long mtime;
 } metadata_t;

 typedef struct {
--- a/src/lib/utils.c
+++ b/src/lib/utils.c
@@ -12,6 +12,10 @@
 #include <string.h>
 #include <stdlib.h>
 #include <time.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+#include <dirent.h>


 static const char base64_encode_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -113,34 +117,44 @@ int url_decode(const char *str, char *dec, long *size) {
    return 0;
 }

-int mime_is_compressible(const char *type) {
+int mime_is_compressible(const char *restrict 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;
+        mime_is_text(type) ||
+        streq(type_parsed, "application/vnd.ms-fontobject") ||
+        streq(type_parsed, "application/x-font-ttf") ||
+        streq(type_parsed, "font/eot") ||
+        streq(type_parsed, "font/opentype") ||
+        streq(type_parsed, "image/bmp") ||
+        streq(type_parsed, "image/gif") ||
+        streq(type_parsed, "image/vnd.microsoft.icon") ||
+        streq(type_parsed, "image/vnd.microsoft.iconbinary") ||
+        streq(type_parsed, "image/x-icon");
+}
+
+int mime_is_text(const char *restrict 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
+        strstarts(type_parsed, "text/") ||
+        strstarts(type_parsed, "message/") ||
+        strends(type_parsed, "+xml") ||
+        strends(type_parsed, "+json") ||
+        streq(type_parsed, "application/javascript") ||
+        streq(type_parsed, "application/json") ||
+        streq(type_parsed, "application/xml") ||
+        streq(type_parsed, "application/x-www-form-urlencoded") ||
+        streq(type_parsed, "application/x-tex") ||
+        streq(type_parsed, "application/x-httpd-php") ||
+        streq(type_parsed, "application/x-latex") ||
+        streq(type_parsed, "application/x-javascript");
 }

 int strcpy_rem_webroot(char *dst, const char *src, long len, const char *webroot) {
@@ -183,6 +197,26 @@ int str_trim_lws(char **start, char **end) {
    return 0;
 }

+int streq(const char *restrict str1, const char *restrict str2) {
+    return str1 != NULL && str2 != NULL && strcmp(str1, str2) == 0;
+}
+
+int strcontains(const char *restrict haystack, const char *restrict needle) {
+    return haystack != NULL && needle != NULL && strstr(haystack, needle) != NULL;
+}
+
+int strstarts(const char *restrict str, const char *restrict prefix) {
+    if (str == NULL || prefix == NULL) return 0;
+    unsigned long l1 = strlen(str), l2 = strlen(prefix);
+    return l2 <= l1 && strncmp(str, prefix, l2) == 0;
+}
+
+int strends(const char *restrict str, const char *restrict suffix) {
+    if (str == NULL || suffix == NULL) return 0;
+    unsigned long l1 = strlen(str), l2 = strlen(suffix);
+    return l2 <= l1 && strcmp(str + l1 - l2, suffix) == 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;
@@ -216,3 +250,136 @@ long clock_cpu(void) {
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time);
    return time.tv_sec * 1000000000 + time.tv_nsec;
 }
+
+long stat_mtime(const char *filename) {
+    struct stat stat_buf;
+    stat(filename, &stat_buf);
+    return stat_buf.st_mtime;
+}
+
+int rm_rf(const char *path) {
+    struct stat stat_buf;
+    if (lstat(path, &stat_buf) != 0)
+        return (errno == ENOENT) ? 0 : -1;
+
+    if (S_ISREG(stat_buf.st_mode)) {
+        // regular file
+        return unlink(path);
+    } else if (S_ISLNK(stat_buf.st_mode)) {
+        // link
+        return unlink(path);
+    } else if (S_ISDIR(stat_buf.st_mode)) {
+        // directory
+        char buf[FILENAME_MAX];
+        DIR *dir;
+
+        // open directory
+        if ((dir = opendir(path)) == NULL)
+            return -1;
+
+        // read directory
+        for (struct dirent *ent; (ent = readdir(dir)) != NULL;) {
+            if (streq(ent->d_name, ".") || streq(ent->d_name, ".."))
+                continue;
+
+            snprintf(buf, sizeof(buf), "%s/%s", path, ent->d_name);
+            if (rm_rf(buf) != 0) {
+                closedir(dir);
+                return -1;
+            }
+        }
+
+        // close and remove directory
+        closedir(dir);
+        return rmdir(path);
+    } else {
+        // other - not supported
+        errno = ENOTSUP;
+        return -1;
+    }
+}
+
+long fsize(FILE *file) {
+    long cur_pos, len;
+    if ((cur_pos = ftell(file)) == -1)
+        return -1;
+    if (fseek(file, 0, SEEK_END) != 0)
+        return -1;
+    if ((len = ftell(file)) == -1)
+        return -1;
+    if (fseek(file, cur_pos, SEEK_SET) != 0)
+        return -1;
+    return len;
+}
+
+long flines(FILE *file) {
+    long cur_pos, lines = 0;
+    if ((cur_pos = ftell(file)) == -1)
+        return -1;
+    if (fseek(file, 0, SEEK_SET) != 0)
+        return -1;
+
+    for (int ch; (ch = fgetc(file)) != EOF;) {
+        if (ch == '\n') lines++;
+    }
+
+    if (fseek(file, cur_pos, SEEK_SET) != 0)
+        return -1;
+    return lines + 1;
+}
+
+long file_get_line_pos(FILE *file, long line_num) {
+    if (line_num < 1) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    long cur_pos;
+    if ((cur_pos = ftell(file)) == -1)
+        return -1;
+    if (fseek(file, 0, SEEK_SET) != 0)
+        return -1;
+
+    long lines = 0, pos = 0;
+    for (int ch; lines < line_num - 1 && (ch = fgetc(file)) != EOF; pos++) {
+        if (ch == '\n') lines++;
+    }
+
+    if (fseek(file, cur_pos, SEEK_SET) != 0)
+        return -1;
+    return pos;
+}
+
+int fseekl(FILE *file, long line_num) {
+    if (line_num < 1) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (fseek(file, 0, SEEK_SET) != 0)
+        return -1;
+
+    long lines = 0;
+    for (int ch; lines < line_num - 1 && (ch = fgetc(file)) != EOF;) {
+        if (ch == '\n') lines++;
+    }
+
+    return 0;
+}
+
+long ftelll(FILE *file) {
+    long cur_pos;
+    if ((cur_pos = ftell(file)) == -1)
+        return -1;
+    if (fseek(file, 0, SEEK_SET) != 0)
+        return -1;
+
+    long lines = 0, pos = 0;
+    for (int ch; pos < cur_pos && (ch = fgetc(file)) != EOF; pos++) {
+        if (ch == '\n') lines++;
+    }
+
+    if (fseek(file, cur_pos, SEEK_SET) != 0)
+        return -1;
+    return lines + 1;
+}
--- a/src/lib/utils.h
+++ b/src/lib/utils.h
@@ -27,7 +27,9 @@ 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 mime_is_compressible(const char *restrict type);
+
+int mime_is_text(const char *restrict type);

 int strcpy_rem_webroot(char *dst, const char *str, long len, const char *webroot);

@@ -35,10 +37,32 @@ int str_trim(char **start, char **end);

 int str_trim_lws(char **start, char **end);

+int streq(const char *restrict str1, const char *restrict str2);
+
+int strcontains(const char *restrict haystack, const char *restrict needle);
+
+int strstarts(const char *restrict str, const char *restrict prefix);
+
+int strends(const char *restrict str, const char *restrict suffix);
+
 int base64_encode(void *data, unsigned long data_len, char *output, unsigned long *output_len);

 long clock_micros(void);

 long clock_cpu(void);

+long stat_mtime(const char *filename);
+
+int rm_rf(const char *path);
+
+long fsize(FILE *file);
+
+long flines(FILE *file);
+
+long file_get_line_pos(FILE *file, long line_num);
+
+int fseekl(FILE *file, long line_num);
+
+long ftelll(FILE *file);
+
 #endif //SESIMOS_UTILS_H
--- a/src/logger.c
+++ b/src/logger.c
@@ -165,14 +165,15 @@ static int logger_remaining(void) {
 void logger_set_name(const char *restrict format, ...) {
    va_list args;

+    void *ptr;
    if (key_name == -1) {
        // not initialized
        va_start(args, format);
        vsnprintf(global_name, sizeof(global_name), format, args);
+        ptr = global_name;
    } else {
        int ret;
-        void *ptr = pthread_getspecific(key_name);
-        if (!ptr) {
+        if ((ptr = pthread_getspecific(key_name)) == NULL) {
            ptr = malloc(LOG_NAME_LEN);
            if ((ret = pthread_setspecific(key_name, ptr)) != 0) {
                errno = ret;
@@ -185,6 +186,9 @@ void logger_set_name(const char *restrict format, ...) {
        vsnprintf(ptr, LOG_NAME_LEN, format, args);
    }

+    // set thread name
+    pthread_setname_np(pthread_self(), global_name);
+
    // cleanup
    va_end(args);
 }
@@ -278,4 +282,9 @@ int logger_init(void) {

 void logger_stop(void) {
    alive = 0;
+    pthread_kill(thread, SIGUSR1);
+}
+
+int logger_join(void) {
+    return pthread_join(thread, NULL);
 }
--- a/src/logger.h
+++ b/src/logger.h
@@ -37,4 +37,6 @@ int logger_init(void);

 void logger_stop(void);

+int logger_join(void);
+
 #endif //SESIMOS_LOGGER_H
--- a/src/server.c
+++ b/src/server.c
@@ -32,21 +32,43 @@
 #include <openssl/pem.h>
 #include <openssl/ssl.h>
 #include <openssl/conf.h>
-
+#include <semaphore.h>

 const char *config_file;
-
 static int sockets[NUM_SOCKETS];
 static SSL_CTX *contexts[CONFIG_MAX_CERT_CONFIG];
-
 static client_ctx_t **clients;
+static sem_t sem_clients_lock;

-static const char *color_table[] = {"\x1B[31m", "\x1B[32m", "\x1B[33m", "\x1B[34m", "\x1B[35m", "\x1B[36m"};
+static void clean(void) {
+    notice("Cleaning sesimos cache and metadata files...");

-static int clean() {
-    remove("/var/sesimos/server/cache");
-    rmdir("/var/sesimos/server/");
-    return 0;
+    // remove legacy files
+    //     /.../server/, /.../server/cache
+    if (rm_rf("/var/sesimos/server") != 0) {
+        error("Unable to remove /var/sesimos/server/");
+    } else if (!errno) {
+        notice("Successfully removed /var/sesimos/server/");
+    }
+    errno = 0;
+
+    // remove cache and metadata files
+    char buf[512];
+    for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
+        host_config_t *hc = &config.hosts[i];
+        if (hc->type == CONFIG_TYPE_UNSET) break;
+        if (hc->type != CONFIG_TYPE_LOCAL) continue;
+
+        snprintf(buf, sizeof(buf), "%s/.sesimos", hc->local.webroot);
+        if (rm_rf(buf) != 0) {
+            error("Unable to remove %s/", buf);
+        } else if (!errno) {
+            notice("Successfully removed %s/", buf);
+        }
+        errno = 0;
+    }
+
+    notice("Cleaned all sesimos cache and metadata files!");
 }

 static int ssl_servername_cb(SSL *ssl, int *ad, void *arg) {
@@ -59,15 +81,39 @@ static int ssl_servername_cb(SSL *ssl, int *ad, void *arg) {
 }

 void server_free_client(client_ctx_t *ctx) {
-    for (int i = 0; i < list_size(clients); i++) {
-        if (clients[i] == ctx) {
-            clients = list_remove(clients, i);
-            break;
+    // try to lock clients list
+    retry:
+    if (sem_wait(&sem_clients_lock) != 0) {
+        if (errno == EINTR) {
+            goto retry;
+        } else {
+            critical("Unable to lock clients list");
+            return;
        }
    }
+
+    // delete from list
+    clients = list_delete(clients, &ctx);
+    if (clients == NULL) {
+        critical("Unable to delete context from list");
+        return;
+    }
+
+    // unlock clients list
+    sem_post(&sem_clients_lock);
+
+    // free data
    free(ctx);
 }

+static void ssl_free() {
+    for (int i = 0; i < CONFIG_MAX_CERT_CONFIG; i++) {
+        const cert_config_t *conf = &config.certs[i];
+        if (conf->name[0] == 0) break;
+        SSL_CTX_free(contexts[i]);
+    }
+}
+
 static void accept_cb(void *arg) {
    int i = (int) (((int *) arg) - sockets);
    int fd = sockets[i];
@@ -78,15 +124,6 @@ static void accept_cb(void *arg) {
        errno = 0;
        return;
    }
-
-    clients = list_append(clients, &client_ctx);
-    if (clients == NULL) {
-        critical("Unable to add client context to list");
-        errno = 0;
-        return;
-    }
-
-    client_ctx->in_use = 1;
    sock *client = &client_ctx->socket;

    client->ctx = contexts[0];
@@ -94,6 +131,7 @@ static void accept_cb(void *arg) {
    int client_fd = accept(fd, &client->_addr.sock, &addr_len);
    if (client_fd < 0) {
        critical("Unable to accept connection");
+        free(client_ctx);
        return;
    }

@@ -104,6 +142,29 @@ static void accept_cb(void *arg) {
    client_ctx->cnx_s = client->ts_start;
    client_ctx->cnx_e = -1, client_ctx->req_s = -1, client_ctx->req_e = -1, client_ctx->res_ts = -1;

+    // try to lock clients list
+    retry:
+    if (sem_wait(&sem_clients_lock) != 0) {
+        if (errno == EINTR) {
+            goto retry;
+        } else {
+            critical("Unable to lock clients list");
+            return;
+        }
+    }
+
+    // append to list
+    clients = list_append(clients, &client_ctx);
+    if (clients == NULL) {
+        critical("Unable to add client context to list");
+        free(client_ctx);
+        errno = 0;
+        return;
+    }
+
+    // unlock clients list
+    sem_post(&sem_clients_lock);
+
    tcp_accept(client_ctx);
 }

@@ -140,11 +201,11 @@ static void terminate_gracefully(int sig) {
    workers_stop();
    workers_destroy();

-    for (int i = 0; i < list_size(clients); i++) {
-        tcp_close(clients[i]);
-    }
-    proxy_close_all();
+    while (list_size(clients) > 0)
+        tcp_close(clients[0]);
+
    logger_set_prefix("");
+    proxy_close_all();

    async_stop();
 }
@@ -154,21 +215,15 @@ static void nothing(int sig) {}
 int main(int argc, char *const argv[]) {
    const int YES = 1;
    int ret;
+    int mode = 0;

    memset(sockets, 0, sizeof(sockets));
-    clients = list_create(sizeof(void *), 64);
-    if (clients == NULL) {
-        critical("Unable to initialize client list");
-        return 1;
-    }

    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)}
    };

-    logger_init();
-
    logger_set_name("server");

    if (setvbuf(stdout, NULL, _IOLBF, 0) != 0 || setvbuf(stderr, NULL, _IOLBF, 0) != 0) {
@@ -179,13 +234,13 @@ int main(int argc, char *const argv[]) {

    static const struct option long_opts[] = {
            {"help",    no_argument,        0, 'h'},
+            {"clean",   no_argument,        0, 'C'},
            {"config",  required_argument,  0, 'c'},
            { 0,        0,                  0,  0 }
    };

    config_file = NULL;
-    int c, opt_idx;
-    while ((c = getopt_long(argc, argv, "hc:", long_opts, &opt_idx)) != -1) {
+    for (int c, opt_idx; (c = getopt_long(argc, argv, "hCc:", long_opts, &opt_idx)) != -1;) {
        switch (c) {
            case 'h':
                fprintf(stderr,
@@ -193,11 +248,15 @@ int main(int argc, char *const argv[]) {
                        "\n"
                        "Options:\n"
                        "  -c, --config <CONFIG-FILE>  path to the config file. If not provided, default will be used\n"
+                        "  -C, --clean                 clear cached files and other metadata\n"
                        "  -h, --help                  print this dialogue\n");
                return 0;
            case 'c':
                config_file = optarg;
                break;
+            case 'C':
+                mode = 1;
+                break;
            case '?':
            default:
                critical("Unable to parse arguments");
@@ -213,6 +272,11 @@ int main(int argc, char *const argv[]) {
    if (config_load(config_file == NULL ? DEFAULT_CONFIG_FILE : config_file) != 0)
        return 1;

+    if (mode == 1) {
+        clean();
+        return 0;
+    }
+
    if ((sockets[0] = socket(AF_INET6, SOCK_STREAM, 0)) == -1 ||
        (sockets[1] = socket(AF_INET6, SOCK_STREAM, 0)) == -1)
    {
@@ -281,15 +345,35 @@ int main(int argc, char *const argv[]) {
        }
    }

+    clients = list_create(sizeof(client_ctx_t *), 64);
+    if (clients == NULL) {
+        critical("Unable to initialize client list");
+        ssl_free();
+        return 1;
+    }
+
+    if (sem_init(&sem_clients_lock, 0, 1) != 0) {
+        critical("Unable to create clients lock semaphore");
+        ssl_free();
+        list_free(clients);
+        return 1;
+    }
+
    if (async_init() != 0) {
        critical("Unable to initialize async thread");
+        ssl_free();
        geoip_free();
+        list_free(clients);
+        sem_destroy(&sem_clients_lock);
        return 1;
    }

    if (proxy_preload() != 0) {
        critical("Unable to initialize proxy");
+        ssl_free();
        geoip_free();
+        list_free(clients);
+        sem_destroy(&sem_clients_lock);
        async_free();
        return 1;
    }
@@ -297,12 +381,19 @@ int main(int argc, char *const argv[]) {
    for (int i = 0; i < NUM_SOCKETS; i++) {
        if (listen(sockets[i], LISTEN_BACKLOG) < 0) {
            critical("Unable to listen on socket %i", i);
+            ssl_free();
            geoip_free();
+            list_free(clients);
+            sem_destroy(&sem_clients_lock);
+            async_free();
            proxy_unload();
            return 1;
        }
    }

+    logger_init();
+    logger_set_name("server");
+
    workers_init();

    for (int i = 0; i < NUM_SOCKETS; i++) {
@@ -316,10 +407,14 @@ int main(int argc, char *const argv[]) {
    notice("Goodbye!");

    // cleanup
+    ssl_free();
    list_free(clients);
+    sem_destroy(&sem_clients_lock);
    geoip_free();
    proxy_unload();
    cache_join();
    async_free();
+    logger_stop();
+    logger_join();
    return 0;
 }
--- a/src/worker/fastcgi_handler.c
+++ b/src/worker/fastcgi_handler.c
@@ -20,7 +20,7 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx);
 static int fastcgi_handler_2(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx);

 void fastcgi_handler_func(client_ctx_t *ctx) {
-    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);

    fastcgi_cnx_t fcgi_cnx;
    int ret = fastcgi_handler_1(ctx, &fcgi_cnx);
@@ -46,9 +46,9 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
    char buf[1024];

    int mode, ret;
-    if (strcmp(uri->filename + strlen(uri->filename) - 4, ".ncr") == 0) {
+    if (strends(uri->filename, ".ncr")) {
        mode = FASTCGI_SESIMOS;
-    } else if (strcmp(uri->filename + strlen(uri->filename) - 4, ".php") == 0) {
+    } else if (strends(uri->filename, ".php")) {
        mode = FASTCGI_PHP;
    } else {
        res->status = http_get_status(500);
@@ -73,7 +73,7 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
    if (client_content_length != NULL) {
        unsigned long client_content_len = strtoul(client_content_length, NULL, 10);
        ret = fastcgi_receive(fcgi_cnx, client, client_content_len);
-    } else if (client_transfer_encoding != NULL && strstr(client_transfer_encoding, "chunked") != NULL) {
+    } else if (strcontains(client_transfer_encoding, "chunked")) {
        ret = fastcgi_receive_chunked(fcgi_cnx, client);
    } else {
        ret = 0;
@@ -118,7 +118,7 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
    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 &&
+        strstarts(content_type, "text/html") &&
        ctx->content_length != -1 &&
        ctx->content_length <= sizeof(ctx->msg_content) - 1)
    {
@@ -157,7 +157,7 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {

 static int fastcgi_handler_2(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
    const char *transfer_encoding = http_get_header_field(&ctx->res.hdr, "Transfer-Encoding");
-    int chunked = (transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL);
+    int chunked = strcontains(transfer_encoding, "chunked");

    int flags = (chunked ? FASTCGI_CHUNKED : 0) | (ctx->use_fastcgi & (FASTCGI_COMPRESS | FASTCGI_COMPRESS_HOLD));
    int ret = fastcgi_send(fcgi_cnx, &ctx->socket, flags);
--- a/src/worker/func.h
+++ b/src/worker/func.h
@@ -9,6 +9,7 @@
 #ifndef SESIMOS_FUNC_H
 #define SESIMOS_FUNC_H

+#include "../defs.h"
 #include "../lib/sock.h"
 #include "../lib/http.h"
 #include "../lib/uri.h"
@@ -18,7 +19,7 @@
 typedef struct {
    sock socket;
    int req_num;
-    unsigned char in_use: 1, s_keep_alive:1, c_keep_alive:1, use_fastcgi:4, use_proxy:2, ws_close:2;
+    unsigned char s_keep_alive:1, c_keep_alive:1, use_fastcgi:4, use_proxy:2, ws_close:2;
    char cc[3], host[256];
    char req_host[256], err_msg[256];
    char log_prefix[128];
@@ -62,8 +63,6 @@ void timeout_request(client_ctx_t *ctx);

 void tcp_close(client_ctx_t *ctx);

-void proxy_close(proxy_ctx_t *ctx);
-
 int ws_handle_connection(client_ctx_t *ctx);

 void ws_close(ws_ctx_t *ctx);
--- a/src/worker/local_handler.c
+++ b/src/worker/local_handler.c
@@ -19,7 +19,7 @@
 static int local_handler(client_ctx_t *ctx);

 void local_handler_func(client_ctx_t *ctx) {
-    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);

    switch (local_handler(ctx)) {
        case 0:
@@ -36,6 +36,76 @@ void local_handler_func(client_ctx_t *ctx) {
    }
 }

+static int range_handler(client_ctx_t *ctx) {
+    char buf[64];
+    long num0, num1, num2;
+    char *ptr;
+    int mode;
+    const char *range = http_get_header_field(&ctx->req.hdr, "Range");
+
+    if (strcontains(range, ","))
+        return -1;
+
+    ctx->file = fopen(ctx->uri.filename, "rb");
+
+    if (strstarts(range, "bytes=")) {
+        mode = 0;
+        range += 6;
+        num0 = fsize(ctx->file), num1 = 0, num2 = num0 - 1;
+        sprintf(buf, "bytes */%li", num0);
+    } else if (strstarts(range, "lines=") && mime_is_text(ctx->uri.meta->type)) {
+        mode = 1;
+        range += 6;
+        num0 = flines(ctx->file), num1 = 1, num2 = num0;
+        sprintf(buf, "lines */%li", num0);
+    } else {
+        return -1;
+    }
+
+    http_add_header_field(&ctx->res.hdr, "Content-Range", buf);
+
+    if ((ptr = strchr(range, '-')) == NULL)
+        return -1;
+
+    if (num0 == 0) {
+        ctx->content_length = 0;
+        return 0;
+    }
+
+    if (ptr[1] != 0) num2 = (long) strtoul(ptr + 1, NULL, 10);
+    if (ptr != range) {
+        num1 = (long) strtoul(range, NULL, 10);
+    } else {
+        if (mode == 0) {
+            num1 = num0 - num2 - 1;
+            num2 = num0 - 1;
+        } else if (mode == 1) {
+            num1 = num0 - num2 + 1;
+            num2 = num0;
+        }
+    }
+
+    if ((mode == 0 && (num1 >= num0 || num2 >= num0 || num1 > num2 || num1 < 0 || num2 < 0)) ||
+        (mode == 1 && (num1 > num0 || num2 > num0 || num1 > num2 || num1 <= 0 || num2 <= 0)))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "%s %li-%li/%li", (mode == 0) ? "bytes" : "lines", num1, num2, num0);
+    http_remove_header_field(&ctx->res.hdr, "Content-Range", HTTP_REMOVE_ALL);
+    http_add_header_field(&ctx->res.hdr, "Content-Range", buf);
+
+    if (mode == 0) {
+        fseek(ctx->file, num1, SEEK_SET);
+        ctx->content_length = num2 - num1 + 1;
+    } else if (mode == 1) {
+        fseekl(ctx->file, num1);
+        ctx->content_length = file_get_line_pos(ctx->file, num2 + 1) - file_get_line_pos(ctx->file, num1);
+    }
+
+    return 0;
+}
+
 static int local_handler(client_ctx_t *ctx) {
    http_res *res = &ctx->res;
    http_req *req = &ctx->req;
@@ -45,14 +115,14 @@ static int local_handler(client_ctx_t *ctx) {
    char buf1[1024], buf2[1024];
    int accept_if_modified_since = 0;

-    if (strcmp(req->method, "TRACE") == 0) {
+    if (streq(req->method, "TRACE")) {
        res->status = http_get_status(200);
        http_add_header_field(&res->hdr, "Content-Type", "message/http");

        ctx->msg_buf_ptr = malloc(4096);
        ctx->msg_buf = ctx->msg_buf_ptr;
        ctx->content_length = snprintf(ctx->msg_buf, 4096 - ctx->content_length, "%s %s HTTP/%s\r\n", req->method, req->uri, req->version);
-        for (int i = 0; i < list_size(&req->hdr); i++) {
+        for (int i = 0; i < list_size(req->hdr.fields); i++) {
            const http_field *f = &req->hdr.fields[i];
            ctx->content_length += snprintf(ctx->msg_buf + ctx->content_length, 4096 - ctx->content_length, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
        }
@@ -60,11 +130,11 @@ static int local_handler(client_ctx_t *ctx) {
        return 0;
    }

-    if (strncmp(uri->req_path, "/.well-known/", 13) == 0) {
+    if (strstarts(uri->req_path, "/.well-known/")) {
        http_add_header_field(&res->hdr, "Access-Control-Allow-Origin", "*");
    }

-    if (strncmp(uri->req_path, "/.well-known/", 13) != 0 && strstr(uri->path, "/.") != NULL) {
+    if (!strstarts(uri->req_path, "/.well-known/") && strcontains(uri->path, "/.")) {
        res->status = http_get_status(403);
        sprintf(err_msg, "Parts of this URI are hidden.");
        return 0;
@@ -87,8 +157,11 @@ static int local_handler(client_ctx_t *ctx) {

    if (uri->is_static) {
        res->status = http_get_status(200);
-        http_add_header_field(&res->hdr, "Accept-Ranges", "bytes");
-        if (strcmp(req->method, "GET") != 0 && strcmp(req->method, "HEAD") != 0) {
+        cache_init_uri(ctx->conf->cache, uri);
+
+        http_add_header_field(&res->hdr, "Accept-Ranges", mime_is_text(uri->meta->type) ? "bytes, lines" : "bytes");
+
+        if (!streq(req->method, "GET") && !streq(req->method, "HEAD")) {
            res->status = http_get_status(405);
            return 0;
        }
@@ -99,18 +172,15 @@ static int local_handler(client_ctx_t *ctx) {
            return 0;
        }

-        cache_init_uri(ctx->conf->cache, uri);
-
-        const char *last_modified = http_format_date(uri->meta->stat.st_mtime, buf1, sizeof(buf1));
+        const char *last_modified = http_format_date(uri->meta->mtime, buf1, sizeof(buf1));
        http_add_header_field(&res->hdr, "Last-Modified", last_modified);
        sprintf(buf2, "%s; charset=%s", uri->meta->type, uri->meta->charset);
        http_add_header_field(&res->hdr, "Content-Type", buf2);

-
        const char *accept_encoding = http_get_header_field(&req->hdr, "Accept-Encoding");
        int enc = 0;
        if (accept_encoding != NULL) {
-            if (uri->meta->filename_comp_br[0] != 0 && strstr(accept_encoding, "br") != NULL) {
+            if (uri->meta->filename_comp_br[0] != 0 && strcontains(accept_encoding, "br")) {
                ctx->file = fopen(uri->meta->filename_comp_br, "rb");
                if (ctx->file == NULL) {
                    cache_mark_dirty(ctx->conf->cache, uri->filename);
@@ -119,7 +189,7 @@ static int local_handler(client_ctx_t *ctx) {
                    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) {
+            } else if (uri->meta->filename_comp_gz[0] != 0 && strcontains(accept_encoding, "gzip")) {
                ctx->file = fopen(uri->meta->filename_comp_gz, "rb");
                if (ctx->file == NULL) {
                    cache_mark_dirty(ctx->conf->cache, uri->filename);
@@ -135,80 +205,44 @@ static int local_handler(client_ctx_t *ctx) {
        }

        if (uri->meta->etag[0] != 0) {
+            strcpy(buf1, uri->meta->etag);
            if (enc) {
-                sprintf(buf1, "%s-%s", uri->meta->etag, (enc & COMPRESS_BR) ? "br" : (enc & COMPRESS_GZ) ? "gzip" : "");
-                http_add_header_field(&res->hdr, "ETag", buf1);
-            } else {
-                http_add_header_field(&res->hdr, "ETag", uri->meta->etag);
+                strcat(buf1, "-");
+                strcat(buf1, (enc & COMPRESS_BR) ? "br" : (enc & COMPRESS_GZ) ? "gzip" : "");
            }
+            http_add_header_field(&res->hdr, "ETag", buf1);
        }

-        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");
-        }
+        http_add_header_field(&res->hdr, "Cache-Control", mime_is_text(uri->meta->type) ? "public, max-age=3600" : "public, max-age=86400");

        const char *if_modified_since = http_get_header_field(&req->hdr, "If-Modified-Since");
        const char *if_none_match = http_get_header_field(&req->hdr, "If-None-Match");
-        if ((if_none_match != NULL && strstr(if_none_match, uri->meta->etag) == NULL) ||
-            (accept_if_modified_since && if_modified_since != NULL && strcmp(if_modified_since, last_modified) == 0))
+        if ((if_none_match != NULL && !strcontains(if_none_match, uri->meta->etag)) ||
+            (accept_if_modified_since && streq(if_modified_since, last_modified)))
        {
            res->status = http_get_status(304);
            return 0;
        }

-        const char *range = http_get_header_field(&req->hdr, "Range");
-        if (range != NULL) {
-            if (strlen(range) <= 6 || strncmp(range, "bytes=", 6) != 0) {
-                res->status = http_get_status(416);
+        if (http_get_header_field(&req->hdr, "Range") != NULL) {
+            if (range_handler(ctx) == 0) {
+                res->status = http_get_status(206);
+            } else {
+                if (ctx->file) {
+                    fclose(ctx->file);
+                    ctx->file = NULL;
+                }
                http_remove_header_field(&res->hdr, "Content-Type", HTTP_REMOVE_ALL);
                http_remove_header_field(&res->hdr, "Last-Modified", HTTP_REMOVE_ALL);
                http_remove_header_field(&res->hdr, "ETag", HTTP_REMOVE_ALL);
                http_remove_header_field(&res->hdr, "Cache-Control", HTTP_REMOVE_ALL);
-                return 0;
-            }
-            range += 6;
-            char *ptr = strchr(range, '-');
-            if (ptr == NULL) {
                res->status = http_get_status(416);
-                return 0;
            }
-            ctx->file = fopen(uri->filename, "rb");
-            fseek(ctx->file, 0, SEEK_END);
-            unsigned long file_len = ftell(ctx->file);
-            fseek(ctx->file, 0, SEEK_SET);
-            if (file_len == 0) {
-                ctx->content_length = 0;
-                return 0;
-            }
-            long num1 = 0;
-            long num2 = (long) file_len - 1;
-
-            if (ptr != range) num1 = (long) strtoul(range, NULL, 10);
-            if (ptr[1] != 0) num2 = (long) strtoul(ptr + 1, NULL, 10);
-
-            if (num1 >= file_len || num2 >= file_len || num1 > num2) {
-                res->status = http_get_status(416);
-                return 0;
-            }
-            sprintf(buf1, "bytes %li-%li/%li", num1, num2, file_len);
-            http_add_header_field(&res->hdr, "Content-Range", buf1);
-
-            res->status = http_get_status(206);
-            fseek(ctx->file, num1, SEEK_SET);
-            ctx->content_length = num2 - num1 + 1;
-
            return 0;
        }

-        if (ctx->file == NULL) {
-            ctx->file = fopen(uri->filename, "rb");
-        }
-
-        fseek(ctx->file, 0, SEEK_END);
-        ctx->content_length = ftell(ctx->file);
-        fseek(ctx->file, 0, SEEK_SET);
+        if (ctx->file == NULL) ctx->file = fopen(uri->filename, "rb");
+        ctx->content_length = fsize(ctx->file);
    } else {
        return 1;
    }
--- a/src/worker/proxy_handler.c
+++ b/src/worker/proxy_handler.c
@@ -14,13 +14,12 @@
 #include "../workers.h"

 #include <string.h>
-#include <errno.h>

 static int proxy_handler_1(client_ctx_t *ctx);
 static int proxy_handler_2(client_ctx_t *ctx);

 void proxy_handler_func(client_ctx_t *ctx) {
-    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);

    // TODO handle 1xx responses

@@ -29,12 +28,14 @@ void proxy_handler_func(client_ctx_t *ctx) {

    if (ret == 1) {
        proxy_unlock_ctx(ctx->proxy);
+        ctx->proxy->client = NULL;
        ctx->proxy = NULL;
    } else if (ctx->use_proxy == 0) {
        proxy_close(ctx->proxy);
    } else if (ctx->use_proxy == 1) {
        proxy_handler_2(ctx);
        proxy_unlock_ctx(ctx->proxy);
+        ctx->proxy->client = NULL;
        ctx->proxy = NULL;
    } else if (ctx->use_proxy == 2) {
        // WebSocket
@@ -63,12 +64,12 @@ static int proxy_handler_1(client_ctx_t *ctx) {
        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)
+            (strcontains(connection, "upgrade") || strcontains(connection, "Upgrade")) &&
+            streq(upgrade, "websocket"))
        {
            const char *ws_accept = http_get_header_field(&res->hdr, "Sec-WebSocket-Accept");
            if (ws_calc_accept_key(status->ws_key, buf) == 0) {
-                ctx->use_proxy = (strcmp(buf, ws_accept) == 0) ? 2 : 1;
+                ctx->use_proxy = streq(buf, ws_accept) ? 2 : 1;
            }
        } else {
            status->status = 101;
@@ -84,11 +85,11 @@ static int proxy_handler_1(client_ctx_t *ctx) {
        const char *content_encoding = http_get_header_field(&res->hdr, "Content-Encoding");
        if (content_encoding == NULL && (
                content_length_f == NULL ||
-                (content_length_f != NULL && strcmp(content_length_f, "0") == 0) ||
-                (content_type != NULL && content_length_f != NULL && strncmp(content_type, "text/html", 9) == 0)))
+                streq(content_length_f, "0") ||
+                (content_length_f != NULL && strstarts(content_type, "text/html"))))
        {
-            long content_len = (strcmp(ctx->req.method, "HEAD") != 0 && content_length_f != NULL) ? strtol(content_length_f, NULL, 10) : 0;
-            if (content_len <= sizeof(ctx->msg_content) - 1) {
+            long content_len = (!streq(ctx->req.method, "HEAD") && content_length_f != NULL) ? strtol(content_length_f, NULL, 10) : 0;
+            if (content_len < sizeof(ctx->msg_content)) {
                if (status->status != 101) {
                    status->status = res->status->code;
                    status->origin = res->status->code >= 400 ? SERVER : NONE;
@@ -103,7 +104,7 @@ static int proxy_handler_1(client_ctx_t *ctx) {
        }
    }

-    if (strcmp(ctx->req.method, "HEAD") == 0) {
+    if (streq(ctx->req.method, "HEAD")) {
        return 1;
    }

@@ -119,7 +120,7 @@ static int proxy_handler_1(client_ctx_t *ctx) {
    }

    char *transfer_encoding = http_get_header_field(&res->hdr, "Transfer-Encoding");
-    int chunked = transfer_encoding != NULL && strcmp(transfer_encoding, "chunked") == 0;
+    int chunked = transfer_encoding != NULL && streq(transfer_encoding, "chunked");
    http_remove_header_field(&res->hdr, "Transfer-Encoding", HTTP_REMOVE_ALL);
    ret = sprintf(buf, "%s%s%s",
                  (use_proxy & PROXY_COMPRESS_BR) ? "br" :
@@ -136,7 +137,7 @@ static int proxy_handler_1(client_ctx_t *ctx) {

 static int proxy_handler_2(client_ctx_t *ctx) {
    const char *transfer_encoding = http_get_header_field(&ctx->res.hdr, "Transfer-Encoding");
-    int chunked = transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL;
+    int chunked = strcontains(transfer_encoding, "chunked");

    const char *content_len = http_get_header_field(&ctx->res.hdr, "Content-Length");
    unsigned long len_to_send = 0;
@@ -153,18 +154,3 @@ static int proxy_handler_2(client_ctx_t *ctx) {

    return ret;
 }
-
-void proxy_close(proxy_ctx_t *ctx) {
-    client_ctx_t *cctx = ctx->client;
-    if (cctx) {
-        logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, cctx->req_host, CLR_STR, cctx->log_prefix);
-    } else {
-        logger_set_prefix("");
-    }
-
-    info(BLUE_STR "Closing proxy connection");
-    sock_close(&ctx->proxy);
-
-    memset(ctx, 0, sizeof(*ctx));
-    errno = 0;
-}
--- a/src/worker/request_handler.c
+++ b/src/worker/request_handler.c
@@ -23,7 +23,7 @@
 static int request_handler(client_ctx_t *ctx);

 void request_handler_func(client_ctx_t *ctx) {
-    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);

    switch (request_handler(ctx)) {
        case 0:
@@ -62,10 +62,8 @@ static void init_ctx(client_ctx_t *ctx) {
    memset(&ctx->req, 0, sizeof(ctx->req));
    memset(&ctx->res, 0, sizeof(ctx->res));

-
    ctx->res.status = http_get_status(501);
    http_init_hdr(&ctx->res.hdr);
-    ctx->res.hdr.last_field_num = -1;
    sprintf(ctx->res.version, "1.1");

    ctx->status.status = 0;
@@ -108,7 +106,7 @@ static int request_handler(client_ctx_t *ctx) {
    }

    const char *hdr_connection = http_get_header_field(&req->hdr, "Connection");
-    ctx->c_keep_alive = (hdr_connection != NULL && (strstr(hdr_connection, "keep-alive") != NULL || strstr(hdr_connection, "Keep-Alive") != NULL));
+    ctx->c_keep_alive = (strcontains(hdr_connection, "keep-alive") || strcontains(hdr_connection, "Keep-Alive"));
    const char *host_ptr = http_get_header_field(&req->hdr, "Host");
    if (host_ptr != NULL && strlen(host_ptr) > 255) {
        ctx->req_host[0] = 0;
@@ -128,11 +126,11 @@ static int request_handler(client_ctx_t *ctx) {
        strcpy(ctx->req_host, host_ptr);
    }

-    logger_set_prefix("[%s%*s%s]%s", BLD_STR, INET6_ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
    info(BLD_STR "%s %s", req->method, req->uri);

-    if (strncmp(req->uri, "/.sesimos/res/", 14) == 0) {
-        if (strcmp(req->method, "GET") != 0 && strcmp(req->method, "HEAD") != 0) {
+    if (strstarts(req->uri, "/.sesimos/res/")) {
+        if (!streq(req->method, "GET") && !streq(req->method, "HEAD")) {
            res->status = http_get_status(405);
            http_add_header_field(&res->hdr, "Allow", "GET, HEAD");
            return 0;
@@ -150,7 +148,7 @@ static int request_handler(client_ctx_t *ctx) {
        res->status = http_get_status(404);
        for (int i = 0; i < sizeof(resources) / sizeof(res_t); i++) {
            const res_t *r = &resources[i];
-            if (strcmp(req->uri + 14, r->name) == 0) {
+            if (streq(req->uri + 14, r->name)) {
                res->status = http_get_status(203);
                http_add_header_field(&res->hdr, "Content-Type", r->type);
                http_add_header_field(&res->hdr, "Cache-Control", "public, max-age=86400");
@@ -189,13 +187,13 @@ static int request_handler(client_ctx_t *ctx) {
        return 0;
    }

-    if (ctx->conf->type == CONFIG_TYPE_LOCAL && strcmp(req->method, "TRACE") == 0) {
+    if (ctx->conf->type == CONFIG_TYPE_LOCAL && streq(req->method, "TRACE")) {
        return 1;
    } else if (dir_mode != URI_DIR_MODE_NO_VALIDATION) {
        ssize_t size = sizeof(buf0);
        url_decode(req->uri, buf0, &size);
-        int change_proto = (!client->enc && strncmp(uri->uri, "/.well-known/", 13) != 0);
-        if (strcmp(uri->uri, buf0) != 0 || change_proto) {
+        int change_proto = (!client->enc && !strstarts(uri->uri, "/.well-known/"));
+        if (!streq(uri->uri, buf0) || change_proto) {
            res->status = http_get_status(308);
            size = url_encode(uri->uri, strlen(uri->uri), buf0, sizeof(buf0));
            if (change_proto) {
@@ -261,8 +259,8 @@ int respond(client_ctx_t *ctx) {
            http_add_header_field(&res->hdr, "Content-Type", "text/html; charset=UTF-8");

            // TODO list Locations on 3xx Redirects
-            const http_doc_info *http_info = http_get_status_info(res->status);
-            const http_status_msg *http_msg = http_get_error_msg(res->status);
+            const http_doc_info *http_info = http_get_status_info(res->status->code);
+            const http_status_msg *http_msg = http_get_error_msg(res->status->code);

            if (ctx->msg_content[0] == 0) {
                if (res->status->code >= 300 && res->status->code < 400) {
@@ -271,7 +269,7 @@ int respond(client_ctx_t *ctx) {
                        snprintf(ctx->msg_content, sizeof(ctx->msg_content), "      <ul>\n        <li><a href=\"%s\">%s</a></li>\n      </ul>\n", location, location);
                    }
                }
-            } else if (strncmp(ctx->msg_content, "<!DOCTYPE html>", 15) == 0 || strncmp(ctx->msg_content, "<html", 5) == 0) {
+            } else if (strstarts(ctx->msg_content, "<!DOCTYPE html>") || strstarts(ctx->msg_content, "<html")) {
                ctx->msg_content[0] = 0;
                // TODO let relevant information pass?
            }
@@ -302,10 +300,10 @@ int respond(client_ctx_t *ctx) {
            ctx->msg_buf_ptr = malloc(4096);
            ctx->msg_buf = ctx->msg_buf_ptr;
            snprintf(msg_pre_buf_1, sizeof(msg_pre_buf_1), http_info->doc,
-                     res->status->code, res->status->msg, http_msg != NULL ? http_msg->msg : "", err_msg[0] != 0 ? err_msg : "");
-            ctx->content_length = snprintf(ctx->msg_buf, 4096, http_default_doc, res->status->code,
-                                           res->status->msg, msg_pre_buf_1, http_info->mode, http_info->icon, http_info->color, ctx->req_host,
-                                           proxy_doc, ctx->msg_content[0] != 0 ? ctx->msg_content : "", SERVER_STR_HTML);
+                     res->status->code, res->status->msg, http_msg != NULL ? http_msg->msg : "", err_msg);
+            ctx->content_length = snprintf(ctx->msg_buf, 4096, http_default_doc, res->status->code, res->status->msg,
+                                           msg_pre_buf_1, http_info->mode, http_info->icon, http_info->color,
+                                           ctx->req_host, proxy_doc, ctx->msg_content, SERVER_STR_HTML);
        }
        if (ctx->content_length >= 0) {
            sprintf(buf0, "%li", ctx->content_length);
@@ -331,7 +329,7 @@ int respond(client_ctx_t *ctx) {
    http_send_response(client, res);
    ctx->res_ts = clock_micros();
    const char *location = http_get_header_field(&res->hdr, "Location");
-    info("%s%s%03i %s%s%s (%s)%s", http_get_status_color(res->status), ctx->use_proxy ? "-> " : "", res->status->code,
+    info("%s%s%03i %s%s%s (%s)%s", http_get_status_color(res->status->code), ctx->use_proxy ? "-> " : "", res->status->code,
         res->status->msg, location != NULL ? " -> " : "", location != NULL ? location : "",
         format_duration(ctx->res_ts - ctx->req_s, buf0), CLR_STR);

@@ -340,7 +338,7 @@ int respond(client_ctx_t *ctx) {
    if (ctx->use_proxy) {
        // reverse proxy
        return 3;
-    } else if (strcmp(req->method, "HEAD") != 0) {
+    } else if (!streq(req->method, "HEAD")) {
        // default response
        if (ctx->msg_buf != NULL) {
            ret = sock_send(client, ctx->msg_buf, ctx->content_length, 0);
@@ -386,7 +384,7 @@ void request_complete(client_ctx_t *ctx) {

 void timeout_request(client_ctx_t *ctx) {
    init_ctx(ctx);
-    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);

    ctx->s_keep_alive = 0;
    ctx->res.status = http_get_status(408);
--- a/src/worker/tcp_acceptor.c
+++ b/src/worker/tcp_acceptor.c
@@ -32,8 +32,10 @@ void tcp_acceptor_func(client_ctx_t *ctx) {
 static int tcp_acceptor(client_ctx_t *ctx) {
    struct sockaddr_in6 server_addr;

+    memset(ctx->_c_addr, 0, sizeof(ctx->_c_addr));
+    memset(ctx->_s_addr, 0, sizeof(ctx->_s_addr));
    inet_ntop(ctx->socket._addr.ipv6.sin6_family, &ctx->socket._addr.ipv6.sin6_addr, ctx->_c_addr, sizeof(ctx->_c_addr));
-    if (strncmp(ctx->_c_addr, "::ffff:", 7) == 0) {
+    if (strstarts(ctx->_c_addr, "::ffff:")) {
        ctx->socket.addr = ctx->_c_addr + 7;
    } else {
        ctx->socket.addr = ctx->_c_addr;
@@ -42,17 +44,17 @@ static int tcp_acceptor(client_ctx_t *ctx) {
    socklen_t len = sizeof(server_addr);
    getsockname(ctx->socket.socket, (struct sockaddr *) &server_addr, &len);
    inet_ntop(server_addr.sin6_family, (void *) &server_addr.sin6_addr, ctx->_s_addr, sizeof(ctx->_s_addr));
-    if (strncmp(ctx->_s_addr, "::ffff:", 7) == 0) {
+    if (strstarts(ctx->_s_addr, "::ffff:")) {
        ctx->socket.s_addr = ctx->_s_addr + 7;
    } else {
        ctx->socket.s_addr = ctx->_s_addr;
    }

    sprintf(ctx->log_prefix, "[%s%4i%s]%s[%*s][%5i]%s", (int) ctx->socket.enc ? HTTPS_STR : HTTP_STR,
-            ntohs(server_addr.sin6_port), CLR_STR, /*color_table[0]*/ "", INET6_ADDRSTRLEN, ctx->socket.addr,
+            ntohs(server_addr.sin6_port), CLR_STR, /*color_table[0]*/ "", ADDRSTRLEN, ctx->socket.addr,
            ntohs(ctx->socket._addr.ipv6.sin6_port), CLR_STR);

-    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);

    int ret;
    char buf[1024];
@@ -103,7 +105,7 @@ static int tcp_acceptor(client_ctx_t *ctx) {

        ret = SSL_accept(client->ssl);
        if (ret != 1) {
-            error_ssl(SSL_get_error(client->ssl, ret));
+            sock_error(client, ret);
            info("Unable to perform handshake");
            return -1;
        }
@@ -118,7 +120,8 @@ static int tcp_acceptor(client_ctx_t *ctx) {
 }

 void tcp_close(client_ctx_t *ctx) {
-    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
+    errno = 0;
+    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);

    sock_close(&ctx->socket);

--- a/src/worker/ws_frame_handler.c
+++ b/src/worker/ws_frame_handler.c
@@ -16,7 +16,7 @@
 static int ws_frame_handler(ws_ctx_t *ctx);

 void ws_frame_handler_func(ws_ctx_t *ctx) {
-    logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
+    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);

    if (ws_frame_handler(ctx) == 0) {
        if (ctx->client->ws_close == 3) {
@@ -84,7 +84,7 @@ void ws_close(ws_ctx_t *ctx) {
    ws_ctx_t *other = ctx->other;
    if (other) {
        other->other = NULL;
-        logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
+        logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
        info("Closing WebSocket connection");
        proxy_close(ctx->client->proxy);
        tcp_close(ctx->client);
Author	SHA1	Message	Date
Lorenz Stechauner	5acab8144d	Rework error interface	2023-01-12 12:54:23 +01:00
Lorenz Stechauner	4814035b62	Fix echo Makefile bug	2023-01-12 11:47:48 +01:00
Lorenz Stechauner	15f400f376	Add status_code_t in http.h	2023-01-12 10:22:27 +01:00
Lorenz Stechauner	32638fdd91	Fix list_remove()	2023-01-12 10:21:57 +01:00
Lorenz Stechauner	07d6280864	Fix list pointer bug in proxy	2023-01-12 01:58:14 +01:00
Lorenz Stechauner	820ce8dac9	Update logger_prefix	2023-01-12 00:34:04 +01:00
Lorenz Stechauner	5bd9b3fb33	Hopeful fix	2023-01-11 23:53:43 +01:00
Lorenz Stechauner	a3dcddf69d	Add lock for clients list	2023-01-11 18:06:55 +01:00
Lorenz Stechauner	487386158d	Remove most memory leaks with valgrind	2023-01-11 17:50:11 +01:00
Lorenz Stechauner	32f00175e4	Add lock to cache_handler	2023-01-11 15:55:39 +01:00
Lorenz Stechauner	581b4dc5aa	Fix flines()	2023-01-11 15:07:01 +01:00
Lorenz Stechauner	611ceabfb2	Small fixes in tcp_acceptor	2023-01-11 14:49:06 +01:00
Lorenz Stechauner	6b295cef95	Add Accept-Ranges lines	2023-01-11 14:30:12 +01:00
Lorenz Stechauner	764b754a6f	Add more utils	2023-01-11 11:06:36 +01:00
Lorenz Stechauner	7699583c5f	List/FastCGI cleanup	2023-01-11 00:34:17 +01:00
Lorenz Stechauner	8b92d4ff91	Remove color_table	2023-01-10 23:54:47 +01:00
Lorenz Stechauner	e8d8abdc5a	Add -C --clean	2023-01-10 23:52:29 +01:00
Lorenz Stechauner	15c6b7ddaa	Create .sesimos/ in cache_init	2023-01-09 22:53:42 +01:00
Lorenz Stechauner	e9a065f8aa	Add -pthread to Makefile	2023-01-09 22:47:50 +01:00
Lorenz Stechauner	0730429041	Fix error.c	2023-01-09 22:45:37 +01:00