mpmc: Use volatile modifier on buffer differently

Makefile

@@ -59,6 +59,7 @@ bin/res/%.txt: res/%.*
 bin/sesimos: bin/server.o bin/logger.o bin/cache_handler.o bin/async.o bin/workers.o \
              bin/worker/request_handler.o bin/worker/tcp_acceptor.o \
              bin/worker/fastcgi_handler.o bin/worker/local_handler.o bin/worker/proxy_handler.o \
+             bin/worker/proxy_peer_handler.o \
              bin/worker/ws_frame_handler.o bin/worker/chunk_handler.o bin/worker/fastcgi_frame_handler.o \
              bin/lib/http_static.o bin/res/default.o bin/res/proxy.o bin/res/style.o \
              bin/res/icon_error.o bin/res/icon_info.o bin/res/icon_success.o bin/res/icon_warning.o \
@@ -90,6 +91,8 @@ bin/worker/local_handler.o: src/worker/func.h
 
 bin/worker/proxy_handler.o: src/worker/func.h
 
+bin/worker/proxy_peer_handler.o: src/worker/func.h
+
 bin/worker/ws_frame_handler.o: src/worker/func.h
 
 bin/worker/fastcgi_frame_handler.o: src/worker/func.h

src/async.c

@@ -19,8 +19,10 @@
 #include <pthread.h>
 #include <semaphore.h>
 #include <unistd.h>
+#include <openssl/ssl.h>
 
