Implement * notation for hosts

Makefile

@@ -1,9 +1,9 @@
 
-CFLAGS=-std=c11 -Wall
-INCLUDE=-lssl -lcrypto -lmagic -lz -lmaxminddb -lbrotlienc
-LIBS=src/lib/*.c
+CC=gcc
+CFLAGS=-std=gnu11 -Wall
+LIBS=-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.3-fpm.sock\""
+DEBIAN_OPTS=-D CACHE_MAGIC_FILE="\"/usr/share/file/magic.mgc\"" -D PHP_FPM_SOCKET="\"/var/run/php/php7.4-fpm.sock\""
 
 packages:
 	@echo "Installing packages..."
@@ -15,14 +15,12 @@ permit:
 
 compile:
 	@mkdir -p bin
-	gcc $(LIBS) -o bin/libnecronda-server.so --shared -fPIC $(CFLAGS) $(INCLUDE)
-	gcc src/necronda-server.c -o bin/necronda-server $(CFLAGS) $(INCLUDE) \
-		-Lbin -lnecronda-server -Wl,-rpath=$(shell pwd)/bin
+	$(CC) src/lib/*.c -o bin/libnecrondaserver.so --shared -fPIC $(CFLAGS) $(LIBS)
+	$(CC) src/necronda-server.c -o bin/necronda-server $(CFLAGS) $(LIBS) \
+		-Lbin -lnecrondaserver -Wl,-rpath=$(shell pwd)/bin
 
-compile-debian:
+compile-prod:
 	@mkdir -p bin
-	gcc $(LIBS) -o bin/libnecronda-server.so --shared -fPIC $(CFLAGS) $(INCLUDE) \
-		$(DEBIAN_OPTS) -O3
-	gcc src/necronda-server.c -o bin/necronda-server $(CFLAGS) $(INCLUDE) \
-		-Lbin -lnecronda-server -Wl,-rpath=$(shell pwd)/bin \
-		$(DEBIAN_OPTS) -O3
+	$(CC) src/lib/*.c -o bin/libnecrondaserver.so --shared -fPIC $(CFLAGS) $(LIBS) $(DEBIAN_OPTS) -O3
+	$(CC) src/necronda-server.c -o bin/necronda-server $(CFLAGS) $(LIBS) $(DEBIAN_OPTS) -O3 \
+		-Lbin -lnecrondaserver -Wl,-rpath=$(shell pwd)/bin

README.md

@@ -5,6 +5,7 @@ Necronda web server
 ## Features
 
 * Full IPv4 and IPv6 support
+* TLS Server Name Inspection (SNI)
 * Serving local files via HTTP and HTTPS
   * File compression ([gzip](https://www.gzip.org/), [Brotli](https://www.brotli.org/)) and disk cache for compressed files
 * Reverse proxy for other HTTP and HTTPS servers
@@ -22,23 +23,25 @@ See [docs/example.conf](docs/example.conf) for more details.
 
 ### Global directives
 
-* `certificate` - path to SSL certificate (or certificate chain)
-* `private_key` - path to SSL private key
 * `geoip_dir` (optional) - path to a directory containing GeoIP databases
 * `dns_server` (optional) - address of a DNS server
 
 
-### Virtual host configuration
+### Configuration
 
-* `[<host>]` - begins section for the virtual host `<host>`
-* Local
-    * `webroot` - path to the root directory
-    * `dir_mode` - specify the behaviour for directories without an `index.html` or `index.php`
-        * `forbidden` - the server will respond with `403 Forbidden`
-        * `info` - try passing *path info* to an upper `.php` file.
-        * `list` - list contents of directory (**not implemented yet**)
-* Reverse proxy
-    * `hostname` - hostname of server to be reverse proxy of
-    * `port` - port to be used
-    * `http` - use HTTP to communicate with server
-    * `https` - use HTTPS to communicate with server
+* `[cert <cert-name]` - begins section for a certificate
+  * `certificate` - path to SSL certificate (or certificate chain)
+  * `private_key` - path to SSL private key
+* `[host <host>]` - begins section for the virtual host `<host>`
+  * `cert` - the name of the certificate to use
+  * Local
+      * `webroot` - path to the root directory
+      * `dir_mode` - specify the behaviour for directories without an `index.html` or `index.php`
+          * `forbidden` - the server will respond with `403 Forbidden`
+          * `info` - try passing *path info* to an upper `.php` file.
+          * `list` - list contents of directory (**not implemented yet**)
+  * Reverse proxy
+      * `hostname` - hostname of server to be reverse proxy of
+      * `port` - port to be used
+      * `http` - use HTTP to communicate with server
+      * `https` - use HTTPS to communicate with server

src/client.c

@@ -34,9 +34,13 @@ struct timeval client_timeout;
 
 host_config *get_host_config(const char *host) {
     for (int i = 0; i < CONFIG_MAX_HOST_CONFIG; i++) {
-        host_config *hc = &config[i];
+        host_config *hc = &config->hosts[i];
         if (hc->type == CONFIG_TYPE_UNSET) break;
         if (strcmp(hc->name, host) == 0) return hc;
+        if (hc->name[0] == '*' && hc->name[1] == '.') {
+            const char *pos = strstr(host, hc->name + 1);
+            if (pos != NULL && strlen(pos) == strlen(hc->name + 1)) return hc;
+        }
     }
     return NULL;
 }
@@ -54,26 +58,31 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
     struct timespec begin, end;
     long ret;
     int client_keep_alive;
+
     char buf0[1024], buf1[1024];
-    char msg_buf[4096], msg_pre_buf[4096], err_msg[256];
+    char msg_buf[8192], msg_pre_buf_1[4096], msg_pre_buf_2[4096], err_msg[256];
+    char msg_content[1024];
     char buffer[CHUNK_SIZE];
-    err_msg[0] = 0;
     char host[256], *host_ptr, *hdr_connection;
-    host_config *conf = NULL;
-    long content_length = 0;
-    FILE *file = NULL;
+
     msg_buf[0] = 0;
+    err_msg[0] = 0;
+    msg_content[0] = 0;
+
+    host_config *conf = NULL;
+    FILE *file = NULL;
+
+    long content_length = 0;
     int accept_if_modified_since = 0;
     int use_fastcgi = 0;
     int use_rev_proxy = 0;
     int p_len;
-    fastcgi_conn php_fpm = {.socket = 0, .req_id = 0};
+
+    fastcgi_conn fcgi_conn = {.socket = 0, .req_id = 0};
     http_status custom_status;
 
-    http_res res;
-    sprintf(res.version, "1.1");
-    res.status = http_get_status(501);
-    res.hdr.field_num = 0;
+    http_res res = {.version = "1.1", .status = http_get_status(501), .hdr.field_num = 0};
+    http_status_ctx ctx = {.status = 0, .origin = NONE};
 
     clock_gettime(CLOCK_MONOTONIC, &begin);
 
@@ -138,7 +147,7 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         strcpy(host, host_ptr);
     }
 
-    sprintf(log_req_prefix, "[%6i][%s%24s%s]%s ", getpid(), BLD_STR, host, CLR_STR, log_client_prefix);
+    sprintf(log_req_prefix, "[%6i][%s%*s%s]%s ", getpid(), BLD_STR, INET6_ADDRSTRLEN, host, CLR_STR, log_client_prefix);
     log_prefix = log_req_prefix;
     print(BLD_STR "%s %s" CLR_STR, req.method, req.uri);
 
@@ -372,41 +381,51 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
             content_length = ftell(file);
             fseek(file, 0, SEEK_SET);
         } else {
+            int mode;
+            if (strcmp(uri.filename + strlen(uri.filename) - 4, ".ncr") == 0) {
+                mode = FASTCGI_NECRONDA;
+            } else if (strcmp(uri.filename + strlen(uri.filename) - 4, ".php") == 0) {
+                mode = FASTCGI_PHP;
+            } else {
+                res.status = http_get_status(500);
+                print(ERR_STR "Invalid FastCGI extension: %s" CLR_STR, uri.filename);
+                goto respond;
+            }
+
             struct stat statbuf;
             stat(uri.filename, &statbuf);
             char *last_modified = http_format_date(statbuf.st_mtime, buf0, sizeof(buf0));
             http_add_header_field(&res.hdr, "Last-Modified", last_modified);
 
             res.status = http_get_status(200);
-            if (fastcgi_init(&php_fpm, client_num, req_num, client, &req, &uri) != 0) {
-                res.status = http_get_status(502);
-                sprintf(err_msg, "Unable to communicate with PHP-FPM.");
+            if (fastcgi_init(&fcgi_conn, mode, client_num, req_num, client, &req, &uri) != 0) {
+                res.status = http_get_status(503);
+                sprintf(err_msg, "Unable to communicate with FastCGI socket.");
                 goto respond;
             }
 
             char *client_content_length = http_get_header_field(&req.hdr, "Content-Length");
             if (client_content_length != NULL) {
                 unsigned long client_content_len = strtoul(client_content_length, NULL, 10);
-                ret = fastcgi_receive(&php_fpm, client, client_content_len);
+                ret = fastcgi_receive(&fcgi_conn, client, client_content_len);
                 if (ret != 0) {
                     if (ret < 0) {
                         goto abort;
                     } else {
-                        sprintf(err_msg, "Unable to communicate with PHP-FPM.");
+                        sprintf(err_msg, "Unable to communicate with FastCGI socket.");
                     }
                     res.status = http_get_status(502);
                     goto respond;
                 }
             }
-            fastcgi_close_stdin(&php_fpm);
+            fastcgi_close_stdin(&fcgi_conn);
 
-            ret = fastcgi_header(&php_fpm, &res, err_msg);
+            ret = fastcgi_header(&fcgi_conn, &res, err_msg);
             if (ret != 0) {
-                if (ret < 0) {
-                    goto abort;
-                }
+                if (ret < 0) goto abort;
                 goto respond;
             }
+
             char *status = http_get_header_field(&res.hdr, "Status");
             if (status != NULL) {
                 int status_code = (int) strtoul(status, NULL, 10);
@@ -424,9 +443,29 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
                 }
             }
 
-            content_length = -1;
+            const char *content_length_f = http_get_header_field(&res.hdr, "Content-Length");
+            content_length = (content_length_f == NULL) ? -1 : strtol(content_length_f, NULL, 10);
+
+            const char *content_type = http_get_header_field(&res.hdr, "Content-Type");
+            const char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
+            if (content_encoding == NULL &&
+                content_type != NULL &&
+                strncmp(content_type, "text/html", 9) == 0 &&
+                content_length != -1 &&
+                content_length <= sizeof(msg_content) - 1)
+            {
+                fastcgi_dump(&fcgi_conn, msg_content, sizeof(msg_content));
+                goto respond;
+            }
+
             use_fastcgi = 1;
 
+            if (content_length != -1 && content_length < 1024000) {
+                use_fastcgi |= FASTCGI_COMPRESS_HOLD;
+            }
+
+            content_length = -1;
+
             int http_comp = http_get_compression(&req, &res);
             if (http_comp & COMPRESS) {
                 if (http_comp & COMPRESS_BR) {
@@ -438,6 +477,7 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
                 }
                 http_add_header_field(&res.hdr, "Vary", "Accept-Encoding");
                 http_add_header_field(&res.hdr, "Content-Encoding", buf0);
+                http_remove_header_field(&res.hdr, "Content-Length", HTTP_REMOVE_ALL);
             }
 
             if (http_get_header_field(&res.hdr, "Content-Length") == NULL) {
@@ -449,9 +489,27 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         http_remove_header_field(&res.hdr, "Date", HTTP_REMOVE_ALL);
         http_remove_header_field(&res.hdr, "Server", HTTP_REMOVE_ALL);
 
-        ret = rev_proxy_init(&req, &res, conf, client, &custom_status, err_msg);
+        ret = rev_proxy_init(&req, &res, &ctx, conf, client, &custom_status, err_msg);
         use_rev_proxy = (ret == 0);
 
+        // Let 300 be formatted by origin server
+        if (use_rev_proxy && res.status->code >= 301 && res.status->code < 600) {
+            const char *content_type = http_get_header_field(&res.hdr, "Content-Type");
+            const char *content_length_f = http_get_header_field(&res.hdr, "Content-Length");
+            const char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
+            if (content_encoding == NULL && content_type != NULL && content_length_f != NULL &&
+                strncmp(content_type, "text/html", 9) == 0)
+            {
+                long content_len = strtol(content_length_f, NULL, 10);
+                if (content_len <= sizeof(msg_content) - 1) {
+                    ctx.status = res.status->code;
+                    ctx.origin = res.status->code >= 400 ? SERVER : NONE;
+                    use_rev_proxy = 0;
+                    rev_proxy_dump(msg_content, content_len);
+                }
+            }
+        }
+
         /*
         char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
         if (use_rev_proxy && content_encoding == NULL) {
@@ -488,25 +546,61 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
         if (http_get_header_field(&res.hdr, "Accept-Ranges") == NULL) {
             http_add_header_field(&res.hdr, "Accept-Ranges", "none");
         }
-        if (!use_fastcgi && !use_rev_proxy && file == NULL &&
-                ((res.status->code >= 400 && res.status->code < 600) || err_msg[0] != 0)) {
+        if (!use_fastcgi && file == NULL) {
             http_remove_header_field(&res.hdr, "Date", HTTP_REMOVE_ALL);
             http_remove_header_field(&res.hdr, "Server", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res.hdr, "Cache-Control", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res.hdr, "Content-Type", HTTP_REMOVE_ALL);
+            http_remove_header_field(&res.hdr, "Content-Encoding", HTTP_REMOVE_ALL);
             http_add_header_field(&res.hdr, "Date", http_get_date(buf0, sizeof(buf0)));
             http_add_header_field(&res.hdr, "Server", SERVER_STR);
+            http_add_header_field(&res.hdr, "Cache-Control", "no-cache");
+            http_add_header_field(&res.hdr, "Content-Type", "text/html; charset=UTF-8");
 
             // TODO list Locations on 3xx Redirects
             const http_doc_info *info = http_get_status_info(res.status);
             const http_status_msg *http_msg = http_get_error_msg(res.status);
 
-            sprintf(msg_pre_buf, info->doc, res.status->code, res.status->msg,
+            if (res.status->code >= 300 && res.status->code < 400 && msg_content[0] == 0) {
+                const char *location = http_get_header_field(&res.hdr, "Location");
+                if (location != NULL) {
+                    snprintf(msg_content, sizeof(msg_content),
+                             "<ul>\n\t<li><a href=\"%1$s\">%1$s</a></li>\n</ul>\n", location);
+                }
+            }
+
+            char *rev_proxy_doc = "";
+            if (conf != NULL && conf->type == CONFIG_TYPE_REVERSE_PROXY) {
+                const http_status *status = http_get_status(ctx.status);
+                char stat_str[8];
+                sprintf(stat_str, "%03i", ctx.status);
+                sprintf(msg_pre_buf_2, http_rev_proxy_document,
+                        " success",
+                        (ctx.origin == CLIENT_REQ) ? " error" : " success",
+                        (ctx.origin == INTERNAL) ? " error" : " success",
+                        (ctx.origin == SERVER_REQ) ? " error" : (ctx.status == 0 ? "" : " success"),
+                        (ctx.origin == CLIENT_RES) ? " error" : " success",
+                        (ctx.origin == SERVER) ? " error" : (ctx.status == 0 ? "" : " success"),
+                        (ctx.origin == SERVER_RES) ? " error" : (ctx.status == 0 ? "" : " success"),
+                        (ctx.origin == INTERNAL) ? " error" : " success",
+                        (ctx.origin == INTERNAL || ctx.origin == SERVER) ? " error" : " success",
+                        res.status->code,
+                        res.status->msg,
+                        (ctx.status == 0) ? "???" : stat_str,
+                        (status != NULL) ? status->msg : "",
+                        host);
+                rev_proxy_doc = msg_pre_buf_2;
+            }
+
+            sprintf(msg_pre_buf_1, info->doc, res.status->code, res.status->msg,
                     http_msg != NULL ? http_msg->msg : "", err_msg[0] != 0 ? err_msg : "");
             content_length = snprintf(msg_buf, sizeof(msg_buf), http_default_document, res.status->code,
-                                      res.status->msg, msg_pre_buf, info->mode, info->icon, info->color, host);
-            http_add_header_field(&res.hdr, "Content-Type", "text/html; charset=UTF-8");
+                                      res.status->msg, msg_pre_buf_1, info->mode, info->icon, info->color, host,
+                                      rev_proxy_doc, msg_content[0] != 0 ? msg_content : "");
         }
         if (content_length >= 0) {
             sprintf(buf0, "%li", content_length);
+            http_remove_header_field(&res.hdr, "Content-Length", HTTP_REMOVE_ALL);
             http_add_header_field(&res.hdr, "Content-Length", buf0);
         } else if (http_get_header_field(&res.hdr, "Transfer-Encoding") == NULL) {
             server_keep_alive = 0;
@@ -561,8 +655,8 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
             char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
             int chunked = transfer_encoding != NULL && strcmp(transfer_encoding, "chunked") == 0;
 
-            int flags = (chunked ? FASTCGI_CHUNKED : 0) | (use_fastcgi & FASTCGI_COMPRESS);
-            fastcgi_send(&php_fpm, client, flags);
+            int flags = (chunked ? FASTCGI_CHUNKED : 0) | (use_fastcgi & (FASTCGI_COMPRESS | FASTCGI_COMPRESS_HOLD));
+            ret = fastcgi_send(&fcgi_conn, client, flags);
         } else if (use_rev_proxy) {
             char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
             int chunked = transfer_encoding != NULL && strstr(transfer_encoding, "chunked") != NULL;
@@ -574,7 +668,11 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
             }
 
             int flags = (chunked ? REV_PROXY_CHUNKED : 0) | (use_rev_proxy & REV_PROXY_COMPRESS);
-            rev_proxy_send(client, len_to_send, flags);
+            ret = rev_proxy_send(client, len_to_send, flags);
+        }
+
+        if (ret < 0) {
+            client_keep_alive = 0;
         }
     }
 
@@ -589,10 +687,10 @@ int client_request_handler(sock *client, unsigned long client_num, unsigned int
 
     uri_free(&uri);
     abort:
-    if (php_fpm.socket != 0) {
-        shutdown(php_fpm.socket, SHUT_RDWR);
-        close(php_fpm.socket);
-        php_fpm.socket = 0;
+    if (fcgi_conn.socket != 0) {
+        shutdown(fcgi_conn.socket, SHUT_RDWR);
+        close(fcgi_conn.socket);
+        fcgi_conn.socket = 0;
     }
     http_free_req(&req);
     http_free_res(&res);
@@ -682,7 +780,7 @@ int client_connection_handler(sock *client, unsigned long client_num) {
         if (pos != NULL) {
             pos = strstr(pos, "\"iso_code\":");
             pos += 12;
-            strncpy(client_cc, pos, 2);
+            snprintf(client_cc, sizeof(client_cc), "%s", pos);
         }
     }
 
@@ -770,11 +868,11 @@ int client_handler(sock *client, unsigned long client_num, struct sockaddr_in6 *
     log_req_prefix = malloc(256);
     log_client_prefix = malloc(256);
     sprintf(log_client_prefix, "[%s%4i%s]%s[%*s][%5i]%s", (int) client->enc ? HTTPS_STR : HTTP_STR,
-            ntohs(server_addr->sin6_port), CLR_STR, color_table[client_num % 6], INET_ADDRSTRLEN, client_addr_str,
+            ntohs(server_addr->sin6_port), CLR_STR, color_table[client_num % 6], INET6_ADDRSTRLEN, client_addr_str,
             ntohs(client_addr->sin6_port), CLR_STR);
 
     log_conn_prefix = malloc(256);
-    sprintf(log_conn_prefix, "[%6i][%24s]%s ", getpid(), server_addr_str, log_client_prefix);
+    sprintf(log_conn_prefix, "[%6i][%*s]%s ", getpid(), INET6_ADDRSTRLEN, server_addr_str, log_client_prefix);
     log_prefix = log_conn_prefix;
 
     print("Started child process with PID %i", getpid());

src/lib/cache.c

@@ -57,14 +57,17 @@ int cache_process() {
     }
     cache = shm_rw;
 
-    if (mkdir("/var/necronda-server/", 0755) < 0) {
-        if (errno != EEXIST) {
-            fprintf(stderr, ERR_STR "Unable to create directory '/var/necronda-server/': %s" CLR_STR "\n", strerror(errno));
-            return -3;
-        }
+    if (mkdir("/var/necronda/", 0755) < 0 && errno != EEXIST) {
+        fprintf(stderr, ERR_STR "Unable to create directory '/var/necronda/': %s" CLR_STR "\n", strerror(errno));
+        return -3;
     }
 
-    FILE *cache_file = fopen("/var/necronda-server/cache", "rb");
+    if (mkdir("/var/necronda/server/", 0755) < 0 && errno != EEXIST) {
+        fprintf(stderr, ERR_STR "Unable to create directory '/var/necronda/server/': %s" CLR_STR "\n", strerror(errno));
+        return -3;
+    }
+
+    FILE *cache_file = fopen("/var/necronda/server/cache", "rb");
     if (cache_file != NULL) {
         fread(cache, sizeof(cache_entry), CACHE_ENTRIES, cache_file);
         fclose(cache_file);
@@ -100,15 +103,21 @@ int cache_process() {
                 FILE *comp_file_br = NULL;
                 if (compress) {
                     sprintf(buf, "%.*s/.necronda-server", cache[i].webroot_len, cache[i].filename);
-                    mkdir(buf, 0755);
+                    if (mkdir(buf, 0755) != 0 && errno != EEXIST) {
+                        fprintf(stderr, ERR_STR "Unable to create directory %s: %s" CLR_STR "\n", buf, strerror(errno));
+                        goto comp_err;
+                    }
+
                     sprintf(buf, "%.*s/.necronda-server/cache", cache[i].webroot_len, cache[i].filename);
-                    mkdir(buf, 0700);
+                    if (mkdir(buf, 0700) != 0 && errno != EEXIST) {
+                        fprintf(stderr, ERR_STR "Unable to create directory %s: %s" CLR_STR "\n", buf, strerror(errno));
+                        goto comp_err;
+                    }
+
                     char *rel_path = cache[i].filename + cache[i].webroot_len + 1;
                     for (int j = 0; j < strlen(rel_path); j++) {
                         char ch = rel_path[j];
-                        if (ch == '/') {
-                            ch = '_';
-                        }
+                        if (ch == '/') ch = '_';
                         buf[j] = ch;
                     }
                     buf[strlen(rel_path)] = 0;
@@ -120,7 +129,8 @@ int cache_process() {
                                         "%.*s/.necronda-server/cache/%s.br",
                                         cache[i].webroot_len, cache[i].filename, buf);
                     if (p_len_gz < 0 || p_len_gz >= sizeof(filename_comp_gz) ||
-                            p_len_br < 0 || p_len_br >= sizeof(filename_comp_br)) {
+                        p_len_br < 0 || p_len_br >= sizeof(filename_comp_br))
+                    {
                         fprintf(stderr, ERR_STR "Unable to open cached file: "
                                                 "File name for compressed file too long" CLR_STR "\n");
                         goto comp_err;
@@ -191,7 +201,7 @@ int cache_process() {
 
         if (cache_changed) {
             cache_changed = 0;
-            cache_file = fopen("/var/necronda-server/cache", "wb");
+            cache_file = fopen("/var/necronda/server/cache", "wb");
             if (cache_file == NULL) {
                 fprintf(stderr, ERR_STR "Unable to open cache file: %s" CLR_STR "\n", strerror(errno));
                 free(buf);

src/lib/cache.h

@@ -18,10 +18,6 @@
 #   define CACHE_MAGIC_FILE "/usr/share/file/misc/magic.mgc"
 #endif
 
-#ifndef DEFAULT_CONFIG_FILE
-#   define DEFAULT_CONFIG_FILE "/etc/necronda-server/necronda-server.conf"
-#endif
-
 
 typedef struct {
     char filename[256];

src/lib/config.c

@@ -14,11 +14,11 @@
 #include <errno.h>
 #include <stdlib.h>
 
-host_config *config;
-char cert_file[256], key_file[256], geoip_dir[256], dns_server[256];
+t_config *config;
+char geoip_dir[256], dns_server[256];
 
 int config_init() {
-    int shm_id = shmget(CONFIG_SHM_KEY, CONFIG_MAX_HOST_CONFIG * sizeof(host_config), IPC_CREAT | IPC_EXCL | 0640);
+    int shm_id = shmget(CONFIG_SHM_KEY, sizeof(t_config), IPC_CREAT | IPC_EXCL | 0640);
     if (shm_id < 0) {
         fprintf(stderr, ERR_STR "Unable to create shared memory: %s" CLR_STR "\n", strerror(errno));
         return -1;
@@ -37,7 +37,7 @@ int config_init() {
         return -3;
     }
     config = shm_rw;
-    memset(config, 0, CONFIG_MAX_HOST_CONFIG * sizeof(host_config));
+    memset(config, 0, sizeof(t_config));
     shmdt(shm_rw);
     config = shm;
     return 0;
@@ -68,42 +68,82 @@ int config_load(const char *filename) {
     fseek(file, 0, SEEK_END);
     unsigned long len = ftell(file);
     fseek(file, 0, SEEK_SET);
-    char *conf = malloc(len);
+    char *conf = alloca(len + 1);
     fread(conf, 1, len, file);
+    conf[len] = 0;
     fclose(file);
 
-    host_config *tmp_config = malloc(CONFIG_MAX_HOST_CONFIG * sizeof(host_config));
-    memset(tmp_config, 0, CONFIG_MAX_HOST_CONFIG * sizeof(host_config));
+    t_config *tmp_config = malloc(sizeof(t_config));
+    memset(tmp_config, 0, sizeof(t_config));
 
     int i = 0;
+    int j = 0;
+    int line = 0;
     int mode = 0;
+    char section = 0;
     char *ptr = NULL;
     char *source, *target;
-    while ((ptr = strtok(ptr == NULL ? conf :  NULL, "\n")) != NULL) {
+    while ((ptr = strsep(&conf, "\r\n")) != NULL) {
+        line++;
         char *comment = strchr(ptr, '#');
         if (comment != NULL) comment[0] = 0;
+
         len = strlen(ptr);
+        char *end_ptr = ptr + len - 1;
+        while (end_ptr[0] == ' ' || end_ptr[0] == '\t') {
+            end_ptr[0] = 0;
+            end_ptr--;
+        }
+        len = strlen(ptr);
+        if (len == 0) continue;
+
         if (ptr[0] == '[') {
             if (ptr[len - 1] != ']') goto err;
-            strncpy(tmp_config[i].name, ptr + 1, len - 2);
-            i++;
+            ptr++;
+            int l = 0;
+            if (strncmp(ptr, "host", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
+                ptr += 4;
+                while (ptr[0] == ' ' || ptr[0] == '\t' || ptr[0] == ']') ptr++;
+                while (ptr[l] != ' ' && ptr[l] != '\t' && ptr[l] != ']') l++;
+                if (l == 0) goto err;
+                snprintf(tmp_config->hosts[i].name, sizeof(tmp_config->hosts[i].name), "%.*s", l, ptr);
+                i++;
+                section = 'h';
+            } else if (strncmp(ptr, "cert", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
+                ptr += 4;
+                while (ptr[0] == ' ' || ptr[0] == '\t' || ptr[0] == ']') ptr++;
+                while (ptr[l] != ' ' && ptr[l] != '\t' && ptr[l] != ']') l++;
+                if (l == 0) goto err;
+                snprintf(tmp_config->certs[j].name, sizeof(tmp_config->certs[j].name), "%.*s", l, ptr);
+                j++;
+                section = 'c';
+            } else {
+                goto err;
+            }
             continue;
-        } else if (i == 0) {
-            if (len > 12 && strncmp(ptr, "certificate", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
-                source = ptr + 11;
-                target = cert_file;
-            } else if (len > 12 && strncmp(ptr, "private_key", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
-                source = ptr + 11;
-                target = key_file;
-            } else if (len > 10 && strncmp(ptr, "geoip_dir", 9) == 0 && (ptr[9] == ' ' || ptr[9] == '\t')) {
+        } else if (section == 0) {
+            if (len > 10 && strncmp(ptr, "geoip_dir", 9) == 0 && (ptr[9] == ' ' || ptr[9] == '\t')) {
                 source = ptr + 9;
                 target = geoip_dir;
             } else if (len > 11 && strncmp(ptr, "dns_server", 10) == 0 && (ptr[10] == ' ' || ptr[10] == '\t')) {
                 source = ptr + 10;
                 target = dns_server;
+            } else {
+                goto err;
             }
-        } else {
-            host_config *hc = &tmp_config[i - 1];
+        } else if (section == 'c') {
+            cert_config *cc = &tmp_config->certs[j - 1];
+            if (len > 12 && strncmp(ptr, "certificate", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
+                source = ptr + 11;
+                target = cc->full_chain;
+            } else if (len > 12 && strncmp(ptr, "private_key", 11) == 0 && (ptr[11] == ' ' || ptr[11] == '\t')) {
+                source = ptr + 11;
+                target = cc->priv_key;
+            } else {
+                goto err;
+            }
+        } else if (section == 'h') {
+            host_config *hc = &tmp_config->hosts[i - 1];
             if (len > 8 && strncmp(ptr, "webroot", 7) == 0 && (ptr[7] == ' ' || ptr[7] == '\t')) {
                 source = ptr + 7;
                 target = hc->local.webroot;
@@ -112,6 +152,9 @@ int config_load(const char *filename) {
                 } else {
                     hc->type = CONFIG_TYPE_LOCAL;
                 }
+            } else if (len > 5 && strncmp(ptr, "cert", 4) == 0 && (ptr[4] == ' ' || ptr[4] == '\t')) {
+                source = ptr + 4;
+                target = hc->cert_name;
             } else if (len > 9 && strncmp(ptr, "dir_mode", 8) == 0 && (ptr[8] == ' ' || ptr[8] == '\t')) {
                 source = ptr + 8;
                 target = NULL;
@@ -154,44 +197,61 @@ int config_load(const char *filename) {
                     hc->rev_proxy.enc = 1;
                 }
                 continue;
+            } else {
+                goto err;
             }
+        } else {
+            goto err;
         }
-        char *end_ptr = source + strlen(source) - 1;
+
         while (source[0] == ' ' || source[0] == '\t') source++;
-        while (end_ptr[0] == ' ' || end_ptr[0] == '\t') end_ptr--;
-        if (end_ptr <= source) {
+        if (strlen(source) == 0) {
             err:
-            free(conf);
             free(tmp_config);
-            fprintf(stderr, ERR_STR "Unable to parse config file" CLR_STR "\n");
+            fprintf(stderr, ERR_STR "Unable to parse config file (line %i)" CLR_STR "\n", line);
             return -2;
         }
-        end_ptr[1] = 0;
+
         if (target != NULL) {
             strcpy(target, source);
         } else if (mode == 1) {
             if (strcmp(source, "forbidden") == 0) {
-                tmp_config[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
+                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_FORBIDDEN;
             } else if (strcmp(source, "info") == 0) {
-                tmp_config[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
+                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_INFO;
             } else if (strcmp(source, "list") == 0) {
-                tmp_config[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
+                tmp_config->hosts[i - 1].local.dir_mode = URI_DIR_MODE_LIST;
             } else {
                 goto err;
             }
         } else if (mode == 2) {
-            tmp_config[i - 1].rev_proxy.port = (unsigned short) strtoul(source, NULL, 10);
+            tmp_config->hosts[i - 1].rev_proxy.port = (unsigned short) strtoul(source, NULL, 10);
         }
     }
-    free(conf);
 
-    for (int j = 0; j < i; j++) {
-        if (tmp_config[j].type == CONFIG_TYPE_LOCAL) {
-            char *webroot = tmp_config[j].local.webroot;
+    for (int k = 0; k < i; k++) {
+        host_config *hc = &tmp_config->hosts[k];
+        if (hc->type == CONFIG_TYPE_LOCAL) {
+            char *webroot = tmp_config->hosts[k].local.webroot;
             if (webroot[strlen(webroot) - 1] == '/') {
                 webroot[strlen(webroot) - 1] = 0;
             }
         }
+        if (hc->cert_name[0] == 0) goto err2;
+        int found = 0;
+        for (int m = 0; m < j; m++) {
+            if (strcmp(tmp_config->certs[m].name, hc->cert_name) == 0) {
+                hc->cert = m;
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            err2:
+            free(tmp_config);
+            fprintf(stderr, ERR_STR "Unable to parse config file" CLR_STR "\n");
+            return -2;
+        }
     }
 
     int shm_id = shmget(CONFIG_SHM_KEY, 0, 0);
@@ -207,7 +267,7 @@ int config_load(const char *filename) {
         fprintf(stderr, ERR_STR "Unable to attach shared memory (rw): %s" CLR_STR "\n", strerror(errno));
         return -4;
     }
-    memcpy(shm_rw, tmp_config, CONFIG_MAX_HOST_CONFIG * sizeof(host_config));
+    memcpy(shm_rw, tmp_config, sizeof(t_config));
     free(tmp_config);
     shmdt(shm_rw);
     return 0;

src/lib/config.h

@@ -12,14 +12,22 @@
 
 #define CONFIG_SHM_KEY 255642
 #define CONFIG_MAX_HOST_CONFIG 64
+#define CONFIG_MAX_CERT_CONFIG 64
 
 #define CONFIG_TYPE_UNSET 0
 #define CONFIG_TYPE_LOCAL 1
 #define CONFIG_TYPE_REVERSE_PROXY 2
 
+#ifndef DEFAULT_CONFIG_FILE
+#   define DEFAULT_CONFIG_FILE "/etc/necronda/server.conf"
+#endif
+
+
 typedef struct {
     int type;
     char name[256];
+    char cert_name[256];
+    int cert;
     union {
         struct {
             char hostname[256];
@@ -33,8 +41,19 @@ typedef struct {
     };
 } host_config;
 
-extern host_config *config;
-extern char cert_file[256], key_file[256], geoip_dir[256], dns_server[256];
+typedef struct {
+    char name[256];
+    char full_chain[256];
+    char priv_key[256];
+} cert_config;
+
+typedef struct {
+    host_config hosts[CONFIG_MAX_HOST_CONFIG];
+    cert_config certs[CONFIG_MAX_CERT_CONFIG];
+} t_config;
+
+extern t_config *config;
+extern char geoip_dir[256], dns_server[256];
 
 int config_init();
 

src/lib/fastcgi.c

@@ -49,7 +49,7 @@ char *fastcgi_add_param(char *buf, const char *key, const char *value) {
     return ptr;
 }
 
-int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_num, const sock *client,
+int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client,
                  const http_req *req, const http_uri *uri) {
     unsigned short req_id = (client_num & 0xFFF) << 4;
     if (client_num == 0) {
@@ -57,20 +57,28 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     } else {
         req_id |= req_num & 0xF;
     }
+    conn->mode = mode;
     conn->req_id = req_id;
     conn->out_buf = NULL;
     conn->out_off = 0;
+    conn->webroot = uri->webroot;
 
-    int php_fpm = socket(AF_UNIX, SOCK_STREAM, 0);
-    if (php_fpm < 0) {
+    int fcgi_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fcgi_sock < 0) {
         print(ERR_STR "Unable to create unix socket: %s" CLR_STR, strerror(errno));
         return -1;
     }
-    conn->socket = php_fpm;
+    conn->socket = fcgi_sock;
 
-    struct sockaddr_un php_fpm_addr = {AF_UNIX, PHP_FPM_SOCKET};
-    if (connect(conn->socket, (struct sockaddr *) &php_fpm_addr, sizeof(php_fpm_addr)) < 0) {
-        print(ERR_STR "Unable to connect to unix socket of PHP-FPM: %s" CLR_STR, strerror(errno));
+    struct sockaddr_un sock_addr = {AF_UNIX};
+    if (conn->mode == FASTCGI_NECRONDA) {
+        snprintf(sock_addr.sun_path, sizeof(sock_addr.sun_path) - 1, "%s", NECRONDA_BACKEND_SOCKET);
+    } else if (conn->mode == FASTCGI_PHP) {
+        snprintf(sock_addr.sun_path, sizeof(sock_addr.sun_path) - 1, "%s", PHP_FPM_SOCKET);
+    }
+
+    if (connect(conn->socket, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0) {
+        print(ERR_STR "Unable to connect to unix socket of FastCGI socket: %s" CLR_STR, strerror(errno));
         return -1;
     }
 
@@ -90,7 +98,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
             {.roleB1 = (FCGI_RESPONDER >> 8) & 0xFF, .roleB0 = FCGI_RESPONDER & 0xFF, .flags = 0}
     };
     if (send(conn->socket, &begin, sizeof(begin), 0) != sizeof(begin)) {
-        print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
         return -2;
     }
 
@@ -173,7 +181,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     header.contentLengthB0 = param_len & 0xFF;
     memcpy(param_buf, &header, sizeof(header));
     if (send(conn->socket, param_buf, param_len + sizeof(header), 0) != param_len + sizeof(header)) {
-        print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
         return -2;
     }
 
@@ -181,7 +189,7 @@ int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_n
     header.contentLengthB1 = 0;
     header.contentLengthB0 = 0;
     if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) {
-        print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
         return -2;
     }
 
@@ -201,14 +209,14 @@ int fastcgi_close_stdin(fastcgi_conn *conn) {
     };
 
     if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) {
-        print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+        print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
         return -2;
     }
 
     return 0;
 }
 
-int fastcgi_php_error(const char *msg, int msg_len, char *err_msg) {
+int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, char *err_msg) {
     char *msg_str = malloc(msg_len + 1);
     char *ptr0 = msg_str;
     strncpy(msg_str, msg, msg_len);
@@ -253,9 +261,9 @@ int fastcgi_php_error(const char *msg, int msg_len, char *err_msg) {
             if (ptr3 != NULL && (ptr3 - ptr2) < len2) {
                 len2 = (int) (ptr3 - ptr2);
             }
-            print("%s%.*s%s", msg_type == 1 ? WRN_STR : msg_type == 2 ? ERR_STR : "", len2, ptr2, msg_type != 0 ? CLR_STR : "");
+            print("%s%.*s%s", msg_type == 1 ? WRN_STR : msg_type == 2 ? ERR_STR : "", len2, ptr2, CLR_STR);
             if (msg_type == 2 && ptr2 == ptr0) {
-                sprintf(err_msg, "%.*s", len2, ptr2);
+                strcpy_rem_webroot(err_msg, ptr2, len2, conn->webroot);
                 err = 1;
             }
             if (ptr3 == NULL) {
@@ -284,14 +292,14 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
     while (1) {
         ret = recv(conn->socket, &header, sizeof(header), 0);
         if (ret < 0) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM: %s" CLR_STR, strerror(errno));
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
             return 1;
         } else if (ret != sizeof(header)) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            print(ERR_STR "Unable to receive from FastCGI socket" CLR_STR);
             return 1;
         }
         req_id = (header.requestIdB1 << 8) | header.requestIdB0;
@@ -299,15 +307,15 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
         content = malloc(content_len + header.paddingLength);
         ret = recv(conn->socket, content, content_len + header.paddingLength, 0);
         if (ret < 0) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM: %s" CLR_STR, strerror(errno));
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
             free(content);
             return 1;
         } else if (ret != (content_len + header.paddingLength)) {
-            res->status = http_get_status(502);
-            sprintf(err_msg, "Unable to communicate with PHP-FPM.");
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
+            res->status = http_get_status(500);
+            sprintf(err_msg, "Unable to communicate with FastCGI socket.");
+            print(ERR_STR "Unable to receive from FastCGI socket" CLR_STR);
             free(content);
             return 1;
         }
@@ -324,14 +332,17 @@ int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg) {
                 print(ERR_STR "FastCGI protocol error: %i" CLR_STR, body->protocolStatus);
             }
             if (app_status != 0) {
-                print(ERR_STR "Script terminated with exit code %i" CLR_STR, app_status);
+                print(ERR_STR "FastCGI app terminated with exit code %i" CLR_STR, app_status);
             }
             close(conn->socket);
             conn->socket = 0;
             free(content);
             return 1;
         } else if (header.type == FCGI_STDERR) {
-            err = err || fastcgi_php_error(content, content_len, err_msg);
+            // TODO implement Necronda backend error handling
+            if (conn->mode == FASTCGI_PHP) {
+                err = err || fastcgi_php_error(conn, content, content_len, err_msg);
+            }
         } else if (header.type == FCGI_STDOUT) {
             break;
         } else {
@@ -417,10 +428,11 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
     while (1) {
         ret = recv(conn->socket, &header, sizeof(header), 0);
         if (ret < 0) {
-            print(ERR_STR "Unable to receive from PHP-FPM: %s" CLR_STR, strerror(errno));
+            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
             return -1;
         } else if (ret != sizeof(header)) {
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
+            print(ERR_STR "Unable to receive from FastCGI socket: received len (%li) != header len (%li)" CLR_STR,
+                  ret, sizeof(header));
             return -1;
         }
 
@@ -428,15 +440,16 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
         content_len = (header.contentLengthB1 << 8) | header.contentLengthB0;
         content = malloc(content_len + header.paddingLength);
         ptr = content;
-        ret = recv(conn->socket, content, content_len + header.paddingLength, 0);
-        if (ret < 0) {
-            print(ERR_STR "Unable to receive from PHP-FPM: %s" CLR_STR, strerror(errno));
-            free(content);
-            return -1;
-        } else if (ret != (content_len + header.paddingLength)) {
-            print(ERR_STR "Unable to receive from PHP-FPM" CLR_STR);
-            free(content);
-            return -1;
+
+        long rcv_len = 0;
+        while (rcv_len < content_len + header.paddingLength) {
+            ret = recv(conn->socket, content + rcv_len, content_len + header.paddingLength - rcv_len, 0);
+            if (ret < 0) {
+                print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+                free(content);
+                return -1;
+            }
+            rcv_len += ret;
         }
 
         if (header.type == FCGI_END_REQUEST) {
@@ -447,7 +460,7 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
                 print(ERR_STR "FastCGI protocol error: %i" CLR_STR, body->protocolStatus);
             }
             if (app_status != 0) {
-                print(ERR_STR "Script terminated with exit code %i" CLR_STR, app_status);
+                print(ERR_STR "FastCGI app terminated with exit code %i" CLR_STR, app_status);
             }
             close(conn->socket);
             conn->socket = 0;
@@ -467,7 +480,10 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
 
             return 0;
         } else if (header.type == FCGI_STDERR) {
-            fastcgi_php_error(content, content_len, buf0);
+            // TODO implement Necronda backend error handling
+            if (conn->mode == FASTCGI_PHP) {
+                fastcgi_php_error(conn, content, content_len, buf0);
+            }
         } else if (header.type == FCGI_STDOUT) {
             unsigned long avail_in, avail_out;
             out:
@@ -497,6 +513,72 @@ int fastcgi_send(fastcgi_conn *conn, sock *client, int flags) {
     }
 }
 
+int fastcgi_dump(fastcgi_conn *conn, char *buf, long len) {
+    FCGI_Header header;
+    long ret;
+    char buf0[256];
+    char *content, *ptr = buf;
+    unsigned short req_id, content_len;
+
+    if (conn->out_buf != NULL && conn->out_len > conn->out_off) {
+        ptr += snprintf(ptr, len, "%.*s", conn->out_len - conn->out_off, conn->out_buf + conn->out_off);
+    }
+
+    while (1) {
+        ret = recv(conn->socket, &header, sizeof(header), 0);
+        if (ret < 0) {
+            print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+            return -1;
+        } else if (ret != sizeof(header)) {
+            print(ERR_STR "Unable to receive from FastCGI socket: received len (%li) != header len (%li)" CLR_STR,
+                  ret, sizeof(header));
+            return -1;
+        }
+
+        req_id = (header.requestIdB1 << 8) | header.requestIdB0;
+        content_len = (header.contentLengthB1 << 8) | header.contentLengthB0;
+        content = malloc(content_len + header.paddingLength);
+
+        long rcv_len = 0;
+        while (rcv_len < content_len + header.paddingLength) {
+            ret = recv(conn->socket, content + rcv_len, content_len + header.paddingLength - rcv_len, 0);
+            if (ret < 0) {
+                print(ERR_STR "Unable to receive from FastCGI socket: %s" CLR_STR, strerror(errno));
+                free(content);
+                return -1;
+            }
+            rcv_len += ret;
+        }
+
+        if (header.type == FCGI_END_REQUEST) {
+            FCGI_EndRequestBody *body = (FCGI_EndRequestBody *) content;
+            int app_status = (body->appStatusB3 << 24) | (body->appStatusB2 << 16) | (body->appStatusB1 << 8) |
+                             body->appStatusB0;
+            if (body->protocolStatus != FCGI_REQUEST_COMPLETE) {
+                print(ERR_STR "FastCGI protocol error: %i" CLR_STR, body->protocolStatus);
+            }
+            if (app_status != 0) {
+                print(ERR_STR "FastCGI app terminated with exit code %i" CLR_STR, app_status);
+            }
+            close(conn->socket);
+            conn->socket = 0;
+            free(content);
+
+            return 0;
+        } else if (header.type == FCGI_STDERR) {
+            // TODO implement Necronda backend error handling
+            if (conn->mode == FASTCGI_PHP) {
+                fastcgi_php_error(conn, content, content_len, buf0);
+            }
+        } else if (header.type == FCGI_STDOUT) {
+            ptr += snprintf(ptr, len - (ptr - buf), "%.*s", content_len, content);
+        } else {
+            print(ERR_STR "Unknown FastCGI type: %i" CLR_STR, header.type);
+        }
+        free(content);
+    }
+}
+
 int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len) {
     unsigned long rcv_len = 0;
     char *buf[16384];
@@ -532,7 +614,7 @@ int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len) {
         if (send(conn->socket, &header, sizeof(header), 0) != sizeof(header)) goto err;
         if (send(conn->socket, buf, ret, 0) != ret) {
             err:
-            print(ERR_STR "Unable to send to PHP-FPM: %s" CLR_STR, strerror(errno));
+            print(ERR_STR "Unable to send to FastCGI socket: %s" CLR_STR, strerror(errno));
             return -2;
         }
     }

src/lib/fastcgi.h

@@ -16,32 +16,42 @@
 #define FASTCGI_COMPRESS_GZ 2
 #define FASTCGI_COMPRESS_BR 4
 #define FASTCGI_COMPRESS 6
+#define FASTCGI_COMPRESS_HOLD 8
+
+#define FASTCGI_PHP 1
+#define FASTCGI_NECRONDA 2
 
 #ifndef PHP_FPM_SOCKET
 #   define PHP_FPM_SOCKET "/var/run/php-fpm/php-fpm.sock"
 #endif
 
+#define NECRONDA_BACKEND_SOCKET "/var/run/necronda/necronda-backend.sock"
+
 typedef struct {
+    int mode;
     int socket;
     unsigned short req_id;
     char *out_buf;
+    const char *webroot;
     unsigned short out_len;
     unsigned short out_off;
 } fastcgi_conn;
 
 char *fastcgi_add_param(char *buf, const char *key, const char *value);
 
-int fastcgi_init(fastcgi_conn *conn, unsigned int client_num, unsigned int req_num, const sock *client,
+int fastcgi_init(fastcgi_conn *conn, int mode, unsigned int client_num, unsigned int req_num, const sock *client,
                  const http_req *req, const http_uri *uri);
 
 int fastcgi_close_stdin(fastcgi_conn *conn);
 
-int fastcgi_php_error(const char *msg, int msg_len, char *err_msg);
+int fastcgi_php_error(const fastcgi_conn *conn, const char *msg, int msg_len, char *err_msg);
 
 int fastcgi_header(fastcgi_conn *conn, http_res *res, char *err_msg);
 
 int fastcgi_send(fastcgi_conn *conn, sock *client, int flags);
 
+int fastcgi_dump(fastcgi_conn *conn, char *buf, long len);
+
 int fastcgi_receive(fastcgi_conn *conn, sock *client, unsigned long len);
 
 #endif //NECRONDA_SERVER_FASTCGI_H

src/lib/http.c

@@ -125,7 +125,7 @@ int http_receive_request(sock *client, http_req *req) {
                         return 2;
                     }
                 }
-                strncpy(req->method, ptr, pos1 - ptr - 1);
+                snprintf(req->method, sizeof(req->method), "%.*s", (int) (pos1 - ptr - 1), ptr);
 
                 pos2 = memchr(pos1, ' ', rcv_len - (pos1 - buf)) + 1;
                 if (pos2 == NULL) {

src/lib/http.h

@@ -42,7 +42,7 @@
 typedef struct {
     unsigned short code;
     char type[16];
-    char msg[32];
+    char msg[64];
 } http_status;
 
 typedef struct {
@@ -75,12 +75,22 @@ typedef struct {
     http_hdr hdr;
 } http_res;
 
+typedef enum {
+    NONE, INTERNAL, CLIENT_REQ, SERVER_REQ, SERVER, SERVER_RES, CLIENT_RES
+} http_error_origin;
+
+typedef struct {
+    unsigned short status;
+    http_error_origin origin;
+} http_status_ctx;
+
 extern const http_status http_statuses[];
 extern const http_status_msg http_status_messages[];
 extern const int http_statuses_size;
 extern const int http_status_messages_size;
 
 extern const char http_default_document[];
+extern const char http_rev_proxy_document[];
 extern const char http_error_document[];
 extern const char http_error_icon[];
 extern const char http_warning_document[];

src/lib/http_static.c

@@ -116,20 +116,85 @@ const char http_default_document[] =
         "\t<link rel=\"shortcut icon\" type=\"image/x-icon\" href=\"/favicon.ico\"/>\n"
         "%5$s"
         "\t<style>\n"
-        "\t\thtml{font-family:\"Arial\",sans-serif;--error:" HTTP_COLOR_ERROR ";--warning:" HTTP_COLOR_WARNING ";--success:" HTTP_COLOR_SUCCESS ";--info:" HTTP_COLOR_INFO ";--color:var(--%4$s);}\n"
+        "\t\thtml{font-family:\"Arial\",sans-serif;--error:" HTTP_COLOR_ERROR ";--warning:" HTTP_COLOR_WARNING ";--success:" HTTP_COLOR_SUCCESS ";--info:" HTTP_COLOR_INFO ";--soft:#808080;--color:var(--%4$s);}\n"
         "\t\tbody{background-color:#F0F0F0;margin:0;}\n"
         "\t\tmain{max-width:650px;margin:2em auto;}\n"
-        "\t\tsection{margin:1em;background-color:#FFFFFF;border: 1px solid var(--color);border-radius:4px;padding:1em;}\n"
-        "\t\th1,h2,h3,h4,h5,h6,h7{text-align:center;color:var(--color);font-weight:normal;}\n"
-        "\t\th1{font-size:3em;margin:0.125em 0 0.125em 0;}\n"
+        "\t\tsection{margin:2em 1em;background-color:#FFFFFF;border: 1px solid var(--color);border-radius:4px;padding:1em;}\n"
+        "\t\th1,h2,h3,h4,h5,h6{text-align:center;color:var(--color);font-weight:normal;}\n"
+        "\t\th1{font-size:3em;margin:0.125em 0;}\n"
         "\t\th2{font-size:1.5em;margin:0.25em 0 1em 0;}\n"
         "\t\tp{text-align:center;font-size:0.875em;}\n"
-        "\t\tdiv.footer{color:#808080;font-size:0.75em;text-align:center;margin:2em 0 0.5em 0;}\n"
-        "\t\tdiv.footer a{color:#808080;}\n"
+        "\t\tdiv.footer{color:var(--soft);font-size:0.75em;text-align:center;margin:2em 0 0.5em 0;}\n"
+        "\t\tdiv.footer a{color:var(--soft);}\n"
+        "\t\tul,ol{width:fit-content;margin:auto;}\n"
+        "\t\tpre{width:fit-content;margin:2em auto 0 auto;}\n"
+        "\n"
+        "\t\tsection.error-ctx{display:flex;padding:0;border:none;}\n"
+        "\t\tdiv.box{flex:100%% 1 1;border:1px solid var(--info);color:var(--info);position:relative;padding:1em;box-sizing:border-box;text-align:center;}\n"
+        "\t\tdiv.box.error{border-color:var(--error);color:var(--error);}\n"
+        "\t\tdiv.box.success{border-color:var(--success);color:var(--success);}\n"
+        "\t\tdiv.arrow{position:absolute;height:20px;width:30px;z-index:10;background-repeat:no-repeat;background-size:contain;}\n"
+        "\t\tdiv.arrow.response{left:-17.5px;bottom:calc(33.3333%% - 10px);}\n"
+        "\t\tdiv.arrow.request{right:-17.5px;top:calc(33.3333%% - 10px);}\n"
+        "\t\tdiv.border{flex:1px 0 0;background-color:var(--info);}\n"
+        "\t\tdiv.border.error{background-color:var(--error);}\n"
+        "\t\tdiv.border.success{background-color:var(--success);}\n"
+        "\t\tdiv.content>span{display:block;color:var(--soft);font-size:0.75em;}\n"
+        "\t\tdiv.content>img{height:3.75rem;margin:0.75rem auto;display:block;}\n"
+        "\t\th3{font-size:2.25em;margin:0.75rem 0 0 0;color:unset;height:2.5rem;}\n"
+        "\t\th4{font-size:1em;margin:0 0 0.75rem 0;color:unset;height:1.25rem;}\n"
+        "\n"
+        "\t\tdiv.arrow.request.success{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjRkZG"
+        "RkZGIiBzdHJva2U9IiMwMDgwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
+        "\t\tdiv.arrow.request.error{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjRkZG"
+        "RkZGIiBzdHJva2U9IiNDMDAwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
+        "\t\tdiv.arrow.response.success{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiNGRkZG"
+        "RkYiIHN0cm9rZT0iIzAwODAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
+        "\t\tdiv.arrow.response.error{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiNGRkZG"
+        "RkYiIHN0cm9rZT0iI0MwMDAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
+        "\n"
         "\t\t@media(prefers-color-scheme:dark){\n"
-        "\t\t\thtml{color:#FFFFFF;}\n"
+        "\t\t\thtml{color:#FFFFFF;--soft:#404040;}\n"
         "\t\t\tbody{background-color:#101010;}\n"
         "\t\t\tsection{background-color:#181818;}\n"
+        "\n"
+        "\t\t\tdiv.arrow.request.success{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjMTgx"
+        "ODE4IiBzdHJva2U9IiMwMDgwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
+        "\t\t\tdiv.arrow.request.error{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTEsMSBMMjUsMSBMMjksMTAgTDI1LDE5IEwxLDE5IiBmaWxsPSIjMTgx"
+        "ODE4IiBzdHJva2U9IiNDMDAwMDAiIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPgo=');}\n"
+        "\t\t\tdiv.arrow.response.success{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiMxODE4"
+        "MTgiIHN0cm9rZT0iIzAwODAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
+        "\t\t\tdiv.arrow.response.error{background-image:url('data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzAiIGhlaWdodD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTI5LDE5IEw1LDE5IEwxLDEwIEw1LDEgTDI5LDEiIGZpbGw9IiMxODE4"
+        "MTgiIHN0cm9rZT0iI0MwMDAwMCIgc3Ryb2tlLXdpZHRoPSIyIi8+PC9zdmc+Cg==');}\n"
+        "\t\t}\n"
+        "\t\t@media(min-width:650px){\n"
+        "\t\t\tdiv.box:first-child{border-top-left-radius:4px;border-bottom-left-radius:4px;border-right:none;}\n"
+        "\t\t\tdiv.box:last-child{border-top-right-radius:4px;border-bottom-right-radius:4px;border-left:none;}\n"
+        "\t\t\tdiv.box:not(:last-child):not(:first-child){border-left:none;border-right:none;}\n"
+        "\t\t}\n"
+        "\t\t@media(max-width:650px){\n"
+        "\t\t\tsection.error-ctx{flex-direction:column;height:unset;}\n"
+        "\t\t\tdiv.box:first-child{border-top-left-radius:4px;border-top-right-radius:4px;border-bottom:none;padding-top:1em;}\n"
+        "\t\t\tdiv.box:last-child{border-bottom-right-radius:4px;border-bottom-left-radius:4px;border-top:none;padding-bottom:1em;}\n"
+        "\t\t\tdiv.box:not(:last-child):not(:first-child){border-top:none;border-bottom:none;}\n"
+        "\t\t\tdiv.arrow.response{transform:rotate(90deg);top:-10px;left:calc(33.3333%% - 22.5px);right:unset;}\n"
+        "\t\t\tdiv.arrow.request{transform:rotate(90deg);bottom:-10px;right:calc(33.3333%% - 22.5px);top:unset;}\n"
         "\t\t}\n"
         "\t</style>\n"
         "</head>\n"
@@ -137,12 +202,52 @@ const char http_default_document[] =
         "\t<main>\n"
         "\t\t<section>\n"
         "%3$s"
+        "%9$s"
         "\t\t\t<div class=\"footer\"><a href=\"https://%7$s/\">%7$s</a> - " SERVER_STR_HTML "</div>\n"
         "\t\t</section>\n"
+        "%8$s"
         "\t</main>\n"
         "</body>\n"
         "</html>\n";
 
+const char http_rev_proxy_document[] =
+        "\t\t<section class=\"error-ctx\">\n"
+        "\t\t\t<div class=\"box%1$s\">\n"
+        "\t\t\t\t<div class=\"content\">\n"
+        "\t\t\t\t\t<span>Client</span>\n"
+        "\t\t\t\t\t<img src=\"data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iNjQiIGhlaWdodD0iNjQiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
+        "L3N2ZyI+PHBhdGggZD0iTTIsMzIgYTMwLDMwLDAsMSwwLDYwLDAgYTMwLDMwLDAsMSwwLC02MCww"
+        "IEw2MiwzMiBNNiwxNiBMNTgsMTYgTTYsNDggTDU4LDQ4IE0zMiwyIEwzMiw2MiBhMTUsMzAsMCwx"
+        "LDAsMCwtNjAgYTE1LDMwLDAsMSwwLDAsNjAgWiIgc3Ryb2tlPSIjMDA4MDAwIiBzdHJva2Utd2lk"
+        "dGg9IjIiIGZpbGw9IiMwMDAwMDAwMCIvPjwvc3ZnPgo=\"/>\n"
+        "\t\t\t\t\t<span>Your Browser</span>\n"
+        "\t\t\t\t</div>\n"
+        "\t\t\t\t<div class=\"arrow request%2$s\"></div>\n"
+        "\t\t\t</div>\n"
+        "\t\t\t<div class=\"border%8$s\"></div>\n"
+        "\t\t\t<div class=\"box%3$s\">\n"
+        "\t\t\t\t<div class=\"content\">\n"
+        "\t\t\t\t\t<span>Reverse Proxy</span>\n"
+        "\t\t\t\t\t<h3>%10$03i</h3>\n"
+        "\t\t\t\t\t<h4>%11$s</h4>\n"
+        "\t\t\t\t\t<span>" SERVER_NAME "</span>\n"
+        "\t\t\t\t</div>\n"
+        "\t\t\t\t<div class=\"arrow request%4$s\"></div>\n"
+        "\t\t\t\t<div class=\"arrow response%5$s\"></div>\n"
+        "\t\t\t</div>\n"
+        "\t\t\t<div class=\"border%9$s\"></div>\n"
+        "\t\t\t<div class=\"box%6$s\">\n"
+        "\t\t\t\t<div class=\"content\">\n"
+        "\t\t\t\t\t<span>Server</span>\n"
+        "\t\t\t\t\t<h3>%12$s</h3>\n"
+        "\t\t\t\t\t<h4>%13$s</h4>\n"
+        "\t\t\t\t\t<span>%14$s</span>\n"
+        "\t\t\t\t</div>\n"
+        "\t\t\t\t<div class=\"arrow response%7$s\"></div>\n"
+        "\t\t\t</div>\n"
+        "\t\t</section>\n";
+
 const char http_error_document[] =
         "\t\t\t<h1>%1$i</h1>\n"
         "\t\t\t<h2>%2$s :&#xFEFF;(</h2>\n"
@@ -158,7 +263,7 @@ const char http_error_icon[] =
 
 const char http_warning_document[] =
         "\t\t\t<h1>%1$i</h1>\n"
-        "\t\t\t<h2>%2$s :&#xFEFF;o</h2>\n"
+        "\t\t\t<h2>%2$s :&#xFEFF;)</h2>\n"
         "\t\t\t<p>%3$s</p>\n"
         "\t\t\t<p>%4$s</p>\n";
 
@@ -166,7 +271,7 @@ const char http_warning_icon[] =
         "\t<link rel=\"alternate icon\" type=\"image/svg+xml\" sizes=\"any\" href=\"data:image/svg+xml;base64,"
         "PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAw"
         "L3N2ZyI+PHRleHQgeD0iNCIgeT0iMTIiIGZpbGw9IiNFMEMwMDAiIHN0eWxlPSJmb250LWZhbWls"
-        "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjpvPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
+        "eTonQXJpYWwnLHNhbnMtc2VyaWYiPjopPC90ZXh0Pjwvc3ZnPgo=\"/>\n";
 
 
 const char http_success_document[] =

src/lib/rev_proxy.c

@@ -36,7 +36,7 @@ int rev_proxy_request_header(http_req *req, int enc) {
     http_add_header_field(&req->hdr, "Connection", "keep-alive");
 
     char *via = http_get_header_field(&req->hdr, "Via");
-    sprintf(buf1, "HTTP/%s %s", req->version, DEFAULT_HOST);
+    sprintf(buf1, "HTTP/%s %s", req->version, SERVER_NAME);
     if (via == NULL) {
         http_add_header_field(&req->hdr, "Via", buf1);
     } else {
@@ -134,7 +134,7 @@ int rev_proxy_response_header(http_req *req, http_res *res) {
     int p_len;
 
     char *via = http_get_header_field(&res->hdr, "Via");
-    p_len = snprintf(buf1, sizeof(buf1), "HTTP/%s %s", req->version, DEFAULT_HOST);
+    p_len = snprintf(buf1, sizeof(buf1), "HTTP/%s %s", req->version, SERVER_NAME);
     if (p_len < 0 || p_len >= sizeof(buf1)) {
         print(ERR_STR "Appended part of header field 'Via' too long" CLR_STR);
         return -1;
@@ -154,8 +154,8 @@ int rev_proxy_response_header(http_req *req, http_res *res) {
     return 0;
 }
 
-int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client, http_status *custom_status,
-                   char *err_msg) {
+int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config *conf, sock *client,
+                   http_status *custom_status, char *err_msg) {
     char buffer[CHUNK_SIZE];
     long ret;
     int tries = 0;
@@ -177,27 +177,27 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
     if (rev_proxy.socket  < 0) {
         print(ERR_STR "Unable to create socket: %s" CLR_STR, strerror(errno));
         res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
         return -1;
     }
 
-    server_timeout.tv_sec = SERVER_TIMEOUT;
+    server_timeout.tv_sec = SERVER_TIMEOUT_INIT;
     server_timeout.tv_usec = 0;
-    if (setsockopt(client->socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
+    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
+        goto rev_proxy_timeout_err;
+    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
         goto rev_proxy_timeout_err;
-    if (setsockopt(client->socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) {
-        rev_proxy_timeout_err:
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to set timeout for socket: %s" CLR_STR, strerror(errno));
-        sprintf(err_msg, "Unable to set timeout for socket: %s", strerror(errno));
-        goto proxy_err;
-    }
 
-    struct hostent *host_ent = gethostbyname(conf->rev_proxy.hostname);
+    struct hostent *host_ent = gethostbyname2(conf->rev_proxy.hostname, AF_INET6);
     if (host_ent == NULL) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to connect to server: Name or service not known" CLR_STR);
-        sprintf(err_msg, "Unable to connect to server: Name or service not known.");
-        goto proxy_err;
+        host_ent = gethostbyname2(conf->rev_proxy.hostname, AF_INET);
+        if (host_ent == NULL) {
+            res->status = http_get_status(503);
+            ctx->origin = SERVER_REQ;
+            print(ERR_STR "Unable to connect to server: Name or service not known" CLR_STR);
+            sprintf(err_msg, "Unable to connect to server: Name or service not known.");
+            goto proxy_err;
+        }
     }
 
     struct sockaddr_in6 address = {.sin6_family = AF_INET6, .sin6_port = htons(conf->rev_proxy.port)};
@@ -209,13 +209,38 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
         memcpy(&address.sin6_addr, addr, 16);
     }
 
+    inet_ntop(address.sin6_family, (void *) &address.sin6_addr, buffer, sizeof(buffer));
+
+    print(BLUE_STR "Connecting to " BLD_STR "[%s]:%i" CLR_STR BLUE_STR "..." CLR_STR, buffer, conf->rev_proxy.port);
     if (connect(rev_proxy.socket, (struct sockaddr *) &address, sizeof(address)) < 0) {
-        res->status = http_get_status(502);
-        print(ERR_STR "Unable to connect to server: %s" CLR_STR, strerror(errno));
+        if (errno == ETIMEDOUT || errno == EINPROGRESS) {
+            res->status = http_get_status(504);
+            ctx->origin = SERVER_REQ;
+        } else if (errno == ECONNREFUSED) {
+            res->status = http_get_status(503);
+            ctx->origin = SERVER_REQ;
+        } else {
+            res->status = http_get_status(500);
+            ctx->origin = INTERNAL;
+        }
+        print(ERR_STR "Unable to connect to [%s]:%i: %s" CLR_STR, buffer, conf->rev_proxy.port, strerror(errno));
         sprintf(err_msg, "Unable to connect to server: %s.", strerror(errno));
         goto proxy_err;
     }
 
+    server_timeout.tv_sec = SERVER_TIMEOUT;
+    server_timeout.tv_usec = 0;
+    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
+        goto rev_proxy_timeout_err;
+    if (setsockopt(rev_proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) {
+        rev_proxy_timeout_err:
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        print(ERR_STR "Unable to set timeout for reverse proxy socket: %s" CLR_STR, strerror(errno));
+        sprintf(err_msg, "Unable to set timeout for reverse proxy socket: %s", strerror(errno));
+        goto proxy_err;
+    }
+
     if (conf->rev_proxy.enc) {
         rev_proxy.ssl = SSL_new(rev_proxy.ctx);
         SSL_set_fd(rev_proxy.ssl, rev_proxy.socket);
@@ -228,6 +253,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
         rev_proxy.enc = 1;
         if (ret < 0) {
             res->status = http_get_status(502);
+            ctx->origin = SERVER_REQ;
             print(ERR_STR "Unable to perform handshake: %s" CLR_STR, sock_strerror(&rev_proxy));
             sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&rev_proxy));
             goto proxy_err;
@@ -235,19 +261,20 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
     }
 
     rev_proxy_host = conf->name;
-    inet_ntop(address.sin6_family, (void *) &address.sin6_addr, buffer, sizeof(buffer));
     print(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i" CLR_STR, buffer, conf->rev_proxy.port);
 
     rev_proxy:
     ret = rev_proxy_request_header(req, (int) client->enc);
     if (ret != 0) {
         res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
         return -1;
     }
 
     ret = http_send_request(&rev_proxy, req);
     if (ret < 0) {
         res->status = http_get_status(502);
+        ctx->origin = SERVER_REQ;
         print(ERR_STR "Unable to send request to server (1): %s" CLR_STR, sock_strerror(&rev_proxy));
         sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
         retry = tries < 4;
@@ -265,6 +292,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
             ret = sock_send(&rev_proxy, client->buf, len, 0);
             if (ret <= 0) {
                 res->status = http_get_status(502);
+                ctx->origin = SERVER_REQ;
                 print(ERR_STR "Unable to send request to server (2): %s" CLR_STR, sock_strerror(&rev_proxy));
                 sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
                 retry = tries < 4;
@@ -277,16 +305,19 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
             if (ret <= 0) {
                 if (ret == -1) {
                     res->status = http_get_status(502);
+                    ctx->origin = SERVER_REQ;
                     print(ERR_STR "Unable to send request to server (3): %s" CLR_STR, sock_strerror(&rev_proxy));
                     sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&rev_proxy));
                     goto proxy_err;
                 } else if (ret == -2) {
                     res->status = http_get_status(400);
+                    ctx->origin = CLIENT_REQ;
                     print(ERR_STR "Unable to receive request from client: %s" CLR_STR, sock_strerror(client));
                     sprintf(err_msg, "Unable to receive request from client: %s.", sock_strerror(client));
                     return -1;
                 }
                 res->status = http_get_status(500);
+                ctx->origin = INTERNAL;
                 print(ERR_STR "Unknown Error" CLR_STR);
                 return -1;
             }
@@ -295,7 +326,16 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
 
     ret = sock_recv(&rev_proxy, buffer, sizeof(buffer), MSG_PEEK);
     if (ret <= 0) {
-        res->status = http_get_status(502);
+        int enc_err = sock_enc_error(&rev_proxy);
+        if (errno == EAGAIN || errno == EINPROGRESS || enc_err == SSL_ERROR_WANT_READ ||
+            enc_err == SSL_ERROR_WANT_WRITE)
+        {
+            res->status = http_get_status(504);
+            ctx->origin = SERVER_RES;
+        } else {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
+        }
         print(ERR_STR "Unable to receive response from server: %s" CLR_STR, sock_strerror(&rev_proxy));
         sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&rev_proxy));
         goto proxy_err;
@@ -306,6 +346,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
 
     if (header_len <= 0) {
         res->status = http_get_status(502);
+        ctx->origin = SERVER_RES;
         print(ERR_STR "Unable to parse header: End of header not found" CLR_STR);
         sprintf(err_msg, "Unable to parser header: End of header not found.");
         goto proxy_err;
@@ -314,6 +355,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
     for (int i = 0; i < header_len; i++) {
         if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
             res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
             print(ERR_STR "Unable to parse header: Header contains illegal characters" CLR_STR);
             sprintf(err_msg, "Unable to parse header: Header contains illegal characters.");
             goto proxy_err;
@@ -325,6 +367,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
         char *pos0 = strstr(ptr, "\r\n");
         if (pos0 == NULL) {
             res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
             print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
             sprintf(err_msg, "Unable to parse header: Invalid header format.");
             goto proxy_err;
@@ -332,6 +375,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
         if (ptr == buf) {
             if (strncmp(ptr, "HTTP/", 5) != 0) {
                 res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
                 print(ERR_STR "Unable to parse header: Invalid header format" CLR_STR);
                 sprintf(err_msg, "Unable to parse header: Invalid header format.");
                 goto proxy_err;
@@ -341,10 +385,12 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
             if (res->status == NULL && status_code >= 100 && status_code <= 999) {
                 custom_status->code = status_code;
                 strcpy(custom_status->type, "");
-                strncpy(custom_status->msg, ptr + 13, strchr(ptr, '\r') - ptr - 13);
+                snprintf(custom_status->msg, sizeof(custom_status->msg), "%.*s",
+                         (int) (strchr(ptr, '\r') - ptr - 13), ptr + 13);
                 res->status = custom_status;
             } else if (res->status == NULL) {
                 res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
                 print(ERR_STR "Unable to parse header: Invalid or unknown status code" CLR_STR);
                 sprintf(err_msg, "Unable to parse header: Invalid or unknown status code.");
                 goto proxy_err;
@@ -353,6 +399,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
             ret = http_parse_header_field(&res->hdr, ptr, pos0);
             if (ret != 0) {
                 res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
                 print(ERR_STR "Unable to parse header" CLR_STR);
                 sprintf(err_msg, "Unable to parse header.");
                 goto proxy_err;
@@ -368,6 +415,7 @@ int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client
     ret = rev_proxy_response_header(req, res);
     if (ret != 0) {
         res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
         return -1;
     }
 
@@ -485,3 +533,9 @@ int rev_proxy_send(sock *client, unsigned long len_to_send, int flags) {
 
     return 0;
 }
+
+int rev_proxy_dump(char *buf, long len) {
+    sock_recv(&rev_proxy, buf, len, 0);
+    sock_close(&rev_proxy);
+    return 0;
+}

src/lib/rev_proxy.h

@@ -13,6 +13,10 @@
 #define REV_PROXY_COMPRESS_BR 4
 #define REV_PROXY_COMPRESS 6
 
+#ifndef SERVER_NAME
+#   define SERVER_NAME "revproxy"
+#endif
+
 #include "http.h"
 #include "config.h"
 
@@ -24,9 +28,11 @@ int rev_proxy_request_header(http_req *req, int enc);
 
 int rev_proxy_response_header(http_req *req, http_res *res);
 
-int rev_proxy_init(http_req *req, http_res *res, host_config *conf, sock *client, http_status *custom_status,
-                   char *err_msg);
+int rev_proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config *conf, sock *client,
+                   http_status *custom_status, char *err_msg);
 
 int rev_proxy_send(sock *client, unsigned long len_to_send, int flags);
 
+int rev_proxy_dump(char *buf, long len);
+
 #endif //NECRONDA_SERVER_REV_PROXY_H

src/lib/sock.c

@@ -12,6 +12,10 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
+int sock_enc_error(sock *s) {
+    return (int) s->enc ? SSL_get_error(s->ssl, (int) s->_last_ret) : 0;
+}
+
 const char *sock_strerror(sock *s) {
     if (s->_last_ret == 0) {
         return "closed";
@@ -21,7 +25,7 @@ const char *sock_strerror(sock *s) {
         }
         const char *err1 = ERR_reason_error_string(s->_ssl_error);
         const char *err2 = strerror(errno);
-        switch (SSL_get_error(s->ssl, (int) s->_last_ret)) {
+        switch (sock_enc_error(s)) {
             case SSL_ERROR_NONE:
                 return NULL;
             case SSL_ERROR_ZERO_RETURN:

src/lib/sock.h

@@ -23,6 +23,8 @@ typedef struct {
     unsigned long _ssl_error;
 } sock;
 
+int sock_enc_error(sock *s);
+
 const char *sock_strerror(sock *s);
 
 long sock_send(sock *s, void *buf, unsigned long len, int flags);

src/lib/uri.c

@@ -30,6 +30,7 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
     char buf1[1024];
     char buf2[1024];
     char buf3[1024];
+    char buf4[1024];
     int p_len;
     uri->webroot = NULL;
     uri->req_path = NULL;
@@ -99,12 +100,18 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
 
     while (1) {
         sprintf(buf0, "%s%s", uri->webroot, uri->path);
-        p_len = snprintf(buf1, sizeof(buf1), "%s.php", buf0);
+        p_len = snprintf(buf1, sizeof(buf1), "%s.ncr", buf0);
         if (p_len < 0 || p_len >= sizeof(buf1)) return -1;
-        p_len = snprintf(buf2, sizeof(buf2), "%s.html", buf0);
+        p_len = snprintf(buf2, sizeof(buf2), "%s.php", buf0);
         if (p_len < 0 || p_len >= sizeof(buf2)) return -1;
+        p_len = snprintf(buf3, sizeof(buf3), "%s.html", buf0);
+        if (p_len < 0 || p_len >= sizeof(buf3)) return -1;
 
-        if (strlen(uri->path) <= 1 || path_exists(buf0) || path_is_file(buf1) || path_is_file(buf2)) {
+        if (strlen(uri->path) <= 1 ||
+            path_exists(buf0) ||
+            path_is_file(buf1) ||
+            path_is_file(buf2) ||
+            path_is_file(buf3)) {
             break;
         }
 
@@ -112,37 +119,42 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
         parent_dir:
         ptr = strrchr(uri->path, '/');
         size = (long) strlen(ptr);
-        sprintf(buf3, "%.*s%s", (int) size, ptr, uri->pathinfo);
-        strcpy(uri->pathinfo, buf3);
+        sprintf(buf4, "%.*s%s", (int) size, ptr, uri->pathinfo);
+        strcpy(uri->pathinfo, buf4);
         ptr[0] = 0;
     }
     if (uri->pathinfo[0] != 0) {
-        sprintf(buf3, "%s", uri->pathinfo + 1);
-        strcpy(uri->pathinfo, buf3);
+        sprintf(buf4, "%s", uri->pathinfo + 1);
+        strcpy(uri->pathinfo, buf4);
     }
 
     if (path_is_file(buf0)) {
         uri->filename = malloc(strlen(buf0) + 1);
         strcpy(uri->filename, buf0);
         long len = (long) strlen(uri->path);
-        if (strcmp(uri->path + len - 5, ".html") == 0) {
-            uri->path[len - 5] = 0;
-        } else if (strcmp(uri->path + len - 4, ".php") == 0) {
+        if (strcmp(uri->path + len - 4, ".ncr") == 0 || strcmp(uri->path + len - 4, ".php") == 0) {
             uri->path[len - 4] = 0;
             uri->is_static = 0;
+        } else if (strcmp(uri->path + len - 5, ".html") == 0) {
+            uri->path[len - 5] = 0;
         }
     } else if (path_is_file(buf1)) {
         uri->is_static = 0;
         uri->filename = malloc(strlen(buf1) + 1);
         strcpy(uri->filename, buf1);
     } else if (path_is_file(buf2)) {
+        uri->is_static = 0;
         uri->filename = malloc(strlen(buf2) + 1);
         strcpy(uri->filename, buf2);
+    } else if (path_is_file(buf3)) {
+        uri->filename = malloc(strlen(buf3) + 1);
+        strcpy(uri->filename, buf3);
     } else {
         uri->is_dir = 1;
         strcpy(uri->path + strlen(uri->path), "/");
-        sprintf(buf1, "%s%sindex.php", uri->webroot, uri->path);
-        sprintf(buf2, "%s%sindex.html", uri->webroot, uri->path);
+        sprintf(buf1, "%s%sindex.ncr", uri->webroot, uri->path);
+        sprintf(buf2, "%s%sindex.php", uri->webroot, uri->path);
+        sprintf(buf3, "%s%sindex.html", uri->webroot, uri->path);
         if (path_is_file(buf1)) {
             uri->filename = malloc(strlen(buf1) + 1);
             strcpy(uri->filename, buf1);
@@ -150,6 +162,10 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
         } else if (path_is_file(buf2)) {
             uri->filename = malloc(strlen(buf2) + 1);
             strcpy(uri->filename, buf2);
+            uri->is_static = 0;
+        } else if (path_is_file(buf3)) {
+            uri->filename = malloc(strlen(buf3) + 1);
+            strcpy(uri->filename, buf3);
         } else {
             if (dir_mode == URI_DIR_MODE_FORBIDDEN) {
                 uri->is_static = 1;
@@ -169,7 +185,9 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
     if (strcmp(uri->path + strlen(uri->path) - 5, "index") == 0) {
         uri->path[strlen(uri->path) - 5] = 0;
     }
-    if (strcmp(uri->pathinfo, "index.php") == 0 || strcmp(uri->pathinfo, "index.html") == 0) {
+    if (strcmp(uri->pathinfo, "index.ncr") == 0 ||
+        strcmp(uri->pathinfo, "index.php") == 0 ||
+        strcmp(uri->pathinfo, "index.html") == 0) {
         uri->pathinfo[0] = 0;
     }
 

src/lib/utils.c

@@ -106,7 +106,7 @@ int url_decode(const char *str, char *dec, long *size) {
 int mime_is_compressible(const char *type) {
     if (type == NULL) return 0;
     char type_parsed[64];
-    strncpy(type_parsed, type, sizeof(type_parsed) - 1);
+    snprintf(type_parsed, sizeof(type_parsed), "%s", type);
     char *pos = strchr(type_parsed, ';');
     if (pos != NULL) pos[0] = 0;
     return
@@ -128,6 +128,18 @@ int mime_is_compressible(const char *type) {
         strcmp(type_parsed, "font/eot") == 0 ||
         strcmp(type_parsed, "font/opentype") == 0 ||
         strcmp(type_parsed, "image/bmp") == 0 ||
+        strcmp(type_parsed, "image/gif") == 0 ||
         strcmp(type_parsed, "image/vnd.microsoft.icon") == 0 ||
+        strcmp(type_parsed, "image/vnd.microsoft.iconbinary") == 0 ||
         strcmp(type_parsed, "image/x-icon") == 0;
 }
+
+int strcpy_rem_webroot(char *dst, const char *src, long len, const char *webroot) {
+    strncpy(dst, src, len);
+    if (webroot == NULL) return 0;
+    char *pos;
+    while ((pos = strstr(dst, webroot)) != NULL) {
+        strcpy(pos, pos + strlen(webroot));
+    }
+    return 0;
+}

src/lib/utils.h

@@ -40,4 +40,6 @@ int url_decode(const char *str, char *dec, long *size);
 
 int mime_is_compressible(const char *type);
 
+int strcpy_rem_webroot(char *dst, const char *str, long len, const char *webroot);
+
 #endif //NECRONDA_SERVER_UTILS_H

src/necronda-server.c

@@ -38,6 +38,7 @@ const char *config_file;
 int sockets[NUM_SOCKETS];
 pid_t children[MAX_CHILDREN];
 MMDB_s mmdbs[MAX_MMDB];
+SSL_CTX *contexts[CONFIG_MAX_CERT_CONFIG];
 
 void openssl_init() {
     SSL_library_init();
@@ -46,6 +47,15 @@ void openssl_init() {
     OpenSSL_add_all_algorithms();
 }
 
+static int ssl_servername_cb(SSL *ssl, int *ad, void *arg) {
+    const char *servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
+    if (servername != NULL) {
+        const host_config *conf = get_host_config(servername);
+        if (conf != NULL) SSL_set_SSL_CTX(ssl, contexts[conf->cert]);
+    }
+    return SSL_TLSEXT_ERR_OK;
+}
+
 void destroy() {
     fprintf(stderr, "\n" ERR_STR "Terminating forcefully!" CLR_STR "\n");
     int status = 0;
@@ -290,29 +300,40 @@ int main(int argc, const char *argv[]) {
     client.buf = NULL;
     client.buf_len = 0;
     client.buf_off = 0;
-    client.ctx = SSL_CTX_new(TLS_server_method());
-    SSL_CTX_set_options(client.ctx, SSL_OP_SINGLE_DH_USE);
-    SSL_CTX_set_verify(client.ctx, SSL_VERIFY_NONE, NULL);
-    SSL_CTX_set_min_proto_version(client.ctx, TLS1_2_VERSION);
-    SSL_CTX_set_mode(client.ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
-    SSL_CTX_set_cipher_list(client.ctx, "HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4");
-    SSL_CTX_set_ecdh_auto(client.ctx, 1);
+
+    for (int i = 0; i < CONFIG_MAX_CERT_CONFIG; i++) {
+        const cert_config *conf = &config->certs[i];
+        if (conf->name[0] == 0) break;
+
+        contexts[i] = SSL_CTX_new(TLS_server_method());
+        SSL_CTX *ctx = contexts[i];
+        SSL_CTX_set_options(ctx, SSL_OP_SINGLE_DH_USE);
+        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
+        SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);
+        SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
+        SSL_CTX_set_cipher_list(ctx, "HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4");
+        SSL_CTX_set_ecdh_auto(ctx, 1);
+        SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
+
+        if (SSL_CTX_use_certificate_chain_file(ctx, conf->full_chain) != 1) {
+            fprintf(stderr, ERR_STR "Unable to load certificate chain file: %s: %s" CLR_STR "\n",
+                    ERR_reason_error_string(ERR_get_error()), conf->full_chain);
+            config_unload();
+            return 1;
+        }
+        if (SSL_CTX_use_PrivateKey_file(ctx, conf->priv_key, SSL_FILETYPE_PEM) != 1) {
+            fprintf(stderr, ERR_STR "Unable to load private key file: %s: %s" CLR_STR "\n",
+                    ERR_reason_error_string(ERR_get_error()), conf->priv_key);
+            config_unload();
+            return 1;
+        }
+    }
+
+    client.ctx = contexts[0];
+
 
     rev_proxy_preload();
 
-    if (SSL_CTX_use_certificate_chain_file(client.ctx, cert_file) != 1) {
-        fprintf(stderr, ERR_STR "Unable to load certificate chain file: %s: %s" CLR_STR "\n",
-                ERR_reason_error_string(ERR_get_error()), cert_file);
-        config_unload();
-        return 1;
-    }
-    if (SSL_CTX_use_PrivateKey_file(client.ctx, key_file, SSL_FILETYPE_PEM) != 1) {
-        fprintf(stderr, ERR_STR "Unable to load private key file: %s: %s" CLR_STR "\n",
-                ERR_reason_error_string(ERR_get_error()), key_file);
-        config_unload();
-        return 1;
-    }
-
     for (int i = 0; i < NUM_SOCKETS; i++) {
         if (listen(sockets[i], LISTEN_BACKLOG) < 0) {
             fprintf(stderr, ERR_STR "Unable to listen on socket %i: %s" CLR_STR "\n", i, strerror(errno));

src/necronda-server.h

@@ -17,14 +17,11 @@
 #define LISTEN_BACKLOG 16
 #define REQ_PER_CONNECTION 200
 #define CLIENT_TIMEOUT 3600
-#define SERVER_TIMEOUT 4
+#define SERVER_TIMEOUT_INIT 4
+#define SERVER_TIMEOUT 3600
 
 #define CHUNK_SIZE 8192
 
-#ifndef DEFAULT_HOST
-#   define DEFAULT_HOST "www.necronda.net"
-#endif
-
 extern int sockets[NUM_SOCKETS];
 extern pid_t children[MAX_CHILDREN];
 extern MMDB_s mmdbs[MAX_MMDB];

src/necronda.h

@@ -8,8 +8,16 @@
 #ifndef NECRONDA_SERVER_NECRONDA_H
 #define NECRONDA_SERVER_NECRONDA_H
 
-#define NECRONDA_VERSION "4.4"
+#define NECRONDA_VERSION "4.5"
 #define SERVER_STR "Necronda/" NECRONDA_VERSION
 #define SERVER_STR_HTML "Necronda web server " NECRONDA_VERSION
 
+#ifndef DEFAULT_HOST
+#   define DEFAULT_HOST "www.necronda.net"
+#endif
+
+#ifndef SERVER_NAME
+#   define SERVER_NAME DEFAULT_HOST
+#endif
+
 #endif //NECRONDA_SERVER_NECRONDA_H