-#define ASYNC_MAX_EVENTS 16
+#define ASYNC_QUEUE_MAX_EVENTS 256
+#define ASYNC_EPOLL_MAX_EVENTS 64
 
 typedef struct {
     int fd;
@@ -35,10 +37,10 @@ typedef struct {
 
 typedef struct {
     int n;
-    evt_listen_t *q[ASYNC_MAX_EVENTS];
+    evt_listen_t *q[ASYNC_QUEUE_MAX_EVENTS];
 } listen_queue_t;
 
-static listen_queue_t listen1, listen2, *listen_q = &listen1;
+static volatile listen_queue_t listen1, listen2, *listen_q = &listen1;
 static volatile sig_atomic_t alive = 1;
 static pthread_t thread = -1;
 static sem_t lock;
@@ -49,6 +51,13 @@ static short async_a2p(async_evt_t events) {
     if (events & ASYNC_IN)  ret |= POLLIN;
     if (events & ASYNC_PRI) ret |= POLLPRI;
     if (events & ASYNC_OUT) ret |= POLLOUT;
+    if (events & ASYNC_ERR_) ret |= POLLERR;
+    if (events & ASYNC_HUP) ret |= POLLHUP;
+    if (events & ASYNC_RDNORM) ret |= POLLRDNORM;
+    if (events & ASYNC_RDBAND) ret |= POLLRDBAND;
+    if (events & ASYNC_WRNORM) ret |= POLLWRNORM;
+    if (events & ASYNC_WRBAND) ret |= POLLWRBAND;
+    if (events & ASYNC_MSG) ret |= POLLMSG;
     return ret;
 }
 
@@ -57,6 +66,13 @@ static unsigned int async_a2e(async_evt_t events) {
     if (events & ASYNC_IN)  ret |= EPOLLIN;
     if (events & ASYNC_PRI) ret |= EPOLLPRI;
     if (events & ASYNC_OUT) ret |= EPOLLOUT;
+    if (events & ASYNC_ERR_) ret |= EPOLLERR;
+    if (events & ASYNC_HUP) ret |= EPOLLHUP;
+    if (events & ASYNC_RDNORM) ret |= EPOLLRDNORM;
+    if (events & ASYNC_RDBAND) ret |= EPOLLRDBAND;
+    if (events & ASYNC_WRNORM) ret |= EPOLLWRNORM;
+    if (events & ASYNC_WRBAND) ret |= EPOLLWRBAND;
+    if (events & ASYNC_MSG) ret |= EPOLLMSG;
     return ret;
 }
 
@@ -65,8 +81,13 @@ static async_evt_t async_p2a(short events) {
     if (events & POLLIN)   ret |= ASYNC_IN;
     if (events & POLLPRI)  ret |= ASYNC_PRI;
     if (events & POLLOUT)  ret |= ASYNC_OUT;
-    if (events & POLLERR)  ret |= ASYNC_ERR;
+    if (events & POLLERR)  ret |= ASYNC_ERR_;
     if (events & POLLHUP)  ret |= ASYNC_HUP;
+    if (events & POLLRDNORM) ret |= ASYNC_RDNORM;
+    if (events & POLLRDBAND) ret |= ASYNC_RDBAND;
+    if (events & POLLWRNORM) ret |= ASYNC_WRNORM;
+    if (events & POLLWRBAND) ret |= ASYNC_WRBAND;
+    if (events & POLLMSG) ret |= ASYNC_MSG;
     return ret;
 }
 
@@ -75,11 +96,24 @@ static async_evt_t async_e2a(unsigned int events) {
     if (events & EPOLLIN)   ret |= ASYNC_IN;
     if (events & EPOLLPRI)  ret |= ASYNC_PRI;
     if (events & EPOLLOUT)  ret |= ASYNC_OUT;
-    if (events & EPOLLERR)  ret |= ASYNC_ERR;
+    if (events & EPOLLERR)  ret |= ASYNC_ERR_;
     if (events & EPOLLHUP)  ret |= ASYNC_HUP;
+    if (events & EPOLLRDNORM) ret |= ASYNC_RDNORM;
+    if (events & EPOLLRDBAND) ret |= ASYNC_RDBAND;
+    if (events & EPOLLWRNORM) ret |= ASYNC_WRNORM;
+    if (events & EPOLLWRBAND) ret |= ASYNC_WRBAND;
+    if (events & EPOLLMSG) ret |= ASYNC_MSG;
     return ret;
 }
 
+static short async_e2p(unsigned int events) {
+    return async_a2p(async_e2a(events));
+}
+
+static unsigned int async_p2e(short events) {
+    return async_a2e(async_p2a(events));
+}
+
 static int async_add_to_queue(evt_listen_t *evt) {
     while (sem_wait(&lock) != 0) {
         if (errno == EINTR) {
@@ -90,7 +124,13 @@ static int async_add_to_queue(evt_listen_t *evt) {
         }
     }
 
-    evt_listen_t *ptr = malloc(sizeof(evt_listen_t));
+    if (listen_q->n >= ASYNC_QUEUE_MAX_EVENTS) {
+        sem_post(&lock);
+        errno = ENOBUFS;
+        return -1;
+    }
+
+    evt_listen_t *ptr = malloc(sizeof(*evt));
     if (ptr == NULL) {
         sem_post(&lock);
         return -1;
@@ -104,20 +144,20 @@ static int async_add_to_queue(evt_listen_t *evt) {
     return 0;
 }
 
-static int async_exec(evt_listen_t *evt, async_evt_t r_events) {
+static int async_exec_cb(evt_listen_t *evt, async_evt_t r_events, void (**cb)(void *)) {
     int ret, e = errno;
     if (r_events & evt->events) {
         // specified event(s) occurred
-        if (evt->socket && !sock_has_pending(evt->socket, 0)) {
-            evt->err_cb(evt->arg);
+        if (!(evt->flags & ASYNC_IGNORE_PENDING) && evt->socket && !sock_has_pending(evt->socket, 0)) {
+            *cb = evt->err_cb;
             ret = 0;
         } else {
-            evt->cb(evt->arg);
+            *cb = evt->cb;
             ret = (evt->flags & ASYNC_KEEP) ? 1 : 0;
         }
     } else if (r_events & (POLLERR | POLLHUP | POLLNVAL)) {
         // error occurred
-        evt->err_cb(evt->arg);
+        *cb = evt->err_cb;
         ret = 0;
     } else {
         // no event occurred
@@ -128,6 +168,13 @@ static int async_exec(evt_listen_t *evt, async_evt_t r_events) {
     return ret;
 }
 
+static int async_exec(evt_listen_t *evt, async_evt_t r_events) {
+    void (*cb)(void *) = NULL;
+    const int ret = async_exec_cb(evt, r_events, &cb);
+    if (cb != NULL) cb(evt->arg);
+    return ret;
+}
+
 static int async_check(evt_listen_t *evt) {
     struct pollfd fds[1] = {{
         .fd = evt->fd,
@@ -135,6 +182,11 @@ static int async_check(evt_listen_t *evt) {
     }};
 
     // check, if fd is already ready
+    if (evt->events & ASYNC_IN && evt->socket && evt->socket->enc && SSL_pending(evt->socket->ssl) > 0) {
+        // ssl layer already ready
+        if (async_exec(evt, ASYNC_IN) == 0)
+            return 1;
+    }
     switch (poll(fds, 1, 0)) {
         case 1:
             // fd already ready
@@ -153,9 +205,12 @@ static int async_add(evt_listen_t *evt) {
     if (async_check(evt) == 1)
         return 0;
 
-    int ret = async_add_to_queue(evt);
-    if (ret == 0 && thread != -1)
+    int ret;
+    if ((ret = async_add_to_queue(evt)) != 0) {
+        alert("Unable to add event to async queue");
+    } else if (thread != -1) {
         pthread_kill(thread, SIGUSR1);
+    }
 
     return ret;
 }
@@ -212,10 +267,10 @@ void async_free(void) {
 }
 
 void async_thread(void) {
-    struct epoll_event ev, events[ASYNC_MAX_EVENTS];
-    int num_fds;
+    struct epoll_event ev, events[ASYNC_EPOLL_MAX_EVENTS];
+    int num_fds, idx;
     long ts, min_ts, cur_ts;
-    listen_queue_t *l;
+    volatile listen_queue_t *l;
     evt_listen_t **local;
 
     if ((local = list_create(sizeof(evt_listen_t *), 16)) == NULL) {
@@ -228,8 +283,18 @@ void async_thread(void) {
     // main event loop
     while (alive) {
         // swap listen queue
+        while (sem_wait(&lock) != 0) {
+            if (errno == EINTR) {
+                errno = 0;
+                continue;
+            } else {
+                critical("Unable to lock async queue");
+                return;
+            }
+        }
         l = listen_q;
         listen_q = (listen_q == &listen1) ? &listen2 : &listen1;
+        sem_post(&lock);
 
         // fill local list and epoll instance with previously added queue entries
         for (int i = 0; i < l->n; i++) {
@@ -243,7 +308,32 @@ void async_thread(void) {
             ev.events = async_a2e(evt->events);
             ev.data.ptr = evt;
 
-            if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, evt->fd, &ev) == -1) {
+            while (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, evt->fd, &ev) == -1) {
+                if (errno == EEXIST) {
+                    // fd already exists, delete old one
+                    warning("Unable to add file descriptor to epoll instance");
+                    errno = 0;
+                    if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, evt->fd, NULL) != -1) {
+                        local = list_delete(local, evt);
+                        if (local == NULL) {
+                            critical("Unable to resize async local list");
+                            return;
+                        }
+                        notice("Removed old file descriptor from epoll instance");
+                        continue;
+                    }
+                } else if (errno == EBADF || errno == EPERM) {
+                    // fd probably already closed or does not support epoll somehow
+                    // FIXME should not happen
+                    warning("Unable to add file descriptor to epoll instance");
+                    errno = 0;
+                    local = list_remove(local, list_size(local) - 1);
+                    if (local == NULL) {
+                        critical("Unable to resize async local list");
+                        return;
+                    }
+                    break;
+                }
                 critical("Unable to add file descriptor to epoll instance");
                 return;
             }
@@ -255,18 +345,18 @@ void async_thread(void) {
         // calculate wait timeout
         min_ts = -1000, cur_ts = clock_micros();
         for (int i = 0; i < list_size(local); i++) {
-            evt_listen_t *evt = local[i];
-            if (!evt->socket) continue;
+            const evt_listen_t *evt = local[i];
+            if (!evt->socket || evt->socket->timeout_us < 0) continue;
 
             ts = evt->socket->ts_last + evt->socket->timeout_us - cur_ts;
             if (min_ts == -1000 || ts < min_ts) min_ts = ts;
         }
 
-        if ((num_fds = epoll_wait(epoll_fd, events, ASYNC_MAX_EVENTS, (int) (min_ts / 1000))) == -1) {
+        // epoll is used in level-triggered mode, so buffers are taken into account
+        if ((num_fds = epoll_wait(epoll_fd, events, ASYNC_EPOLL_MAX_EVENTS, (int) (min_ts / 1000))) == -1) {
             if (errno == EINTR) {
                 // interrupt
                 errno = 0;
-                continue;
             } else {
                 // other error
                 critical("Unable to poll for events");
@@ -276,13 +366,17 @@ void async_thread(void) {
 
         for (int i = 0; i < num_fds; i++) {
             evt_listen_t *evt = events[i].data.ptr;
-            if (!list_contains(local, &evt)) continue;
+            if ((idx = list_find(local, &evt)) == -1) {
+                error("epoll instance reported event not contained in local list");
+                continue;
+            }
 
-            if (async_exec(evt, async_e2a(events[i].events)) == 0) {
+            void (*cb)(void *) = NULL;
+            if (async_exec_cb(evt, async_e2a(events[i].events), &cb) == 0) {
                 logger_set_prefix("");
                 if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, evt->fd, NULL) == -1) {
-                    if (errno == EBADF) {
-                        // already closed fd, do not die
+                    if (errno == EBADF || errno == ENOENT || errno == EPERM) {
+                        // already closed, fd not found, or fd does not support epoll, anyway do not die
                         errno = 0;
                     } else {
                         critical("Unable to remove file descriptor from epoll instance");
@@ -290,13 +384,16 @@ void async_thread(void) {
                     }
                 }
 
-                local = list_delete(local, &evt);
+                local = list_remove(local, idx);
                 if (local == NULL) {
                     critical("Unable to resize async local list");
                     return;
                 }
 
+                if (cb != NULL) cb(evt->arg);
                 free(evt);
+            } else {
+                if (cb != NULL) cb(evt->arg);
             }
             logger_set_prefix("");
         }
@@ -304,15 +401,15 @@ void async_thread(void) {
         // check, if some socket ran into a timeout
         cur_ts = clock_micros();
         for (int i = 0; i < list_size(local); i++) {
-            evt_listen_t *evt = local[i];
+            const evt_listen_t *evt = local[i];
             if (!evt->socket) continue;
 
-            if ((cur_ts - evt->socket->ts_last) >= evt->socket->timeout_us) {
+            if (evt->socket->timeout_us >= 0 && (cur_ts - evt->socket->ts_last) >= evt->socket->timeout_us) {
                 evt->to_cb(evt->arg);
 
                 if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, evt->fd, NULL) == -1) {
-                    if (errno == EBADF) {
-                        // already closed fd, do not die
+                    if (errno == EBADF || errno == ENOENT || errno == EPERM) {
+                        // already closed, fd not found, or fd does not support epoll, anyway do not die
                         errno = 0;
                     } else {
                         critical("Unable to remove file descriptor from epoll instance");

src/async.h

@@ -12,12 +12,18 @@
 #include "lib/sock.h"
 
 #define ASYNC_KEEP 1
+#define ASYNC_IGNORE_PENDING 2
 
-#define ASYNC_IN   0x01
-#define ASYNC_PRI  0x02
-#define ASYNC_OUT  0x04
-#define ASYNC_ERR  0x08
-#define ASYNC_HUP  0x10
+#define ASYNC_IN     0x001
+#define ASYNC_PRI    0x002
+#define ASYNC_OUT    0x004
+#define ASYNC_ERR_   0x008
+#define ASYNC_HUP    0x010
+#define ASYNC_RDNORM 0x040
+#define ASYNC_RDBAND 0x080
+#define ASYNC_WRNORM 0x100
+#define ASYNC_WRBAND 0x200
+#define ASYNC_MSG    0x400
 
 #define ASYNC_WAIT_READ  ASYNC_IN
 #define ASYNC_WAIT_WRITE ASYNC_OUT

src/cache_handler.c

@@ -75,6 +75,10 @@ static void magic_mime_type(const char *restrict filename, char *buf) {
             strcpy(buf, "application/javascript");
             sem_post(&sem_magic);
             return;
+        } else if (strends(filename, ".xhtml")) {
+            strcpy(buf, "application/xhtml+xml");
+            sem_post(&sem_magic);
+            return;
         }
     }
 
@@ -435,7 +439,8 @@ void cache_init_uri(cache_t *cache, http_uri *uri) {
             cache_update_entry(entry, uri->filename, uri->webroot);
             uri->meta = &entry->meta;
         } else {
-            warning("No empty cache entry slot found");
+            error("No empty cache entry slot found");
+            // FIXME populate uri->meta with temporary data
         }
     } else {
         uri->meta = &entry->meta;

src/cache_handler.h

@@ -11,7 +11,7 @@
 
 #include "lib/uri.h"
 
-#define CACHE_ENTRIES 1024
+#define CACHE_ENTRIES 8192
 
 #define CACHE_DIRTY 1
 

src/lib/fastcgi.c

@@ -77,11 +77,14 @@ int fastcgi_send_data(fastcgi_cnx_t *cnx, unsigned char type, unsigned short len
 
 int fastcgi_init(fastcgi_cnx_t *conn, int mode, unsigned int req_num, const sock *client, const http_req *req, const http_uri *uri) {
     conn->mode = mode;
+    conn->header_sent = 0;
     conn->req_id = (req_num + 1) & 0xFFFF;
     conn->webroot = uri->webroot;
     conn->err = NULL;
     conn->fd_err_bytes = 0;
-    sock_init(&conn->out, 0, SOCK_PIPE);
+    conn->fd_out = -1;
+    conn->fd_err = -1;
+    sock_init(&conn->out, -1, SOCK_PIPE);
 
     conn->socket.enc = 0;
     if ((conn->socket.socket = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
@@ -192,6 +195,7 @@ int fastcgi_init(fastcgi_cnx_t *conn, int mode, unsigned int req_num, const sock
 
     conn->fd_out = pipes[1][1];
     conn->out.socket = pipes[1][0];
+    sock_set_timeout(&conn->out, FASTCGI_TIMEOUT);
 
     conn->fd_err = pipes[0][1];
     conn->err = fdopen(pipes[0][0], "r");
@@ -204,11 +208,13 @@ int fastcgi_close_cnx(fastcgi_cnx_t *cnx) {
 
     if (cnx->err) fclose(cnx->err);
     cnx->err = NULL;
-    if (cnx->socket.socket) sock_close(&cnx->socket);
+    sock_close(&cnx->socket);
 
     sock_close(&cnx->out);
-    close(cnx->fd_err);
-    close(cnx->fd_out);
+    if (cnx->fd_err != -1) close(cnx->fd_err);
+    if (cnx->fd_out != -1) close(cnx->fd_out);
+    cnx->fd_err = -1;
+    cnx->fd_out = -1;
 
     errno = e;
     return 0;
@@ -219,7 +225,7 @@ int fastcgi_close_stdin(fastcgi_cnx_t *cnx) {
 }
 
 int fastcgi_php_error(fastcgi_cnx_t *cnx, char *err_msg) {
-    char *line = NULL, *line_ptr = NULL;
+    char *line = NULL, *line_ptr = NULL, *next_ptr = NULL;
     size_t line_len = 0;
     int err = 0;
 
@@ -231,6 +237,12 @@ int fastcgi_php_error(fastcgi_cnx_t *cnx, char *err_msg) {
 
         if (strstarts(line_ptr, "PHP message: ")) {
             line_ptr += 13;
+        } else if (!strstr(line_ptr, "; PHP message: ")) {
+            logmsgf(msg_type, "%s", line_ptr);
+            continue;
+        }
+
+        while (line_ptr) {
             if (strstarts(line_ptr, "PHP Warning:  ")) {
                 msg_type = LOG_WARNING;
             } else if (strstarts(line_ptr, "PHP Fatal error:  ")) {
@@ -239,14 +251,22 @@ int fastcgi_php_error(fastcgi_cnx_t *cnx, char *err_msg) {
                 msg_type = LOG_ERROR;
             } else if (strstarts(line_ptr, "PHP Notice:  ")) {
                 msg_type = LOG_NOTICE;
+            } else {
+                msg_type = LOG_INFO;
             }
-        }
 
-        logmsgf(msg_type, "%s", line_ptr);
+            if ((next_ptr = strstr(line_ptr, "; PHP message: "))) {
+                next_ptr[0] = 0;
+            }
 
-        if (err_msg && msg_type <= LOG_ERROR && line_ptr != line) {
-            strcpy_rem_webroot(err_msg, line_ptr, cnx->webroot);
-            err = 1;
+            logmsgf(msg_type, "%s", line_ptr);
+
+            if (err_msg && msg_type <= LOG_ERROR && line_ptr != line) {
+                strcpy_rem_webroot(err_msg, line_ptr, cnx->webroot);
+                err = 1;
+            }
+
+            line_ptr = next_ptr ? next_ptr + 15 : NULL;
         }
     }
 
@@ -274,7 +294,36 @@ int fastcgi_recv_frame(fastcgi_cnx_t *cnx) {
 
     if (header.type == FCGI_STDOUT || header.type == FCGI_STDERR) {
         char buf[256];
-        if (header.type == FCGI_STDOUT) {
+
+        if (header.type == FCGI_STDOUT && !cnx->header_sent) {
+            char content[256 * 256];
+
+            if (sock_recv_x(&cnx->socket, content, content_len + header.paddingLength, 0) == -1)
+                return -1;
+
+            char *h_pos = strstr(content, "\r\n\r\n");
+            long header_len = h_pos - content + 4;
+            if (h_pos != NULL) {
+                uint64_t len;
+
+                len = header_len;
+                if (write(cnx->fd_out, &len, sizeof(len)) == -1)
+                    return -1;
+                if (write(cnx->fd_out, content, len) == -1)
+                    return -1;
+                cnx->header_sent = 1;
+
+                len = content_len - header_len;
+                if (len > 0) {
+                    if (write(cnx->fd_out, &len, sizeof(len)) == -1)
+                        return -1;
+                    if (write(cnx->fd_out, content + header_len, len) == -1)
+                        return -1;
+                }
+
+                return header.type;
+            }
+        } else if (header.type == FCGI_STDOUT) {
             uint64_t len = content_len;
             if (write(cnx->fd_out, &len, sizeof(len)) == -1)
                 return -1;
@@ -286,6 +335,7 @@ int fastcgi_recv_frame(fastcgi_cnx_t *cnx) {
             cnx->fd_err_bytes += content_len + 1;
         }
         for (long ret, sent = 0; sent < content_len; sent += ret) {
+            // FIXME if pipe is full thread gets stuck
             if ((ret = splice(cnx->socket.socket, 0, fd, 0, content_len - sent, 0)) == -1) {
                 if (errno == EINTR) {
                     errno = 0, ret = 0;
@@ -320,11 +370,6 @@ int fastcgi_recv_frame(fastcgi_cnx_t *cnx) {
     return header.type;
 }
 
-long fastcgi_send(fastcgi_cnx_t *cnx, sock *client) {
-    char buf[CHUNK_SIZE];
-    return sock_splice_all(client, &cnx->out, buf, sizeof(buf));
-}
-
 int fastcgi_header(fastcgi_cnx_t *cnx, http_res *res, char *err_msg) {
     long ret, len;
     char content[CLIENT_MAX_HEADER_SIZE];
@@ -384,8 +429,17 @@ int fastcgi_header(fastcgi_cnx_t *cnx, http_res *res, char *err_msg) {
     return 0;
 }
 
-int fastcgi_dump(fastcgi_cnx_t *cnx, char *buf, long len) {
-    return sock_recv_x(&cnx->socket, buf, len, 0) == -1 ? -1 : 0;
+int fastcgi_dump(fastcgi_cnx_t *cnx, char *buf, const long len) {
+    for (long ret, rcv = 0; rcv < len; rcv += ret) {
+        if ((ret = sock_recv_chunk_header(&cnx->out)) == -1) {
+            return -1;
+        }
+        const long min = ret > len - rcv ? len - rcv : ret;
+        if ((ret = sock_recv_x(&cnx->out, buf + rcv, min, 0)) <= 0) {
+            return -1;
+        }
+    }
+    return 0;
 }
 
 int fastcgi_receive(fastcgi_cnx_t *cnx, sock *client, unsigned long len) {

src/lib/fastcgi.h

@@ -13,6 +13,7 @@
 #include "http.h"
 #include "uri.h"
 
+#define FASTCGI_SOCKET_TIMEOUT 1
 #define FASTCGI_TIMEOUT 3600
 
 #define FASTCGI_BACKEND_PHP 1
@@ -23,6 +24,7 @@
 
 typedef struct {
     int mode;
+    unsigned char header_sent:1;
     sock socket, out;
     int fd_err, fd_out;
     long fd_err_bytes;

src/lib/http.c

@@ -101,6 +101,7 @@ void http_free_field(http_field *f) {
 }
 
 void http_free_hdr(http_hdr *hdr) {
+    if (hdr->fields == NULL) return;
     for (int i = 0; i < list_size(hdr->fields); i++) {
         http_free_field(&hdr->fields[i]);
     }
@@ -131,7 +132,7 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,
     if (hdr->last_field_num > list_size(hdr->fields))
         return http_error(HTTP_ERROR_GENERAL);
 
-    char *pos1 = (char *) buf, *pos2 = (char *) end_ptr;
+    const char *pos1 = buf, *pos2 = end_ptr;
     if (buf[0] == ' ' || buf[0] == '\t') {
         if (hdr->last_field_num == -1)
             return http_error(HTTP_ERROR_GENERAL);
@@ -387,6 +388,14 @@ int http_send_request(sock *server, http_req *req) {
     return 0;
 }
 
+int http_send_100_continue(sock *client) {
+    char buf[256];
+    char date_buf[64];
+    int size = sprintf(buf, "HTTP/1.1 100 Continue\r\nDate: %s\r\nServer: " SERVER_STR "\r\n\r\n",
+                       http_get_date(date_buf, sizeof(date_buf)));
+    return sock_send_x(client, buf, size, 0) == -1 ? -1 : 0;
+}
+
 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) {

src/lib/http.h

@@ -174,6 +174,8 @@ int http_send_response(sock *client, http_res *res);
 
 int http_send_request(sock *server, http_req *req);
 
+int http_send_100_continue(sock *client);
+
 const http_status *http_get_status(status_code_t status_code);
 
 const http_status_msg *http_get_error_msg(status_code_t status_code);

src/lib/mpmc.c

@@ -10,7 +10,7 @@
 
 static void *mpmc_worker(void *arg);
 
-int mpmc_init(mpmc_t *ctx, int n_workers, int buf_size, void (*consumer)(void *obj), const char *name) {
+int mpmc_init(mpmc_t *ctx, const int n_workers, const int buf_size, void (*consumer)(void *), const char *name) {
     ctx->alive = 1;
     ctx->n_workers = n_workers;
     ctx->size = buf_size, ctx->max_size = buf_size;
@@ -35,8 +35,8 @@ int mpmc_init(mpmc_t *ctx, int n_workers, int buf_size, void (*consumer)(void *o
         return -1;
     }
 
-    memset(ctx->buffer,   0, ctx->size      * sizeof(void *));
-    memset(ctx->workers, -1, ctx->n_workers * sizeof(pthread_t));
+    memset((void *)ctx->buffer, 0, ctx->size      * sizeof(void *));
+    memset(ctx->workers,       -1, ctx->n_workers * sizeof(pthread_t));
 
     for (int i = 0; i < ctx->n_workers; i++) {
         int ret;
@@ -72,7 +72,7 @@ int mpmc_queue(mpmc_t *ctx, void *obj) {
         }
     }
 
-    int p = ctx->wr;
+    const int p = ctx->wr;
     ctx->wr = (ctx->wr + 1) % ctx->size;
 
     // unlock wr field
@@ -121,7 +121,7 @@ static void *mpmc_worker(void *arg) {
             }
         }
 
-        int p = ctx->rd;
+        const int p = ctx->rd;
         ctx->rd = (ctx->rd + 1) % ctx->size;
 
         // unlock rd field
@@ -143,12 +143,13 @@ void mpmc_stop(mpmc_t *ctx) {
 }
 
 void mpmc_destroy(mpmc_t *ctx) {
-    int e = errno;
+    const int e = errno;
 
-    // stop threads, if running
+    // stop threads if running
     mpmc_stop(ctx);
     for (int i = 0; i < ctx->n_workers; i++) {
         if (ctx->workers[i] == -1) break;
+        debug("Waiting for worker %s/%i to finish...", ctx->name, i);
         pthread_kill(ctx->workers[i], SIGUSR1);
         pthread_join(ctx->workers[i], NULL);
     }
@@ -157,7 +158,7 @@ void mpmc_destroy(mpmc_t *ctx) {
     sem_destroy(&ctx->used);
     sem_destroy(&ctx->lck_rd);
     sem_destroy(&ctx->lck_wr);
-    free(ctx->buffer);
+    free((void *)ctx->buffer);
     free(ctx->workers);
 
     // reset errno

src/lib/mpmc.h

@@ -5,18 +5,18 @@
 #include <semaphore.h>
 
 typedef struct {
-    unsigned char alive;
+    volatile unsigned int alive:1;
     int n_workers;
-    int rd, wr;
+    volatile int rd, wr;
     sem_t free, used, lck_rd, lck_wr;
     int size, max_size;
-    void **buffer;
+    void *volatile *buffer;
     pthread_t *workers;
     void (*consumer)(void *obj);
     const char* name;
 } mpmc_t;
 
-int mpmc_init(mpmc_t *ctx, int n_workers, int buf_size, void (*consumer)(void *obj), const char *name);
+int mpmc_init(mpmc_t *ctx, int n_workers, int buf_size, void (*consumer)(void *), const char *name);
 
 int mpmc_queue(mpmc_t *ctx, void *obj);
 

src/lib/proxy.c

@@ -137,11 +137,20 @@ proxy_ctx_t *proxy_get_by_conf(host_config_t *conf) {
     return NULL;
 }
 
-void proxy_unlock_ctx(proxy_ctx_t *ctx) {
+int proxy_unlock_ctx(proxy_ctx_t *ctx) {
     int n = (int) ((ctx - proxies) / MAX_PROXY_CNX_PER_HOST);
+    if (ctx->close) proxy_close(ctx);
+
+    debug("Released proxy connection slot %i/%i", (ctx - proxies) % MAX_PROXY_CNX_PER_HOST, MAX_PROXY_CNX_PER_HOST);
     ctx->in_use = 0;
     ctx->client = NULL;
     sem_post(&available[n]);
+    if (!ctx->close) {
+        return 1;
+    } else {
+        ctx->close = 0;
+        return 0;
+    }
 }
 
 int proxy_request_header(http_req *req, sock *sock) {
@@ -202,13 +211,13 @@ int proxy_request_header(http_req *req, sock *sock) {
         if (forwarded == NULL) {
             http_add_header_field(&req->hdr, "X-Forwarded-Host", http_get_header_field(&req->hdr, "Host"));
         } else {
-            char *ptr = strchr(forwarded, ',');
+            const char *ptr = strchr(forwarded, ',');
             unsigned long len;
             if (ptr != NULL) len = ptr - forwarded;
             else len = strlen(forwarded);
             ptr = strstr(forwarded, "host=");
             if ((ptr - forwarded) < len) {
-                char *end = strchr(ptr, ';');
+                const char *end = strchr(ptr, ';');
                 if (end == NULL) len -= (ptr - forwarded);
                 else len = (end - ptr);
                 len -= 5;
@@ -224,13 +233,13 @@ int proxy_request_header(http_req *req, sock *sock) {
         if (forwarded == NULL) {
             http_add_header_field(&req->hdr, "X-Forwarded-Proto", sock->enc ? "https" : "http");
         } else {
-            char *ptr = strchr(forwarded, ',');
+            const char *ptr = strchr(forwarded, ',');
             unsigned long len;
             if (ptr != NULL) len = ptr - forwarded;
             else len = strlen(forwarded);
             ptr = strstr(forwarded, "proto=");
             if ((ptr - forwarded) < len) {
-                char *end = strchr(ptr, ';');
+                const char *end = strchr(ptr, ';');
                 if (end == NULL) len -= (ptr - forwarded);
                 else len = (end - ptr);
                 len -= 6;
@@ -305,13 +314,16 @@ static int proxy_connect(proxy_ctx_t *proxy, host_config_t *conf, http_res *res,
     info(BLUE_STR "Connecting to " BLD_STR "[%s]:%i" CLR_STR BLUE_STR "...", conf->proxy.hostname, conf->proxy.port);
 
     int fd;
-    if ((fd = sock_connect(conf->proxy.hostname, conf->proxy.port, SERVER_TIMEOUT_INIT, addr_buf, sizeof(addr_buf))) == -1) {
-        if (errno == ETIMEDOUT || errno == EINPROGRESS) {
+    if ((fd = sock_connect(conf->proxy.hostname, conf->proxy.port, SERVER_SOCKET_TIMEOUT_INIT, addr_buf, sizeof(addr_buf))) == -1) {
+        if (errno == ETIMEDOUT || errno == EINPROGRESS || errno == EHOSTDOWN || errno == EHOSTUNREACH) {
             res->status = http_get_status(504);
             ctx->origin = SERVER_REQ;
         } else if (errno == ECONNREFUSED) {
             res->status = http_get_status(502);
             ctx->origin = SERVER_REQ;
+        } else if (errno == ECONNABORTED || errno == ECONNRESET) {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
         } else {
             res->status = http_get_status(500);
             ctx->origin = INTERNAL;
@@ -340,6 +352,7 @@ static int proxy_connect(proxy_ctx_t *proxy, host_config_t *conf, http_res *res,
         if ((ret = SSL_do_handshake(proxy->proxy.ssl)) != 1) {
             sock_error(&proxy->proxy, (int) ret);
             SSL_free(proxy->proxy.ssl);
+            proxy->proxy.ssl = NULL;
             res->status = http_get_status(502);
             ctx->origin = SERVER_REQ;
             error("Unable to perform handshake");
@@ -354,7 +367,8 @@ static int proxy_connect(proxy_ctx_t *proxy, host_config_t *conf, http_res *res,
     proxy->host = conf->name;
     proxy->http_timeout = 0;
 
-    info(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i", addr_buf, conf->proxy.port);
+    info(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i" CLR_STR BLUE_STR " (slot %i/%i)",
+         addr_buf, conf->proxy.port, (proxy - proxies) % MAX_PROXY_CNX_PER_HOST, MAX_PROXY_CNX_PER_HOST);
 
     return 0;
 }
@@ -366,6 +380,7 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
     *proxy_ptr = proxy_get_by_conf(conf);
     proxy_ctx_t *proxy = *proxy_ptr;
     proxy->client = NULL;
+    debug("Selected proxy connection slot %i/%i", (proxy - proxies) % MAX_PROXY_CNX_PER_HOST, MAX_PROXY_CNX_PER_HOST);
 
     const char *connection = http_get_header_field(&req->hdr, "Connection");
     if (strcontains(connection, "upgrade") || strcontains(connection, "Upgrade")) {
@@ -395,8 +410,10 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
         if (!retry)
             return -1;
 
-        if (!proxy->initialized || sock_has_pending(&proxy->proxy, SOCK_DONTWAIT) != 0 || srv_error ||
-           (proxy->http_timeout != 0 && (clock_micros() - proxy->proxy.ts_last) >= proxy->http_timeout))
+        // honor server timeout with one-second buffer
+        if (!proxy->initialized || srv_error ||
+            (proxy->http_timeout > 0 && (clock_micros() - proxy->proxy.ts_last_send) >= proxy->http_timeout) ||
+            sock_has_pending(&proxy->proxy, SOCK_DONTWAIT))
         {
             if (proxy->initialized)
                 proxy_close(proxy);
@@ -423,37 +440,128 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
         break;
     }
 
-    const char *content_length = http_get_header_field(&req->hdr, "Content-Length");
-    unsigned long content_len = content_length != NULL ? strtoul(content_length, NULL, 10) : 0;
-    const char *transfer_encoding = http_get_header_field(&req->hdr, "Transfer-Encoding");
-
-    ret = 0;
-    if (content_len > 0) {
-        ret = sock_splice(&proxy->proxy, client, buffer, sizeof(buffer), content_len);
-    } else if (strcontains(transfer_encoding, "chunked")) {
-        ret = sock_splice_chunked(&proxy->proxy, client, buffer, sizeof(buffer), SOCK_CHUNKED);
-    }
-
-    if (ret < 0 || (content_len != 0 && ret != content_len)) {
-        if (ret == -1 && errno != EPROTO) {
-            res->status = http_get_status(502);
-            ctx->origin = SERVER_REQ;
-            error("Unable to send request to server (2)");
-            sprintf(err_msg, "Unable to send request to server: %s.", error_str(errno, err_buf, sizeof(err_buf)));
-            return -1;
-        } else if (ret == -1) {
-            res->status = http_get_status(400);
-            ctx->origin = CLIENT_REQ;
-            error("Unable to receive request from client");
-            sprintf(err_msg, "Unable to receive request from client: %s.", error_str(errno, err_buf, sizeof(err_buf)));
+    const char *client_expect = http_get_header_field(&req->hdr, "Expect");
+    int expect_100_continue = (client_expect != NULL && strcasecmp(client_expect, "100-continue") == 0);
+    int ignore_content = 0;
+    if (expect_100_continue) {
+        http_res tmp_res = {
+            .version = "1.1",
+            .status = http_get_status(501),
+        };
+        if (http_init_hdr(&tmp_res.hdr) != 0) {
+            res->status = http_get_status(500);
+            ctx->origin = INTERNAL;
+            error("Unable to initialize http header");
             return -1;
         }
+
+        ret = proxy_peek_response(proxy, &tmp_res, ctx, custom_status, err_msg);
+        http_free_hdr(&tmp_res.hdr);
+        if (ret < 0)
+            return (int) ret;
+
+        if (tmp_res.status->code == 100) {
+            if (sock_recv_x(&proxy->proxy, buffer, ret, 0) == -1) {
+                res->status = http_get_status(502);
+                ctx->origin = SERVER_RES;
+                error("Unable to receive from server");
+                return -1;
+            }
+            info("%s -> %03i %s%s", http_get_status_color(tmp_res.status->code), tmp_res.status->code, tmp_res.status->msg, CLR_STR);
+            if (http_send_response(client, &tmp_res) != 0) {
+                res->status = http_get_status(400);
+                ctx->origin = CLIENT_RES;
+                error("Unable to send to client");
+                return -1;
+            }
+        } else {
+            ignore_content = 1;
+        }
+    }
+
+    if (!ignore_content) {
+        const char *content_length = http_get_header_field(&req->hdr, "Content-Length");
+        unsigned long content_len = content_length != NULL ? strtoul(content_length, NULL, 10) : 0;
+        const char *transfer_encoding = http_get_header_field(&req->hdr, "Transfer-Encoding");
+
+        ret = 0;
+        if (content_len > 0) {
+            ret = sock_splice(&proxy->proxy, client, buffer, sizeof(buffer), content_len);
+        } else if (strcontains(transfer_encoding, "chunked")) {
+            ret = sock_splice_chunked(&proxy->proxy, client, buffer, sizeof(buffer), SOCK_CHUNKED);
+        }
+
+        if (ret < 0 || (content_len != 0 && ret != content_len)) {
+            if (ret == -1 && errno != EPROTO) {
+                res->status = http_get_status(502);
+                ctx->origin = SERVER_REQ;
+                error("Unable to send request to server (2)");
+                sprintf(err_msg, "Unable to send request to server: %s.", error_str(errno, err_buf, sizeof(err_buf)));
+                return -1;
+            } else if (ret == -1) {
+                res->status = http_get_status(400);
+                ctx->origin = CLIENT_REQ;
+                error("Unable to receive request from client");
+                sprintf(err_msg, "Unable to receive request from client: %s.", error_str(errno, err_buf, sizeof(err_buf)));
+                return -1;
+            }
+            res->status = http_get_status(500);
+            ctx->origin = INTERNAL;
+            error("Unknown Error");
+            return -1;
+        }
+    }
+
+    if (sock_set_socket_timeout(&proxy->proxy, SERVER_SOCKET_TIMEOUT_RES) != 0) {
         res->status = http_get_status(500);
         ctx->origin = INTERNAL;
-        error("Unknown Error");
+        error("Unable to set timeout for reverse proxy socket");
         return -1;
     }
 
+    while (1) {
+        ret = proxy_peek_response(proxy, res, ctx, custom_status, err_msg);
+        if (ret < 0) {
+            return (int) ret;
+        } else if (sock_recv_x(&proxy->proxy, buffer, ret, 0) == -1) {
+            res->status = http_get_status(502);
+            ctx->origin = SERVER_RES;
+            error("Unable to receive from server");
+            return -1;
+        }
+        if (res->status->code == 100) {
+            info("%s -> %03i %s%s", http_get_status_color(res->status->code), res->status->code, res->status->msg, CLR_STR);
+            if (http_send_response(client, res) != 0) {
+                res->status = http_get_status(400);
+                ctx->origin = CLIENT_RES;
+                error("Unable to send to client");
+                return -1;
+            }
+        } else {
+            break;
+        }
+    }
+
+    long keep_alive_timeout = http_get_keep_alive_timeout(&res->hdr);
+    proxy->http_timeout = (keep_alive_timeout > 0) ? keep_alive_timeout * 1000000 : 0;
+
+    connection = http_get_header_field(&res->hdr, "Connection");
+    proxy->close = !streq(res->version, "1.1") || strcontains(connection, "close") || strcontains(connection, "Close");
+
+    ret = proxy_response_header(req, res, conf);
+    if (ret != 0) {
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        return -1;
+    }
+
+    return 0;
+}
+
+int proxy_peek_response(proxy_ctx_t *proxy, http_res *res, http_status_ctx *ctx, http_status *custom_status, char *err_msg) {
+    char buffer[CHUNK_SIZE], err_buf[256];
+    long ret;
+
     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();
@@ -470,6 +578,13 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
     }
     buffer[ret] = 0;
 
+    if (sock_set_socket_timeout(&proxy->proxy, SOCKET_TIMEOUT) != 0) {
+        res->status = http_get_status(500);
+        ctx->origin = INTERNAL;
+        error("Unable to set timeout for reverse proxy socket");
+        return -1;
+    }
+
     char *buf = buffer;
     unsigned short header_len = (unsigned short) (strstr(buffer, "\r\n\r\n") - buffer + 4);
 
@@ -538,27 +653,15 @@ int proxy_init(proxy_ctx_t **proxy_ptr, http_req *req, http_res *res, http_statu
         }
         ptr = pos0 + 2;
     }
-    if (sock_recv_x(&proxy->proxy, buffer, header_len, 0) == -1)
-        return -1;
-
-    long keep_alive_timeout = http_get_keep_alive_timeout(&res->hdr);
-    proxy->http_timeout = (keep_alive_timeout > 0) ? keep_alive_timeout * 1000000 : 0;
-
-    ret = proxy_response_header(req, res, conf);
-    if (ret != 0) {
-        res->status = http_get_status(500);
-        ctx->origin = INTERNAL;
-        return -1;
-    }
-
-    return 0;
+    return header_len;
 }
 
-int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags) {
+long proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags) {
+    long ret;
     char buffer[CHUNK_SIZE];
-    if (sock_splice(client, &proxy->proxy, buffer, sizeof(buffer), len_to_send) == -1)
+    if ((ret = sock_splice(client, &proxy->proxy, buffer, sizeof(buffer), len_to_send)) == -1)
         return -1;
-    return 0;
+    return ret;
 }
 
 int proxy_dump(proxy_ctx_t *proxy, char *buf, long len) {
@@ -577,11 +680,16 @@ void proxy_close(proxy_ctx_t *ctx) {
     if (ctx->initialized) {
         ctx->cnx_e = clock_micros();
         char buf[32];
-        info(BLUE_STR "Closing proxy connection (%s)", format_duration(ctx->cnx_e - ctx->cnx_s, buf));
+        info(BLUE_STR "Closing proxy connection %i/%i (%s)",
+             (ctx - proxies) % MAX_PROXY_CNX_PER_HOST, MAX_PROXY_CNX_PER_HOST,
+             format_duration(ctx->cnx_e - ctx->cnx_s, buf));
     }
 
     sock_close(&ctx->proxy);
-
-    memset(ctx, 0, sizeof(*ctx));
+    ctx->initialized = 0;
+    ctx->http_timeout = 0;
+    ctx->cnx_e = 0, ctx->cnx_s = 0;
+    ctx->client = NULL;
+    ctx->host = NULL;
     errno = 0;
 }

src/lib/proxy.h

@@ -19,7 +19,7 @@
 #include "config.h"
 
 typedef struct {
-    unsigned char initialized:1, in_use:1;
+    volatile unsigned char initialized:1, in_use:1, close:1;
     sock proxy;
     long cnx_s, cnx_e;
     long http_timeout;
@@ -35,7 +35,7 @@ void proxy_close_all(void);
 
 proxy_ctx_t *proxy_get_by_conf(host_config_t *conf);
 
-void proxy_unlock_ctx(proxy_ctx_t *ctx);
+int proxy_unlock_ctx(proxy_ctx_t *ctx);
 
 int proxy_request_header(http_req *req, sock *sock);
 
@@ -43,7 +43,9 @@ int proxy_response_header(http_req *req, http_res *res, host_config_t *conf);
 
 int proxy_init(proxy_ctx_t **proxy, http_req *req, http_res *res, http_status_ctx *ctx, host_config_t *conf, sock *client, http_status *custom_status, char *err_msg);
 
-int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags);
+int proxy_peek_response(proxy_ctx_t *proxy, http_res *res, http_status_ctx *ctx, http_status *custom_status, char *err_msg);
+
+long proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags);
 
 int proxy_dump(proxy_ctx_t *proxy, char *buf, long len);
 

src/lib/sock.c

@@ -86,6 +86,7 @@ int sock_init(sock *s, int fd, int flags) {
     s->pipe = !!(flags & SOCK_PIPE);
     s->ts_start = clock_micros();
     s->ts_last = s->ts_start;
+    s->ts_last_send = s->ts_last;
     s->timeout_us = -1;
     s->ssl = NULL;
     s->addr = NULL;
@@ -224,6 +225,7 @@ long sock_send(sock *s, void *buf, unsigned long len, int flags) {
 
     if (ret >= 0) {
         s->ts_last = clock_micros();
+        s->ts_last_send = s->ts_last;
         return ret;
     } else {
         return -1;
@@ -233,7 +235,7 @@ long sock_send(sock *s, void *buf, unsigned long len, int flags) {
 long sock_send_x(sock *s, void *buf, unsigned long len, int flags) {
     for (long ret, sent = 0; sent < len; sent += ret) {
         if ((ret = sock_send(s, (unsigned char *) buf + sent, len - sent, flags)) <= 0) {
-            if (errno == EINTR) {
+            if (errno == EINTR || errno == EAGAIN) {
                 errno = 0, ret = 0;
                 continue;
             } else {
@@ -276,7 +278,7 @@ long sock_recv(sock *s, void *buf, unsigned long len, int flags) {
 long sock_recv_x(sock *s, void *buf, unsigned long len, int flags) {
     for (long ret, rcv = 0; rcv < len; rcv += ret) {
         if ((ret = sock_recv(s, (unsigned char *) buf + rcv, len - rcv, flags | MSG_WAITALL)) <= 0) {
-            if (errno == EINTR) {
+            if (errno == EINTR || errno == EAGAIN) {
                 errno = 0, ret = 0;
                 continue;
             } else {
@@ -293,7 +295,7 @@ long sock_splice(sock *dst, sock *src, void *buf, unsigned long buf_len, unsigne
     if ((src->pipe || dst->pipe) && !src->enc && !dst->enc) {
         for (long ret; send_len < len; send_len += ret) {
             if ((ret = splice(src->socket, 0, dst->socket, 0, len, 0)) == -1) {
-                if (errno == EINTR) {
+                if (errno == EINTR || errno == EAGAIN) {
                     errno = 0, ret = 0;
                     continue;
                 } else {
@@ -306,7 +308,7 @@ long sock_splice(sock *dst, sock *src, void *buf, unsigned long buf_len, unsigne
             next_len = (long) ((buf_len < (len - send_len)) ? buf_len : (len - send_len));
 
             if ((ret = sock_recv(src, buf, next_len, MSG_WAITALL)) <= 0) {
-                if (errno == EINTR) {
+                if (errno == EINTR || errno == EAGAIN) {
                     errno = 0, ret = 0;
                     continue;
                 } else {
@@ -326,7 +328,7 @@ long sock_splice_all(sock *dst, sock *src, void *buf, unsigned long buf_len) {
     long send_len = 0;
     for (long ret;; send_len += ret) {
         if ((ret = sock_recv(src, buf, buf_len, 0)) <= 0) {
-            if (errno == EINTR) {
+            if (errno == EINTR || errno == EAGAIN) {
                 errno = 0, ret = 0;
                 continue;
             } else if (ret == 0) {
@@ -374,12 +376,12 @@ long sock_splice_chunked(sock *dst, sock *src, void *buf, unsigned long buf_len,
 
 int sock_close(sock *s) {
     int e = errno;
-    if (s->enc && s->ssl != NULL) {
+    if (s->ssl != NULL) {
         SSL_shutdown(s->ssl);
         SSL_free(s->ssl);
         s->ssl = NULL;
     }
-    close(s->socket);
+    if (s->socket != -1) close(s->socket);
     s->socket = -1;
     s->enc = 0, s->pipe = 0;
     errno = e;
@@ -390,7 +392,9 @@ int sock_has_pending(sock *s, int flags) {
     int e = errno;
     long ret;
     if (s->pipe) {
-        ioctl(s->socket, FIONREAD, &ret);
+        int arg;
+        ioctl(s->socket, FIONREAD, &arg);
+        ret = arg;
     } else if (s->enc && (flags & SOCK_DONTWAIT)) {
         ret = SSL_pending(s->ssl);
     } else {
@@ -403,37 +407,44 @@ int sock_has_pending(sock *s, int flags) {
 
 long sock_recv_chunk_header(sock *s) {
     if (s->pipe) {
-        uint64_t len;
+        int64_t len;
         if (sock_recv_x(s, &len, sizeof(len), 0) == -1)
             return -1;
-        return (long) len;
+        if (len < 0) errno = ECONNABORTED;
+        return len;
     }
 
-    long ret;
+    long ret1, ret2;
     size_t len = 0;
-    char buf[20];
+    char buf[20], *buf_ptr = buf;
 
-    do {
-        if ((ret = sock_recv(s, buf, sizeof(buf) - 1, MSG_PEEK)) <= 0) {
-            if (errno == EINTR) {
+    while (1) {
+        if ((ret1 = sock_recv(s, buf_ptr, sizeof(buf) - 1 - (buf_ptr - buf), MSG_PEEK)) <= 0) {
+            if (errno == EINTR || errno == EAGAIN) {
                 errno = 0;
                 continue;
             } else {
                 return -1;
             }
-        } else if (ret < 2) {
-            continue;
         }
-        buf[ret] = 0;
+        buf_ptr[ret1] = 0;
 
-        if ((ret = parse_chunk_header(buf, ret, &len)) == -1 && errno == EPROTO)
-            return -1;
-    } while (ret < 0);
+        if ((ret2 = parse_chunk_header(buf, (buf_ptr - buf) + ret1, &len)) == -1) {
+            if (errno != EAGAIN) {
+                return -1;
+            } else {
+                if (sock_recv_x(s, buf_ptr, ret1, 0) == -1)
+                    return -1;
+            }
+        } else {
+            if (sock_recv_x(s, buf_ptr, len - (buf_ptr - buf), 0) == -1)
+                return -1;
+            break;
+        }
+        buf_ptr += ret1;
+    }
 
-    if (sock_recv_x(s, buf, len, 0) == -1)
-        return -1;
-
-    return ret;
+    return ret2;
 }
 
 int sock_send_chunk_header(sock *s, unsigned long size) {

src/lib/sock.h

@@ -31,14 +31,14 @@ typedef struct {
     char *addr, *s_addr;
     SSL_CTX *ctx;
     SSL *ssl;
-    long ts_start, ts_last, timeout_us;
+    long ts_start, ts_last, ts_last_send, timeout_us;
 } sock;
 
 void sock_error(sock *s, int ret);
 
 const char *sock_error_str(unsigned long err);
 
-int sock_init(sock *s, int fd, int enc);
+int sock_init(sock *s, int fd, int flags);
 
 int sock_connect(const char *hostname, unsigned short port, double timeout_sec, char *addr_buf, size_t addr_buf_size);
 

src/lib/uri.c

@@ -38,8 +38,8 @@ int path_exists(const char *path) {
     return ret == 0;
 }
 
-int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mode) {
-    char buf0[1024], buf1[1024], buf2[1024], buf3[1024];
+int uri_init(http_uri *uri, const char *webroot, char *uri_str, int dir_mode) {
+    char buf0[1024], buf1[1024], buf2[1024], buf3[1024], buf4[1024];
     int p_len;
 
     uri->webroot = NULL;
@@ -107,57 +107,71 @@ 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.xhtml", buf0);
         if (p_len < 0 || p_len >= sizeof(buf1)) return -1;
         p_len = snprintf(buf2, sizeof(buf2), "%s.html", buf0);
         if (p_len < 0 || p_len >= sizeof(buf2)) return -1;
+        p_len = snprintf(buf3, sizeof(buf3), "%s.php", buf0);
+        if (p_len < 0 || p_len >= sizeof(buf3)) return -1;
 
-        if (strlen(uri->path) <= 1 || path_exists(buf0) || path_is_file(buf1) || path_is_file(buf2))
+        if (strlen(uri->path) <= 1 || path_exists(buf0) || path_is_file(buf1) || path_is_file(buf2) || path_is_file(buf3))
             break;
 
         char *ptr;
         parent_dir:
         ptr = strrchr(uri->path, '/');
         size = (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 (strends(uri->path, ".php")) {
-            uri->path[len - 4] = 0;
-            uri->is_static = 0;
+        if (strends(uri->path, ".xhtml")) {
+            uri->path[len - 6] = 0;
         } else if (strends(uri->path, ".html")) {
             uri->path[len - 5] = 0;
+        } else if (strends(uri->path, ".php")) {
+            uri->path[len - 4] = 0;
+            uri->is_static = 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);
+        uri->is_static = 0;
     } else {
         uri->is_dir = 1;
         strcpy(uri->path + strlen(uri->path), "/");
-        sprintf(buf1, "%s%s" "index.php", uri->webroot, uri->path);
+        sprintf(buf1, "%s%s" "index.xhtml", uri->webroot, uri->path);
         sprintf(buf2, "%s%s" "index.html", uri->webroot, uri->path);
-        if (path_is_file(buf1)) {
+        sprintf(buf3, "%s%s" "index.php", uri->webroot, uri->path);
+        if (path_is_file(buf3) && uri->pathinfo[0] != 0) {
+            uri->filename = malloc(strlen(buf3) + 1);
+            strcpy(uri->filename, buf3);
+            uri->is_static = 0;
+        } else if (path_is_file(buf1)) {
             uri->filename = malloc(strlen(buf1) + 1);
             strcpy(uri->filename, buf1);
-            uri->is_static = 0;
         } else if (path_is_file(buf2)) {
             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);
+            uri->is_static = 0;
         } else {
             if (dir_mode == URI_DIR_MODE_FORBIDDEN) {
                 uri->is_static = 1;
@@ -174,17 +188,17 @@ int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mo
         }
     }
 
-    if (strends(uri->path + strlen(uri->path), "index"))
+    if (strends(uri->path, "/index"))
         uri->path[strlen(uri->path) - 5] = 0;
 
-    if (streq(uri->pathinfo, "index.php") || streq(uri->pathinfo, "index.html"))
+    if (streq(uri->pathinfo, "index.php") || streq(uri->pathinfo, "index.html") || streq(uri->pathinfo, "index.xhtml"))
         uri->pathinfo[0] = 0;
 
-    sprintf(buf0, "%s%s%s%s%s", uri->path,
+    sprintf(buf4, "%s%s%s%s%s", uri->path,
             (strlen(uri->pathinfo) == 0 || uri->path[strlen(uri->path) - 1] == '/') ? "" : "/",
             uri->pathinfo, uri->query != NULL ? "?" : "", uri->query != NULL ? uri->query : "");
-    uri->uri = malloc(strlen(buf0) + 1);
-    strcpy(uri->uri, buf0);
+    uri->uri = malloc(strlen(buf4) + 1);
+    strcpy(uri->uri, buf4);
 
     return 0;
 }

src/lib/uri.h

@@ -42,7 +42,7 @@ typedef struct {
 } http_uri;
 
 
-int uri_init(http_uri *uri, const char *webroot, const char *uri_str, int dir_mode);
+int uri_init(http_uri *uri, const char *webroot, char *uri_str, int dir_mode);
 
 int uri_init_cache(http_uri *uri);
 

src/lib/utils.c

@@ -20,6 +20,24 @@
 
 static const char base64_encode_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const int base64_mod_table[3] = {0, 2, 1};
+static const char base64_decode_table[256] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1,  0, -1, -1,
+    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
 
 
 char *format_duration(unsigned long micros, char *buf) {
@@ -150,6 +168,7 @@ int mime_is_text(const char *restrict type) {
         streq(type_parsed, "application/javascript") ||
         streq(type_parsed, "application/json") ||
         streq(type_parsed, "application/xml") ||
+        streq(type_parsed, "application/sql") ||
         streq(type_parsed, "application/x-www-form-urlencoded") ||
         streq(type_parsed, "application/x-tex") ||
         streq(type_parsed, "application/x-httpd-php") ||
@@ -174,7 +193,7 @@ int strcpy_rem_webroot(char *dst, const char *src, const char *webroot) {
     return 0;
 }
 
-int str_trim(char **start, char **end) {
+int str_trim(const char **start, const char **end) {
     if (start == NULL || end == NULL || *start == NULL || *end == NULL)
         return -1;
 
@@ -185,7 +204,7 @@ int str_trim(char **start, char **end) {
     return 0;
 }
 
-int str_trim_lws(char **start, char **end) {
+int str_trim_lws(const char **start, const char **end) {
     if (start == NULL || end == NULL || *start == NULL || *end == NULL)
         return -1;
 
@@ -206,25 +225,25 @@ int strcontains(const char *restrict haystack, const char *restrict needle) {
 
 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);
+    const 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);
+    const 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);
+    const unsigned long out_len = 4 * ((data_len + 2) / 3);
     if (output_len != NULL) *output_len = out_len;
 
     for (int i = 0, j = 0; i < data_len;) {
-        unsigned int octet_a = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
-        unsigned int octet_b = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
-        unsigned int octet_c = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
-        unsigned int triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+        const unsigned int octet_a = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
+        const unsigned int octet_b = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
+        const unsigned int octet_c = (i < data_len) ? ((unsigned char *) data)[i++] : 0;
+        const unsigned int triple = (octet_a << 16) | (octet_b << 8) | octet_c;
         output[j++] = base64_encode_table[(triple >> 3 * 6) & 0x3F];
         output[j++] = base64_encode_table[(triple >> 2 * 6) & 0x3F];
         output[j++] = base64_encode_table[(triple >> 1 * 6) & 0x3F];
@@ -238,6 +257,28 @@ int base64_encode(void *data, unsigned long data_len, char *output, unsigned lon
     return 0;
 }
 
+int base64_decode(const char *data, unsigned long data_len, void *output, unsigned long *output_len) {
+    const unsigned long out_len = 3 * ((data_len + 2) / 4);
+    if (output_len != NULL) *output_len = out_len;
+
+    char *out = output;
+    for (int i = 0, j = 0; i < data_len;) {
+        const int octet_a = (i < data_len) ? base64_decode_table[((unsigned char *) data)[i++]] : 0;
+        const int octet_b = (i < data_len) ? base64_decode_table[((unsigned char *) data)[i++]] : 0;
+        const int octet_c = (i < data_len) ? base64_decode_table[((unsigned char *) data)[i++]] : 0;
+        const int octet_d = (i < data_len) ? base64_decode_table[((unsigned char *) data)[i++]] : 0;
+        if (octet_a < 0 || octet_b < 0 || octet_c < 0 || octet_d < 0) return -1;
+        const unsigned int triple = (octet_a << 3 * 6) | (octet_b << 2 * 6) | (octet_c << 6) | octet_d;
+        out[j++] = (char) (triple >> 16);
+        out[j++] = (char) ((triple >> 8) & 0xFF);
+        out[j++] = (char) (triple & 0xFF);
+    }
+
+    out[out_len] = 0;
+
+    return 0;
+}
+
 long clock_micros(void) {
     struct timespec time;
     clock_gettime(CLOCK_MONOTONIC, &time);
@@ -383,9 +424,9 @@ long ftelll(FILE *file) {
     return lines + 1;
 }
 
-long parse_chunk_header(const char *buf, size_t len, size_t *ret_len) {
+long parse_chunk_header(const char *buf, const size_t len, size_t *ret_len) {
     for (int i = 0; i < len; i++) {
-        char ch = buf[i];
+        const char ch = buf[i];
         if (ch == '\r') {
             continue;
         } else if (ch == '\n' && i > 1 && buf[i - 1] == '\r') {
@@ -396,5 +437,6 @@ long parse_chunk_header(const char *buf, size_t len, size_t *ret_len) {
             return -1;
         }
     }
+    errno = EAGAIN;
     return -1;
 }

src/lib/utils.h

@@ -33,9 +33,9 @@ int mime_is_text(const char *restrict type);
 
 int strcpy_rem_webroot(char *dst, const char *str, const char *webroot);
 
-int str_trim(char **start, char **end);
+int str_trim(const char **start, const char **end);
 
-int str_trim_lws(char **start, char **end);
+int str_trim_lws(const char **start, const char **end);
 
 int streq(const char *restrict str1, const char *restrict str2);
 
@@ -47,6 +47,8 @@ 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);
 
+int base64_decode(const char *data, unsigned long data_len, void *output, unsigned long *output_len);
+
 long clock_micros(void);
 
 long clock_cpu(void);

src/logger.c

@@ -20,7 +20,7 @@
 #include <malloc.h>
 
 #define LOG_MAX_MSG_SIZE 2048
-#define LOG_BUF_SIZE 16
+#define LOG_BUF_SIZE 256
 #define LOG_NAME_LEN 12
 #define LOG_PREFIX_LEN 256
 

src/server.c

@@ -40,6 +40,8 @@ static SSL_CTX *contexts[CONFIG_MAX_CERT_CONFIG];
 static client_ctx_t **clients;
 static sem_t sem_clients_lock;
 
+static void terminate_gracefully(int sig);
+
 static void clean(void) {
     notice("Cleaning sesimos cache and metadata files...");
 
@@ -121,7 +123,7 @@ static void accept_cb(void *arg) {
     client_ctx_t *client_ctx = malloc(sizeof(client_ctx_t));
     if (client_ctx == NULL) {
         critical("Unable to allocate memory for client context");
-        errno = 0;
+        terminate_gracefully(0);
         return;
     }
     sock *client = &client_ctx->socket;
@@ -132,6 +134,7 @@ static void accept_cb(void *arg) {
     if (client_fd < 0) {
         critical("Unable to accept connection");
         free(client_ctx);
+        terminate_gracefully(0);
         return;
     }
 
@@ -146,6 +149,7 @@ static void accept_cb(void *arg) {
             continue;
         } else {
             critical("Unable to lock clients list");
+            terminate_gracefully(0);
             return;
         }
     }
@@ -154,8 +158,9 @@ static void accept_cb(void *arg) {
     clients = list_append(clients, &client_ctx);
     if (clients == NULL) {
         critical("Unable to add client context to list");
+        sem_post(&sem_clients_lock);
         free(client_ctx);
-        errno = 0;
+        terminate_gracefully(0);
         return;
     }
 
@@ -190,21 +195,27 @@ static void terminate_gracefully(int sig) {
     sigaction(SIGINT, &act, NULL);
     sigaction(SIGTERM, &act, NULL);
 
+    debug("Closing listening sockets...");
     for (int i = 0; i < NUM_SOCKETS; i++) {
         close(sockets[i]);
     }
 
+    debug("Stopping workers...");
     cache_stop();
     workers_stop();
+    debug("Destroying workers...");
     workers_destroy();
 
     logger_set_prefix("");
+    debug("Closing proxy connections...");
     proxy_close_all();
 
+    debug("Closing client connections...");
     while (list_size(clients) > 0)
         tcp_close(clients[0]);
     logger_set_prefix("");
 
+    debug("Stopping async loop...");
     async_stop();
 }
 
@@ -320,7 +331,7 @@ int main(int argc, char *const argv[]) {
         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_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_AUTO_RETRY);
         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);
@@ -400,7 +411,19 @@ int main(int argc, char *const argv[]) {
 
     logger_set_name("main");
 
-    workers_init();
+    if (workers_init() != 0) {
+        critical("Unable to initialize workers");
+        ssl_free();
+        list_free(clients);
+        sem_destroy(&sem_clients_lock);
+        geoip_free();
+        proxy_unload();
+        cache_join();
+        async_free();
+        logger_stop();
+        logger_join();
+        return 1;
+    }
 
     for (int i = 0; i < NUM_SOCKETS; i++) {
         async_fd(sockets[i], ASYNC_WAIT_READ, ASYNC_KEEP, &sockets[i], accept_cb, accept_err_cb, accept_err_cb);

src/server.h

@@ -12,14 +12,14 @@
 #include "worker/func.h"
 
 #define NUM_SOCKETS 2
-#define LISTEN_BACKLOG 16
-#define REQ_PER_CONNECTION 200
-#define CLIENT_TIMEOUT 3600
-#define SERVER_TIMEOUT_INIT 4
-#define SERVER_TIMEOUT 3600
+#define LISTEN_BACKLOG 256
+#define REQ_PER_CONNECTION 256
 
-#define CNX_HANDLER_WORKERS 8
-#define REQ_HANDLER_WORKERS 16
+#define SOCKET_TIMEOUT 1
+#define CLIENT_TIMEOUT 3600
+#define SERVER_SOCKET_TIMEOUT_INIT 5
+#define SERVER_SOCKET_TIMEOUT_RES 60
+#define SERVER_TIMEOUT 3600
 
 void server_free_client(client_ctx_t *ctx);
 

src/worker/chunk_handler.c

@@ -1,7 +1,7 @@
 /**
  * sesimos - secure, simple, modern web server
  * @brief FastCGI frame handler
- * @file src/worker/fcti_frame_handler.c
+ * @file src/worker/fcgi_frame_handler.c
  * @author Lorenz Stechauner
  * @date 2023-01-22
  */
@@ -16,7 +16,7 @@ void chunk_handler_func(chunk_ctx_t *ctx) {
     logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
 
     char buf[CHUNK_SIZE];
-    long sent = sock_splice_chunked(&ctx->client->socket, ctx->socket, buf, sizeof(buf), ctx->flags | SOCK_SINGLE_CHUNK);
+    const long sent = sock_splice_chunked(&ctx->client->socket, ctx->socket, buf, sizeof(buf), ctx->flags | SOCK_SINGLE_CHUNK);
     if (sent < 0) {
         // error
         error("Unable to splice chunk");
@@ -28,6 +28,7 @@ void chunk_handler_func(chunk_ctx_t *ctx) {
         ctx->next_cb(ctx);
     } else {
         // next chunk
+        ctx->client->transferred_length += sent;
         handle_chunk(ctx);
         return;
     }

src/worker/fastcgi_frame_handler.c

@@ -1,7 +1,7 @@
 /**
  * sesimos - secure, simple, modern web server
  * @brief FastCGI frame handler
- * @file src/worker/fcti_frame_handler.c
+ * @file src/worker/fastcgi_frame_handler.c
  * @author Lorenz Stechauner
  * @date 2023-01-22
  */
@@ -16,7 +16,8 @@
 #include <unistd.h>
 
 void fastcgi_frame_handler_func(fastcgi_ctx_t *ctx) {
-    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
+    logger_set_prefix("%s", ctx->log_prefix);
+    int64_t val = 0;
 
     switch (fastcgi_recv_frame(&ctx->cnx)) {
         case FCGI_STDOUT:
@@ -25,23 +26,21 @@ void fastcgi_frame_handler_func(fastcgi_ctx_t *ctx) {
             break;
         case -1:
             error("Unable to receive FastCGI frame");
-            ctx->client->s_keep_alive = 0;
-            fastcgi_close(ctx);
-            break;
+            val = -1;
         default:
             // end of request received
-            write(ctx->cnx.fd_out, "\0\0\0\0\0\0\0\0\r\n", 10);
+            write(ctx->cnx.fd_out, &val, sizeof(val));
             fastcgi_close(ctx);
     }
 }
 
 int fastcgi_handle_connection(client_ctx_t *ctx, fastcgi_cnx_t **cnx) {
     sock_set_timeout(&(*cnx)->socket, FASTCGI_TIMEOUT);
-    sock_set_socket_timeout(&(*cnx)->socket, 1);
+    sock_set_socket_timeout(&(*cnx)->socket, FASTCGI_SOCKET_TIMEOUT);
 
     fastcgi_ctx_t *a = malloc(sizeof(fastcgi_ctx_t));
     a->closed = 0;
-    a->client = ctx;
+    snprintf(a->log_prefix, sizeof(a->log_prefix), "[%*s]%s", ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
     memcpy(&a->cnx, *cnx, sizeof(fastcgi_cnx_t));
     ctx->fcgi_ctx = a;
     fastcgi_handle_frame(a);
@@ -51,12 +50,11 @@ int fastcgi_handle_connection(client_ctx_t *ctx, fastcgi_cnx_t **cnx) {
 }
 
 void fastcgi_close(fastcgi_ctx_t *ctx) {
-    if (ctx->closed == 0) {
-        ctx->closed++;
+    ctx->closed++;
+    if (ctx->closed != 2)
         return;
-    }
 
-    logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
+    logger_set_prefix("%s", ctx->log_prefix);
 
     fastcgi_php_error(&ctx->cnx, NULL);
 
@@ -66,7 +64,11 @@ void fastcgi_close(fastcgi_ctx_t *ctx) {
     debug("Closing FastCGI connection");
 
     fastcgi_close_cnx(&ctx->cnx);
-    ctx->client->fcgi_ctx = NULL;
     free(ctx);
     errno = 0;
 }
+
+void fastcgi_close_error(fastcgi_ctx_t *ctx) {
+    logger_set_prefix("%s", ctx->log_prefix);
+    fastcgi_close_cnx(&ctx->cnx);
+}

src/worker/fastcgi_handler.c

@@ -16,37 +16,35 @@
 #include <errno.h>
 #include <unistd.h>
 
-static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx);
-static int fastcgi_handler_2(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx);
+static int fastcgi_handler_1(client_ctx_t *ctx);
+static int fastcgi_handler_2(client_ctx_t *ctx);
 
 void fastcgi_handler_func(client_ctx_t *ctx) {
     logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->req_host, CLR_STR, ctx->log_prefix);
 
-    if (!ctx->chunks_transferred) {
-        fastcgi_cnx_t *fcgi_cnx = NULL;
-        int ret = fastcgi_handler_1(ctx, &fcgi_cnx);
-        respond(ctx);
-        if (ret == 0) {
-            switch (fastcgi_handler_2(ctx, fcgi_cnx)) {
-                case 1: return;
-                case 2: break;
-            }
-        } else if (ctx->fcgi_ctx != NULL) {
-            fastcgi_close(ctx->fcgi_ctx);
-        }
+    const int ret = fastcgi_handler_1(ctx);
+    respond(ctx);
+
+    if (ret == 0) {
+        fastcgi_handler_2(ctx);
+        return;
+    }
+
+    if (ctx->fcgi_ctx != NULL) {
+        fastcgi_close(ctx->fcgi_ctx);
+        ctx->fcgi_ctx = NULL;
     }
 
     request_complete(ctx);
     handle_request(ctx);
 }
 
-static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
+static int fastcgi_handler_1(client_ctx_t *ctx) {
     http_res *res = &ctx->res;
     http_req *req = &ctx->req;
     http_uri *uri = &ctx->uri;
     sock *client = &ctx->socket;
     char *err_msg = ctx->err_msg;
-    char buf[1024];
 
     int mode, ret;
     if (strends(uri->filename, ".php")) {
@@ -58,16 +56,11 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
     }
 
     fastcgi_cnx_t fcgi_cnx_buf;
-    sock_init(&fcgi_cnx_buf.socket, 0, 0);
+    sock_init(&fcgi_cnx_buf.socket, -1, 0);
     fcgi_cnx_buf.req_id = 0;
     fcgi_cnx_buf.r_addr = ctx->socket.addr;
     fcgi_cnx_buf.r_host = (ctx->host[0] != 0) ? ctx->host : NULL;
 
-    struct stat statbuf;
-    stat(uri->filename, &statbuf);
-    char *last_modified = http_format_date(statbuf.st_mtime, buf, sizeof(buf));
-    http_add_header_field(&res->hdr, "Last-Modified", last_modified);
-
     res->status = http_get_status(200);
     if (fastcgi_init(&fcgi_cnx_buf, mode, ctx->req_num, client, req, uri) != 0) {
         fastcgi_close_cnx(&fcgi_cnx_buf);
@@ -76,16 +69,37 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
         return 3;
     }
 
-    (*fcgi_cnx) = &fcgi_cnx_buf;
-    fastcgi_handle_connection(ctx, fcgi_cnx);
+    fastcgi_cnx_t *fcgi_cnx = &fcgi_cnx_buf;
+    fastcgi_handle_connection(ctx, &fcgi_cnx);
 
+    int expect_100_continue = 0;
+    const char *client_expect = http_get_header_field(&req->hdr, "Expect");
+    if (client_expect != NULL && strcasecmp(client_expect, "100-continue") == 0) {
+        expect_100_continue = 1;
+    } else if (client_expect != NULL) {
+        fastcgi_close_cnx((&fcgi_cnx_buf));
+        res->status = http_get_status(417);
+        return 3;
+    }
     const char *client_content_length = http_get_header_field(&req->hdr, "Content-Length");
     const char *client_transfer_encoding = http_get_header_field(&req->hdr, "Transfer-Encoding");
     if (client_content_length != NULL) {
+        if (expect_100_continue) {
+            info(HTTP_1XX_STR "100 Continue" CLR_STR);
+            http_send_100_continue(client);
+        }
         unsigned long client_content_len = strtoul(client_content_length, NULL, 10);
-        ret = fastcgi_receive(*fcgi_cnx, client, client_content_len);
+        ret = fastcgi_receive(fcgi_cnx, client, client_content_len);
     } else if (strcontains(client_transfer_encoding, "chunked")) {
-        ret = fastcgi_receive_chunked(*fcgi_cnx, client);
+        if (expect_100_continue) {
+            info(HTTP_1XX_STR "100 Continue" CLR_STR);
+            http_send_100_continue(client);
+        }
+        ret = fastcgi_receive_chunked(fcgi_cnx, client);
+    } else if (expect_100_continue) {
+        fastcgi_close_cnx((&fcgi_cnx_buf));
+        res->status = http_get_status(417);
+        return 3;
     } else {
         ret = 0;
     }
@@ -98,9 +112,9 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
         res->status = http_get_status(502);
         return 2;
     }
-    fastcgi_close_stdin(*fcgi_cnx);
+    fastcgi_close_stdin(fcgi_cnx);
 
-    if ((ret = fastcgi_header(*fcgi_cnx, res, err_msg)) != 0) {
+    if ((ret = fastcgi_header(fcgi_cnx, res, err_msg)) != 0) {
         if (ret == -1) res->status = http_get_status(502);
         return ret;
     }
@@ -117,7 +131,7 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
             res->status = &ctx->custom_status;
         } else if (res->status == NULL) {
             res->status = http_get_status(500);
-            sprintf(err_msg, "The status_hdr code was set to an invalid or unknown value.");
+            sprintf(err_msg, "The status code was set to an invalid or unknown value.");
             return 2;
         }
     }
@@ -131,16 +145,17 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
         content_type != NULL &&
         strstarts(content_type, "text/html") &&
         ctx->content_length != -1 &&
-        ctx->content_length <= sizeof(ctx->msg_content) - 1)
+        ctx->content_length < sizeof(ctx->msg_content))
     {
-        fastcgi_dump(*fcgi_cnx, ctx->msg_content, sizeof(ctx->msg_content));
+        fastcgi_dump(fcgi_cnx, ctx->msg_content, ctx->content_length);
+        ctx->msg_content[ctx->content_length] = 0;
         return 1;
     }
 
     ctx->use_fastcgi = 1;
     ctx->content_length = -1;
 
-    if (http_get_header_field(&res->hdr, "Content-Length") == NULL) {
+    if (content_length_f == NULL) {
         http_add_header_field(&res->hdr, "Transfer-Encoding", "chunked");
     }
 
@@ -148,12 +163,15 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t **fcgi_cnx) {
 }
 
 static void fastcgi_next_cb(chunk_ctx_t *ctx) {
-    if(ctx->client->fcgi_ctx) {
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->client->req_host, CLR_STR, ctx->client->log_prefix);
+
+    if (ctx->client->fcgi_ctx) {
         fastcgi_close(ctx->client->fcgi_ctx);
         ctx->client->fcgi_ctx = NULL;
     }
 
-    fastcgi_handle(ctx->client);
+    request_complete(ctx->client);
+    handle_request(ctx->client);
 }
 
 static void fastcgi_error_cb(chunk_ctx_t *ctx) {
@@ -163,27 +181,19 @@ static void fastcgi_error_cb(chunk_ctx_t *ctx) {
     logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->client->req_host, CLR_STR, ctx->client->log_prefix);
 
     warning("Closing connection due to FastCGI error");
+    errno = 0;
+
     if(ctx->client->fcgi_ctx) {
-        fastcgi_close(ctx->client->fcgi_ctx);
+        fastcgi_close_error(ctx->client->fcgi_ctx);
         ctx->client->fcgi_ctx = NULL;
     }
 
+    request_complete(ctx->client);
     tcp_close(ctx->client);
-
-    errno = 0;
 }
 
-static int fastcgi_handler_2(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
-    int chunked = strcontains(http_get_header_field(&ctx->res.hdr, "Transfer-Encoding"), "chunked");
-
-    if (chunked) {
-        handle_chunks(ctx, &fcgi_cnx->out, SOCK_CHUNKED, fastcgi_next_cb, fastcgi_error_cb);
-        return 1;
-    } else {
-        fastcgi_send(fcgi_cnx, &ctx->socket);
-        fastcgi_close(ctx->fcgi_ctx);
-        ctx->fcgi_ctx = NULL;
-        fastcgi_handle(ctx);
-        return 2;
-    }
+static int fastcgi_handler_2(client_ctx_t *ctx) {
+    const int chunked = strcontains(http_get_header_field(&ctx->res.hdr, "Transfer-Encoding"), "chunked");
+    handle_chunks(ctx, &ctx->fcgi_ctx->cnx.out, chunked ? SOCK_CHUNKED : 0, fastcgi_next_cb, fastcgi_error_cb);
+    return 1;
 }

src/worker/func.h

@@ -17,6 +17,12 @@
 #include "../lib/proxy.h"
 #include "../lib/fastcgi.h"
 
+typedef struct {
+    unsigned char closed:4;
+    char log_prefix[128];
+    fastcgi_cnx_t cnx;
+} fastcgi_ctx_t;
+
 typedef struct {
     sock socket;
     int req_num;
@@ -33,10 +39,10 @@ typedef struct {
     http_status custom_status;
     host_config_t *conf;
     FILE *file;
-    long content_length;
+    long content_length, transferred_length;
     char *msg_buf, *msg_buf_ptr, msg_content[1024];
     proxy_ctx_t *proxy;
-    void *fcgi_ctx;
+    fastcgi_ctx_t *fcgi_ctx;
 } client_ctx_t;
 
 typedef struct {
@@ -45,12 +51,6 @@ typedef struct {
     void *other;
 } ws_ctx_t;
 
-typedef struct {
-    int closed:2;
-    client_ctx_t *client;
-    fastcgi_cnx_t cnx;
-} fastcgi_ctx_t;
-
 typedef struct {
     client_ctx_t *client;
     sock *socket;
@@ -71,6 +71,8 @@ void fastcgi_frame_handler_func(fastcgi_ctx_t *ctx);
 
 void proxy_handler_func(client_ctx_t *ctx);
 
+void proxy_peer_handler_func(proxy_ctx_t *ctx);
+
 void ws_frame_handler_func(ws_ctx_t *ctx);
 
 void chunk_handler_func(chunk_ctx_t *ctx);
@@ -93,4 +95,6 @@ int fastcgi_handle_connection(client_ctx_t *ctx, fastcgi_cnx_t **cnx);
 
 void fastcgi_close(fastcgi_ctx_t *ctx);
 
+void fastcgi_close_error(fastcgi_ctx_t *ctx);
+
 #endif //SESIMOS_FUNC_H

src/worker/local_handler.c

@@ -39,7 +39,7 @@ 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;
+    const char *ptr;
     int mode;
     const char *range = http_get_header_field(&ctx->req.hdr, "Range");
 
@@ -155,97 +155,112 @@ static int local_handler(client_ctx_t *ctx) {
         return 0;
     }
 
-    if (uri->is_static) {
-        res->status = http_get_status(200);
-        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;
-        }
-
-        if (http_get_header_field(&req->hdr, "Content-Length") != NULL || http_get_header_field(&req->hdr, "Transfer-Encoding") != NULL) {
-            res->status = http_get_status(400);
-            sprintf(err_msg, "A GET request must not contain a payload");
-            return 0;
-        }
-
-        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 && 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);
-                    errno = 0;
-                } else {
-                    http_add_header_field(&res->hdr, "Content-Encoding", "br");
-                    enc = COMPRESS_BR;
-                }
-            } 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);
-                    errno = 0;
-                } else {
-                    http_add_header_field(&res->hdr, "Content-Encoding", "gzip");
-                    enc = COMPRESS_GZ;
-                }
-            }
-            if (enc != 0) {
-                http_add_header_field(&res->hdr, "Vary", "Accept-Encoding");
-            }
-        }
-
-        if (uri->meta->etag[0] != 0) {
-            strcpy(buf1, uri->meta->etag);
-            if (enc) {
-                strcat(buf1, "-");
-                strcat(buf1, (enc & COMPRESS_BR) ? "br" : (enc & COMPRESS_GZ) ? "gzip" : "");
-            }
-            http_add_header_field(&res->hdr, "ETag", buf1);
-        }
-
-        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 && !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;
-        }
-
-        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);
-                res->status = http_get_status(416);
-            }
-            return 0;
-        }
-
-        if (ctx->file == NULL) ctx->file = fopen(uri->filename, "rb");
-        ctx->content_length = fsize(ctx->file);
-    } else {
+    if (!uri->is_static) {
         return 1;
     }
 
+    const char *client_expect = http_get_header_field(&req->hdr, "Expect");
+    if (client_expect != NULL && strcasecmp(client_expect, "100-continue") != 0) {
+        res->status = http_get_status(417);
+        return 0;
+    }
+
+    cache_init_uri(ctx->conf->cache, uri);
+    if (uri->meta == NULL) {
+        res->status = http_get_status(500);
+        sprintf(err_msg, "Could not load metadata of file because all cache entry slots are occupied.");
+        return 0;
+    }
+
+    res->status = http_get_status(200);
+    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;
+    }
+
+    if (http_get_header_field(&req->hdr, "Content-Length") != NULL || http_get_header_field(&req->hdr, "Transfer-Encoding") != NULL) {
+        res->status = http_get_status(400);
+        sprintf(err_msg, "A GET request must not contain a payload");
+        return 0;
+    }
+
+    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 && 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);
+                errno = 0;
+            } else {
+                http_add_header_field(&res->hdr, "Content-Encoding", "br");
+                enc = COMPRESS_BR;
+            }
+        } 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);
+                errno = 0;
+            } else {
+                http_add_header_field(&res->hdr, "Content-Encoding", "gzip");
+                enc = COMPRESS_GZ;
+            }
+        }
+    }
+    if (uri->meta->filename_comp_br[0] != 0 || uri->meta->filename_comp_gz[0] != 0) {
+        http_add_header_field(&res->hdr, "Vary", "Accept-Encoding");
+    }
+
+    buf1[0] = 0;
+    if (uri->meta->etag[0] != 0) {
+        buf1[0] = '"';
+        strcpy(buf1 + 1, uri->meta->etag);
+        if (enc) {
+            strcat(buf1, "-");
+            strcat(buf1, (enc & COMPRESS_BR) ? "br" : (enc & COMPRESS_GZ) ? "gzip" : "");
+        }
+        strcat(buf1, "\"");
+        http_add_header_field(&res->hdr, "ETag", buf1);
+    }
+
+    http_add_header_field(&res->hdr, "Cache-Control", mime_is_text(uri->meta->type) ? "public, must-revalidate, max-age=3600" : "public, must-revalidate, 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 && strcontains(if_none_match, buf1)) ||
+        (accept_if_modified_since && streq(if_modified_since, last_modified)))
+    {
+        res->status = http_get_status(304);
+        ctx->content_length = 0;
+        return 0;
+    }
+
+    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);
+            res->status = http_get_status(416);
+        }
+        return 0;
+    }
+
+    if (ctx->file == NULL) ctx->file = fopen(uri->filename, "rb");
+    ctx->content_length = fsize(ctx->file);
+
     return 0;
 }

src/worker/proxy_handler.c

@@ -1,7 +1,7 @@
 /**
  * sesimos - secure, simple, modern web server
  * @brief Proxy handler
- * @file src/worker/proxy_handler_1.c
+ * @file src/worker/proxy_handler.c
  * @author Lorenz Stechauner
  * @date 2022-12-29
  */
@@ -27,23 +27,28 @@ void proxy_handler_func(client_ctx_t *ctx) {
     respond(ctx);
 
     if (ret == 1) {
-        proxy_unlock_ctx(ctx->proxy);
-        ctx->proxy = NULL;
+        // error status code
+        if (proxy_unlock_ctx(ctx->proxy) == 1)
+            proxy_peer_handle(ctx->proxy);
     } else if (ctx->use_proxy == 0) {
+        // proxy not used
         proxy_close(ctx->proxy);
+        proxy_unlock_ctx(ctx->proxy);
     } else if (ctx->use_proxy == 1) {
+        // proxy is used
         if (proxy_handler_2(ctx) == 1) {
             // chunked
             return;
         }
-        proxy_unlock_ctx(ctx->proxy);
-        ctx->proxy = NULL;
+        if (proxy_unlock_ctx(ctx->proxy) == 1)
+            proxy_peer_handle(ctx->proxy);
     } else if (ctx->use_proxy == 2) {
         // WebSocket
         ws_handle_connection(ctx);
         return;
     }
 
+    ctx->proxy = NULL;
     request_complete(ctx);
     handle_request(ctx);
 }
@@ -61,6 +66,9 @@ static int proxy_handler_1(client_ctx_t *ctx) {
     ctx->use_proxy = proxy_init(&ctx->proxy, &ctx->req, res, status, ctx->conf, &ctx->socket, &ctx->custom_status, ctx->err_msg) == 0;
     ctx->proxy->client = ctx;
 
+    if (ctx->use_proxy == 0)
+        return 0;
+
     if (res->status->code == 101) {
         const char *connection = http_get_header_field(&res->hdr, "Connection");
         const char *upgrade = http_get_header_field(&res->hdr, "Upgrade");
@@ -84,7 +92,8 @@ static int proxy_handler_1(client_ctx_t *ctx) {
         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 && (
+        const char *transfer_encoding = http_get_header_field(&res->hdr, "Transfer-Encoding");
+        if (transfer_encoding == NULL && content_encoding == NULL && (
                 content_length_f == NULL ||
                 streq(content_length_f, "0") ||
                 (content_length_f != NULL && strstarts(content_type, "text/html"))))
@@ -109,34 +118,44 @@ static int proxy_handler_1(client_ctx_t *ctx) {
 }
 
 static void proxy_chunk_next_cb(chunk_ctx_t *ctx) {
-    proxy_unlock_ctx(ctx->client->proxy);
-    ctx->client->proxy = NULL;
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->client->req_host, CLR_STR, ctx->client->log_prefix);
+    if (proxy_unlock_ctx(ctx->client->proxy) == 1)
+        proxy_peer_handle(ctx->client->proxy);
 
+    ctx->client->proxy = NULL;
     request_complete(ctx->client);
     handle_request(ctx->client);
 }
 
 static void proxy_chunk_err_cb(chunk_ctx_t *ctx) {
-    ctx->client->c_keep_alive = 0;
-    proxy_chunk_next_cb(ctx);
+    logger_set_prefix("[%s%*s%s]%s", BLD_STR, ADDRSTRLEN, ctx->client->req_host, CLR_STR, ctx->client->log_prefix);
+
+    proxy_close(ctx->client->proxy);
+    proxy_unlock_ctx(ctx->client->proxy);
+
+    ctx->client->proxy = NULL;
+    request_complete(ctx->client);
+    tcp_close(ctx->client);
 }
 
 static int proxy_handler_2(client_ctx_t *ctx) {
     const char *transfer_encoding = http_get_header_field(&ctx->res.hdr, "Transfer-Encoding");
-    int chunked = strcontains(transfer_encoding, "chunked");
+    const int chunked = strcontains(transfer_encoding, "chunked");
 
     const char *content_len = http_get_header_field(&ctx->res.hdr, "Content-Length");
-    unsigned long len_to_send = (content_len != NULL) ? strtol(content_len, NULL, 10) : 0;
+    const unsigned long len_to_send = (content_len != NULL) ? strtol(content_len, NULL, 10) : 0;
 
     if (chunked) {
         handle_chunks(ctx, &ctx->proxy->proxy, SOCK_CHUNKED, proxy_chunk_next_cb, proxy_chunk_err_cb);
         return 1;
     }
 
-    int ret;
+    long ret;
     if ((ret = proxy_send(ctx->proxy, &ctx->socket, len_to_send, 0)) == -1) {
         ctx->c_keep_alive = 0;
+    } else if (ret > 0) {
+        ctx->transferred_length += ret;
     }
 
-    return ret;
+    return ret >= 0 ? 0 : ret;
 }

src/worker/proxy_peer_handler.c

@@ -0,0 +1,17 @@
+/**
+ * sesimos - secure, simple, modern web server
+ * @brief Proxy peer handler
+ * @file src/worker/proxy_peer_handler.c
+ * @author Lorenz Stechauner
+ * @date 2023-07-07
+ */
+
+#include "func.h"
+#include "../logger.h"
+#include "../lib/utils.h"
+
+void proxy_peer_handler_func(proxy_ctx_t *ctx) {
+    if (!ctx->initialized || ctx->in_use) return;
+    logger_set_prefix("[%s%*s%s]", BLD_STR, ADDRSTRLEN, ctx->host, CLR_STR);
+    proxy_close(ctx);
+}

src/worker/request_handler.c

@@ -59,6 +59,8 @@ static void init_ctx(client_ctx_t *ctx) {
     ctx->req_host[0] = 0;
     ctx->err_msg[0] = 0;
     ctx->req_s = ctx->socket.ts_last;
+    ctx->transferred_length = 0;
+    ctx->content_length = 0;
 
     memset(&ctx->uri, 0, sizeof(ctx->uri));
     memset(&ctx->req, 0, sizeof(ctx->req));
@@ -249,15 +251,15 @@ int respond(client_ctx_t *ctx) {
         if (http_get_header_field(&res->hdr, "Accept-Ranges") == NULL) {
             http_add_header_field(&res->hdr, "Accept-Ranges", "none");
         }
-        if (!ctx->use_fastcgi && ctx->file == NULL && ctx->msg_buf == NULL) {
+        if (!ctx->use_fastcgi && ctx->file == NULL && ctx->msg_buf == NULL && res->status->code != 304) {
             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");
+            if (http_get_header_field(&res->hdr, "Cache-Control") == NULL)
+                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
@@ -373,10 +375,48 @@ int respond(client_ctx_t *ctx) {
 }
 
 void request_complete(client_ctx_t *ctx) {
-    char buf[32];
+    char buf[64];
     ctx->req_e = clock_micros();
     info("Transfer complete: %s", format_duration(ctx->req_e - ctx->req_s, buf));
 
+    if (ctx->conf) {
+        char path[256];
+        sprintf(path, "/var/log/sesimos/%s.access.log", ctx->req_host);
+        FILE *log = fopen(path, "a");
+        if (log) {
+            struct timespec time1, time2;
+            clock_gettime(CLOCK_MONOTONIC, &time1);
+            clock_gettime(CLOCK_REALTIME, &time2);
+            const long diff = (time2.tv_sec - time1.tv_sec) * 1000000 + (time2.tv_nsec - time1.tv_nsec) / 1000;
+            struct tm time_info;
+            const long ts = (ctx->req_s + diff) / 1000000;
+            strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S%z", localtime_r(&ts, &time_info));
+
+            const char *auth = http_get_header_field(&ctx->req.hdr, "Authorization");
+            char user[256] = {0};
+            if (auth != NULL && strstarts(auth, "Basic ")) {
+                base64_decode(auth + 6, strlen(auth) - 6, user, NULL);
+                char *col = strchr(user, ':');
+                if (col != NULL) col[0] = 0;
+            }
+            const char *ref = http_get_header_field(&ctx->req.hdr, "Referer");
+            const char *ua = http_get_header_field(&ctx->req.hdr, "User-Agent");
+            const char *loc = http_get_header_field(&ctx->res.hdr, "Location");
+            const char *type = http_get_header_field(&ctx->res.hdr, "Content-Type");
+            const long len = ctx->content_length <= 0 ? ctx->transferred_length : ctx->content_length;
+
+            fprintf(log, "%s %s %s [%s] \"%s %s HTTP/%s\" %i %li %s%s%s %s%s%s %s%s%s %s%s%s\n",
+                ctx->socket.addr, "-", user[0] != 0 ? user : "-", buf,
+                ctx->req.method, ctx->req.uri, ctx->req.version, ctx->res.status->code, len,
+                loc != NULL ? "\"" : "", loc != NULL ? loc : "-", loc != NULL ? "\"" : "",
+                type != NULL ? "\"" : "", type != NULL ? type : "-", type != NULL ? "\"" : "",
+                ref != NULL ? "\"" : "", ref != NULL ? ref : "-", ref != NULL ? "\"" : "",
+                ua != NULL ? "\"" : "", ua != NULL ? ua : "-", ua != NULL ? "\"" : "");
+            fclose(log);
+        }
+        errno = 0;
+    }
+
     if (ctx->file) fclose(ctx->file);
     free(ctx->msg_buf_ptr);
     uri_free(&ctx->uri);
@@ -392,5 +432,6 @@ void timeout_request(client_ctx_t *ctx) {
     ctx->res.status = http_get_status(408);
 
     respond(ctx);
+    request_complete(ctx);
     tcp_close(ctx);
 }

src/worker/tcp_acceptor.c

@@ -67,7 +67,7 @@ static int tcp_acceptor(client_ctx_t *ctx) {
          ctx->host[0] != 0 ? ctx->host : "", ctx->host[0] != 0 ? ") " : "",
          ctx->cc[0] != 0 ? ctx->cc : "N/A");
 
-    if (sock_set_socket_timeout(client, 1) != 0 || sock_set_timeout(client, CLIENT_TIMEOUT) != 0) {
+    if (sock_set_socket_timeout(client, SOCKET_TIMEOUT) != 0 || sock_set_timeout(client, CLIENT_TIMEOUT) != 0) {
         error("Unable to set timeout for socket");
         return -1;
     }
@@ -84,6 +84,7 @@ static int tcp_acceptor(client_ctx_t *ctx) {
             return -1;
         }
         client->ts_last = clock_micros();
+        client->ts_last_send = client->ts_last;
     }
 
     ctx->req_num = 0;

src/worker/ws_frame_handler.c

@@ -11,8 +11,10 @@
 #include "../logger.h"
 #include "../lib/websocket.h"
 #include "../workers.h"
+#include "../lib/utils.h"
 
 #include <errno.h>
+#include <string.h>
 
 static int ws_frame_handler(ws_ctx_t *ctx);
 
@@ -32,15 +34,25 @@ void ws_frame_handler_func(ws_ctx_t *ctx) {
 
 int ws_handle_connection(client_ctx_t *ctx) {
     info("Upgrading to WebSocket connection");
+
+    // copy proxy connection details
+    proxy_ctx_t *proxy = malloc(sizeof(proxy_ctx_t));
+    memcpy(proxy, ctx->proxy, sizeof(proxy_ctx_t));
+
+    // free proxy connection slot
+    ctx->proxy->initialized = 0;
+    proxy_unlock_ctx(ctx->proxy);
+    ctx->proxy = proxy;
+
     sock_set_timeout(&ctx->socket, WS_TIMEOUT);
-    sock_set_timeout(&ctx->proxy->proxy, WS_TIMEOUT);
+    sock_set_timeout(&proxy->proxy, WS_TIMEOUT);
 
     ws_ctx_t *a = malloc(sizeof(ws_ctx_t));
     ws_ctx_t *b = malloc(sizeof(ws_ctx_t));
 
     a->other = b,             b->other = a;
     a->client = ctx,          b->client = ctx;
-    a->socket = &ctx->socket, b->socket = &ctx->proxy->proxy;
+    a->socket = &ctx->socket, b->socket = &proxy->proxy;
 
     ws_handle_frame(a);
     ws_handle_frame(b);
@@ -84,10 +96,16 @@ static int ws_frame_handler(ws_ctx_t *ctx) {
 void ws_close(ws_ctx_t *ctx) {
     ws_ctx_t *other = ctx->other;
     if (other) {
+        proxy_ctx_t *proxy = ctx->client->proxy;
         other->other = NULL;
         logger_set_prefix("[%*s]%s", ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
-        info("Closing WebSocket connection");
-        proxy_close(ctx->client->proxy);
+
+        proxy->cnx_e = clock_micros();
+        char buf[32];
+        info("Closing WebSocket connection (%s)", format_duration(proxy->cnx_e - proxy->cnx_s, buf));
+
+        sock_close(&proxy->proxy);
+        free(ctx->client->proxy);
         tcp_close(ctx->client);
     }
     free(ctx);

src/workers.c

@@ -13,18 +13,29 @@
 #include "async.h"
 
 static mpmc_t tcp_acceptor_ctx, request_handler_ctx, local_handler_ctx, fastcgi_handler_ctx, proxy_handler_ctx,
-              ws_frame_handler_ctx, chunk_handler_ctx, fastcgi_frame_handler_ctx;
+              proxy_peer_handler_ctx, ws_frame_handler_ctx, chunk_handler_ctx, fastcgi_frame_handler_ctx;
 
 int workers_init(void) {
-    mpmc_init(&tcp_acceptor_ctx,          8, 64, (void (*)(void *)) tcp_acceptor_func,          "tcp");
-    mpmc_init(&request_handler_ctx,       8, 64, (void (*)(void *)) request_handler_func,       "req");
-    mpmc_init(&local_handler_ctx,         8, 64, (void (*)(void *)) local_handler_func,         "local");
-    mpmc_init(&fastcgi_handler_ctx,       8, 64, (void (*)(void *)) fastcgi_handler_func,       "fcgi");
-    mpmc_init(&proxy_handler_ctx,         8, 64, (void (*)(void *)) proxy_handler_func,         "proxy");
-    mpmc_init(&ws_frame_handler_ctx,      8, 64, (void (*)(void *)) ws_frame_handler_func,      "ws");
-    mpmc_init(&chunk_handler_ctx,         8, 64, (void (*)(void *)) chunk_handler_func,         "chunk");
-    mpmc_init(&fastcgi_frame_handler_ctx, 8, 64, (void (*)(void *)) fastcgi_frame_handler_func, "fcgi_f");
-    return -1;
+    int ret;
+    if ((ret = mpmc_init(&tcp_acceptor_ctx,          8, 64, (void (*)(void *)) tcp_acceptor_func,          "tcp")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&request_handler_ctx,       8, 64, (void (*)(void *)) request_handler_func,       "req")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&local_handler_ctx,         8, 64, (void (*)(void *)) local_handler_func,         "local")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&fastcgi_handler_ctx,       8, 64, (void (*)(void *)) fastcgi_handler_func,       "fcgi")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&proxy_handler_ctx,         8, 64, (void (*)(void *)) proxy_handler_func,         "proxy")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&proxy_peer_handler_ctx,    1,  8, (void (*)(void *)) proxy_peer_handler_func,    "prxy_p")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&ws_frame_handler_ctx,      8, 64, (void (*)(void *)) ws_frame_handler_func,      "ws")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&chunk_handler_ctx,         8, 64, (void (*)(void *)) chunk_handler_func,         "chunk")) != 0)
+        return ret;
+    if ((ret = mpmc_init(&fastcgi_frame_handler_ctx, 8, 64, (void (*)(void *)) fastcgi_frame_handler_func, "fcgi_f")) != 0)
+        return ret;
+    return 0;
 }
 
 void workers_stop(void) {
@@ -32,6 +43,7 @@ void workers_stop(void) {
     mpmc_stop(&local_handler_ctx);
     mpmc_stop(&fastcgi_handler_ctx);
     mpmc_stop(&proxy_handler_ctx);
+    mpmc_stop(&proxy_peer_handler_ctx);
     mpmc_stop(&request_handler_ctx);
     mpmc_stop(&ws_frame_handler_ctx);
     mpmc_stop(&chunk_handler_ctx);
@@ -43,6 +55,7 @@ void workers_destroy(void) {
     mpmc_destroy(&local_handler_ctx);
     mpmc_destroy(&fastcgi_handler_ctx);
     mpmc_destroy(&proxy_handler_ctx);
+    mpmc_destroy(&proxy_peer_handler_ctx);
     mpmc_destroy(&request_handler_ctx);
     mpmc_destroy(&ws_frame_handler_ctx);
     mpmc_destroy(&chunk_handler_ctx);
@@ -92,6 +105,17 @@ int proxy_handle(client_ctx_t *ctx) {
     return mpmc_queue(&proxy_handler_ctx, ctx);
 }
 
+static int proxy_peer_handle_cb(proxy_ctx_t *ctx) {
+    return mpmc_queue(&proxy_peer_handler_ctx, ctx);
+}
+
+int proxy_peer_handle(proxy_ctx_t *ctx) {
+    return async(&ctx->proxy, ASYNC_WAIT_READ, ASYNC_IGNORE_PENDING, ctx,
+                 (void (*)(void *)) proxy_peer_handle_cb,
+                 (void (*)(void *)) proxy_peer_handle_cb,
+                 (void (*)(void *)) proxy_peer_handle_cb);
+}
+
 static int ws_handle_frame_cb(ws_ctx_t *ctx) {
     return mpmc_queue(&ws_frame_handler_ctx, ctx);
 }

src/workers.h

@@ -29,6 +29,8 @@ int fastcgi_handle_frame(fastcgi_ctx_t *ctx);
 
 int proxy_handle(client_ctx_t *ctx);
 
+int proxy_peer_handle(proxy_ctx_t *ctx);
+
 int ws_handle_frame(ws_ctx_t *ctx);
 
 int handle_chunk(chunk_ctx_t *ctx);