lorenz.stechauner/sesimos
1
1
Fork 0
Code Issues Pull Requests Projects Releases Activity

Compare commits

base: lorenz.stechauner:c7be0adc660975357f1bab88b607bdfbcf870728
Branches Tags
lorenz.stechauner:master lorenz.stechauner:stable-4 lorenz.stechauner:dev
lorenz.stechauner:v4.6 lorenz.stechauner:v4.5 lorenz.stechauner:v4.4 lorenz.stechauner:v4.3 lorenz.stechauner:v4.2 lorenz.stechauner:v4.1 lorenz.stechauner:v4.0 lorenz.stechauner:v3.0
..
compare: lorenz.stechauner:stable-4
Branches Tags
lorenz.stechauner:master lorenz.stechauner:stable-4 lorenz.stechauner:dev
lorenz.stechauner:v4.6 lorenz.stechauner:v4.5 lorenz.stechauner:v4.4 lorenz.stechauner:v4.3 lorenz.stechauner:v4.2 lorenz.stechauner:v4.1 lorenz.stechauner:v4.0 lorenz.stechauner:v3.0

1 Commits
c7be0adc66 ... stable-4

Author SHA1 Message Date
Lorenz Stechauner
081af44eba Update php version in Makefile 2023-07-01 18:45:45 +02:00
62 changed files with 2563 additions and 4152 deletions
Expand all files Collapse all files

4
.gitignore vendored
View File

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

76
Makefile
View File

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

22
architecture.md
View File

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

22
res/default.html
View File

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

3
res/globe.svg
View File

@@ -1,3 +0,0 @@
<svg width="64" height="64" xmlns="http://www.w3.org/2000/svg">
<path d="M2,32 a30,30,0,1,0,60,0 a30,30,0,1,0,-60,0 L62,32 M6,16 L58,16 M6,48 L58,48 M32,2 L32,62 a15,30,0,1,0,0,-60 a15,30,0,1,0,0,60 Z" stroke="#008000" stroke-width="2" fill="#00000000"/>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 266 B

3
res/icon_error.svg
View File

@@ -1,3 +0,0 @@
<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg">
<text x="4" y="12" fill="#C00000" style="font-family:'Arial',sans-serif">:(</text>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 158 B

3
res/icon_info.svg
View File

@@ -1,3 +0,0 @@
<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg">
<text x="4" y="12" fill="#606060" style="font-family:'Arial',sans-serif">:)</text>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 158 B

3
res/icon_success.svg
View File

@@ -1,3 +0,0 @@
<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg">
<text x="4" y="12" fill="#008000" style="font-family:'Arial',sans-serif">:)</text>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 158 B

3
res/icon_warning.svg
View File

@@ -1,3 +0,0 @@
<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg">
<text x="4" y="12" fill="#E0C000" style="font-family:'Arial',sans-serif">:)</text>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 158 B

31
res/proxy.html
View File

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

66
res/style.css
View File

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

288
src/async.c
View File

@@ -1,288 +0,0 @@
/**
* Sesimos - secure, simple, modern web server
* @brief Async handler
* @file src/async.c
* @author Lorenz Stechauner
* @date 2022-12-28
*/
#include "async.h"
#include "logger.h"
#include "lib/list.h"
#include <poll.h>
#include <sys/epoll.h>
#include <signal.h>
#include <errno.h>
#include <memory.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#define ASYNC_MAX_EVENTS 16
typedef struct {
int fd;
sock *socket;
async_evt_t events;
int flags;
void *arg;
void (*cb)(void *);
void (*err_cb)(void *);
} evt_listen_t;
typedef struct {
int n;
evt_listen_t *q[ASYNC_MAX_EVENTS];
} listen_queue_t;
static listen_queue_t listen1, listen2, *listen_q = &listen1;
static volatile sig_atomic_t alive = 1;
static pthread_t thread = -1;
static sem_t lock;
static int epoll_fd;
static short async_a2p(async_evt_t events) {
short ret = 0;
if (events & ASYNC_IN) ret |= POLLIN;
if (events & ASYNC_PRI) ret |= POLLPRI;
if (events & ASYNC_OUT) ret |= POLLOUT;
return ret;
}
static unsigned int async_a2e(async_evt_t events) {
unsigned int ret = 0;
if (events & ASYNC_IN) ret |= EPOLLIN;
if (events & ASYNC_PRI) ret |= EPOLLPRI;
if (events & ASYNC_OUT) ret |= EPOLLOUT;
return ret;
}
static async_evt_t async_p2a(short events) {
async_evt_t ret = 0;
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 & POLLHUP) ret |= ASYNC_HUP;
return ret;
}
static async_evt_t async_e2a(unsigned int events) {
async_evt_t ret = 0;
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 & EPOLLHUP) ret |= ASYNC_HUP;
return ret;
}
static int async_add_to_queue(evt_listen_t *evt) {
try_again:
if (sem_wait(&lock) != 0) {
if (errno == EINTR) {
goto try_again;
} else {
return -1;
}
}
evt_listen_t *ptr = malloc(sizeof(evt_listen_t));
if (ptr == NULL) {
sem_post(&lock);
return -1;
}
memcpy(ptr, evt, sizeof(*evt));
listen_q->q[listen_q->n++] = ptr;
sem_post(&lock);
return 0;
}
static int async_exec(evt_listen_t *evt, async_evt_t r_events) {
int ret, e = errno;
if (r_events & evt->events) {
// specified event(s) occurred
if (evt->socket && !sock_has_pending(evt->socket)) {
evt->err_cb(evt->arg);
ret = 0;
} else {
evt->cb(evt->arg);
ret = (evt->flags & ASYNC_KEEP) ? 1 : 0;
}
} else if (r_events & (POLLERR | POLLHUP | POLLNVAL)) {
// error occurred
evt->err_cb(evt->arg);
ret = 0;
} else {
// no event occurred
ret = -1;
}
logger_set_prefix("");
errno = e;
return ret;
}
static int async_check(evt_listen_t *evt) {
struct pollfd fds[1] = {{
.fd = evt->fd,
.events = async_a2p(evt->events)
}};
// check, if fd is already ready
if (poll(fds, 1, 0) == 1) {
// fd already ready
if (async_exec(evt, async_p2a(fds[0].revents)) == 0)
return 1;
}
return 0;
}
static int async_add(evt_listen_t *evt) {
if (async_check(evt) == 1)
return 0;
int ret = async_add_to_queue(evt);
if (ret == 0 && thread != -1)
pthread_kill(thread, SIGUSR1);
return ret;
}
int async_fd(int fd, async_evt_t events, int flags, void *arg, void cb(void *), void err_cb(void *)) {
evt_listen_t evt = {
.fd = fd,
.socket = NULL,
.events = events,
.flags = flags,
.arg = arg,
.cb = cb,
.err_cb = err_cb,
};
return async_add(&evt);
}
int async(sock *s, async_evt_t events, int flags, void *arg, void cb(void *), void err_cb(void *)) {
evt_listen_t evt = {
.fd = s->socket,
.socket = s,
.events = events,
.flags = flags,
.arg = arg,
.cb = cb,
.err_cb = err_cb,
};
return async_add(&evt);
}
int async_init(void) {
if (sem_init(&lock, 0, 1) != 0) {
return -1;
}
listen1.n = 0;
listen2.n = 0;
if ((epoll_fd = epoll_create1(0)) == -1) {
async_free();
return -1;
}
return 0;
}
void async_free(void) {
int e = errno;
sem_destroy(&lock);
close(epoll_fd);
errno = e;
}
void async_thread(void) {
struct epoll_event ev, events[ASYNC_MAX_EVENTS];
int num_fds;
evt_listen_t **local = list_create(sizeof(evt_listen_t *), 16);
if (local == NULL) {
critical("Unable to create async local list");
return;
}
thread = pthread_self();
// main event loop
while (alive) {
// swap listen queue
listen_queue_t *l = listen_q;
listen_q = (listen_q == &listen1) ? &listen2 : &listen1;
// fill local list and epoll instance with previously added queue entries
for (int i = 0; i < l->n; i++) {
evt_listen_t *evt = l->q[i];
local = list_append(local, &evt);
if (local == NULL) {
critical("Unable to resize async local list");
return;
}
ev.events = async_a2e(evt->events);
ev.data.ptr = evt;
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, evt->fd, &ev) == -1) {
critical("Unable to add file descriptor to epoll instance");
return;
}
}
// reset size of queue
l->n = 0;
if ((num_fds = epoll_wait(epoll_fd, events, ASYNC_MAX_EVENTS, -1)) == -1) {
if (errno == EINTR) {
// interrupt
errno = 0;
continue;
} else {
// other error
critical("Unable to poll for events");
return;
}
}
for (int i = 0; i < num_fds; i++) {
evt_listen_t *evt = events[i].data.ptr;
if (async_exec(evt, async_e2a(events[i].events)) == 0) {
if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, evt->fd, NULL) == -1) {
if (errno == EBADF) {
// already closed fd, do not die
errno = 0;
} else {
critical("Unable to remove file descriptor from epoll instance");
return;
}
}
local = list_delete(local, &evt);
if (local == NULL) {
critical("Unable to resize async local list");
return;
}
free(evt);
}
}
}
// cleanup
for (int i = 0; i < list_size(local); i++) {
free(local[i]);
}
list_free(local);
}
void async_stop(void) {
alive = 0;
}

39
src/async.h
View File

@@ -1,39 +0,0 @@
/**
* Sesimos - secure, simple, modern web server
* @brief Async handler (header file)
* @file src/async.h
* @author Lorenz Stechauner
* @date 2022-12-28
*/
#ifndef SESIMOS_ASYNC_H
#define SESIMOS_ASYNC_H
#include "lib/sock.h"
#define ASYNC_KEEP 1
#define ASYNC_IN 0x01
#define ASYNC_PRI 0x02
#define ASYNC_OUT 0x04
#define ASYNC_ERR 0x08
#define ASYNC_HUP 0x10
#define ASYNC_WAIT_READ ASYNC_IN
#define ASYNC_WAIT_WRITE ASYNC_OUT
typedef unsigned int async_evt_t;
int async(sock *s, async_evt_t events, int flags, void *arg, void cb(void *), void err_cb(void *));
int async_fd(int fd, async_evt_t events, int flags, void *arg, void cb(void *), void err_cb(void *));
int async_init(void);
void async_free(void);
void async_thread(void);
void async_stop(void);
#endif //SESIMOS_ASYNC_H

397
src/cache_handler.c
View File

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

46
src/cache_handler.h
View File

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

916
src/client.c Normal file
View File

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

21
src/client.h Normal file
View File

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

7
src/defs.h
View File

@@ -9,12 +9,11 @@
#ifndef SESIMOS_DEF_H #ifndef SESIMOS_DEF_H
#define SESIMOS_DEF_H #define SESIMOS_DEF_H
#define SERVER_VERSION "5.0-wip" #define SERVER_VERSION "4.6"
#define SERVER_STR "sesimos/" SERVER_VERSION #define SERVER_STR "Sesimos/" SERVER_VERSION
#define SERVER_STR_HTML "sesimos&nbsp;web&nbsp;server&nbsp;" SERVER_VERSION #define SERVER_STR_HTML "Sesimos&nbsp;web&nbsp;server&nbsp;" SERVER_VERSION
#define CHUNK_SIZE 8192 #define CHUNK_SIZE 8192
#define MAX_PROXY_CNX_PER_HOST 16
#ifndef DEFAULT_HOST #ifndef DEFAULT_HOST
# define DEFAULT_HOST "www.necronda.net" # define DEFAULT_HOST "www.necronda.net"

394
src/lib/cache.c Normal file
View File

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

50
src/lib/cache.h Normal file
View File

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

30
src/lib/compress.c
View File

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

8
src/lib/compress.h
View File

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

144
src/lib/config.c
View File

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

24
src/lib/config.h
View File

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

128
src/lib/fastcgi.c
View File

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

21
src/lib/fastcgi.h
View File

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

143
src/lib/geoip.c
View File

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

9
src/lib/geoip.h
View File

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

170
src/lib/http.c
View File

@@ -6,11 +6,9 @@
* @date 2020-12-09 * @date 2020-12-09
*/ */
#include "../logger.h"
#include "http.h" #include "http.h"
#include "utils.h" #include "utils.h"
#include "compress.h" #include "compress.h"
#include "list.h"
#include <string.h> #include <string.h>
@@ -70,10 +68,10 @@ void http_free_field(http_field *f) {
} }
void http_free_hdr(http_hdr *hdr) { void http_free_hdr(http_hdr *hdr) {
for (int i = 0; i < list_size(hdr->fields); i++) { for (int i = 0; i < hdr->field_num; i++) {
http_free_field(&hdr->fields[i]); http_free_field(&hdr->fields[i]);
} }
list_free(hdr->fields); hdr->field_num = 0;
hdr->last_field_num = -1; hdr->last_field_num = -1;
} }
@@ -87,24 +85,16 @@ void http_free_res(http_res *res) {
http_free_hdr(&res->hdr); http_free_hdr(&res->hdr);
} }
int http_init_hdr(http_hdr *hdr) {
hdr->fields = list_create(sizeof(http_field), HTTP_INIT_HEADER_FIELD_NUM);
if (hdr->fields == NULL)
return -1;
return 0;
}
int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags) { int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags) {
if (hdr->last_field_num > list_size(hdr->fields)) { if (hdr->last_field_num > hdr->field_num) {
error("Unable to parse header: Invalid state"); print(ERR_STR "Unable to parse header: Invalid state" CLR_STR);
return 3; return 3;
} }
char *pos1 = (char *) buf, *pos2 = (char *) end_ptr; char *pos1 = (char *) buf, *pos2 = (char *) end_ptr;
if (buf[0] == ' ' || buf[0] == '\t') { if (buf[0] == ' ' || buf[0] == '\t') {
if (hdr->last_field_num == -1) { if (hdr->last_field_num == -1) {
error("Unable to parse header"); print(ERR_STR "Unable to parse header" CLR_STR);
return 3; return 3;
} }
http_field *f = &hdr->fields[(int) hdr->last_field_num]; http_field *f = &hdr->fields[(int) hdr->last_field_num];
@@ -117,7 +107,7 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,
pos1 = memchr(buf, ':', end_ptr - buf); pos1 = memchr(buf, ':', end_ptr - buf);
if (pos1 == NULL) { if (pos1 == NULL) {
error("Unable to parse header"); print(ERR_STR "Unable to parse header" CLR_STR);
return 3; return 3;
} }
long len1 = pos1 - buf; long len1 = pos1 - buf;
@@ -126,37 +116,53 @@ int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr,
str_trim_lws(&pos1, &pos2); str_trim_lws(&pos1, &pos2);
long len2 = pos2 - pos1; long len2 = pos2 - pos1;
int field_num = list_size(hdr->fields); char field_num = hdr->field_num;
int found = http_get_header_field_num_len(hdr, buf, len1); int found = http_get_header_field_num_len(hdr, buf, len1);
if (!(flags & HTTP_MERGE_FIELDS) || found == -1) { if (!(flags & HTTP_MERGE_FIELDS) || found == -1) {
if (http_add_header_field_len(hdr, buf, len1, pos1, len2 < 0 ? 0 : len2) != 0) { if (http_add_header_field_len(hdr, buf, len1, pos1, len2 < 0 ? 0 : len2) != 0) {
error("Unable to parse header: Too many header fields"); print(ERR_STR "Unable to parse header: Too many header fields" CLR_STR);
return 3; return 3;
} }
} else { } else {
field_num = found; field_num = (char) found;
http_append_to_header_field(&hdr->fields[found], ", ", 2); http_append_to_header_field(&hdr->fields[found], ", ", 2);
http_append_to_header_field(&hdr->fields[found], pos1, len2); http_append_to_header_field(&hdr->fields[found], pos1, len2);
} }
hdr->last_field_num = field_num; hdr->last_field_num = (char) field_num;
return 0; return 0;
} }
int http_parse_request(char *buf, http_req *req) { int http_receive_request(sock *client, http_req *req) {
long rcv_len, len;
char buf[CLIENT_MAX_HEADER_SIZE];
char *ptr, *pos0 = buf, *pos1, *pos2; char *ptr, *pos0 = buf, *pos1, *pos2;
long len; memset(buf, 0, sizeof(buf));
memset(req->method, 0, sizeof(req->method));
memset(req->version, 0, sizeof(req->version));
req->uri = NULL;
req->hdr.field_num = 0;
req->hdr.last_field_num = -1;
while (1) {
rcv_len = sock_recv(client, buf, CLIENT_MAX_HEADER_SIZE, MSG_PEEK);
if (rcv_len <= 0) {
print("Unable to receive http header: %s", sock_strerror(client));
return -1;
}
unsigned long header_len = strstr(buf, "\r\n\r\n") - buf + 4; unsigned long header_len = strstr(buf, "\r\n\r\n") - buf + 4;
if (header_len <= 0) { if (header_len <= 0) {
error("Unable to parse http header: End of header not found"); print(ERR_STR "Unable to parse http header: End of header not found" CLR_STR);
return -5; return 5;
} else {
rcv_len = sock_recv(client, buf, header_len, 0);
} }
for (int i = 0; i < header_len; i++) { for (int i = 0; i < header_len; i++) {
if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) { if ((buf[i] >= 0x00 && buf[i] <= 0x1F && buf[i] != '\r' && buf[i] != '\n') || buf[i] == 0x7F) {
error("Unable to parse http header: Header contains illegal characters"); print(ERR_STR "Unable to parse http header: Header contains illegal characters" CLR_STR);
return -4; return 4;
} }
} }
@@ -164,37 +170,37 @@ int http_parse_request(char *buf, http_req *req) {
while (header_len > (ptr - buf + 2)) { while (header_len > (ptr - buf + 2)) {
pos0 = strstr(ptr, "\r\n"); pos0 = strstr(ptr, "\r\n");
if (pos0 == NULL) { if (pos0 == NULL) {
error("Unable to parse http header: Invalid header format"); print(ERR_STR "Unable to parse http header: Invalid header format" CLR_STR);
return -1; return 1;
} }
if (req->version[0] == 0) { if (req->version[0] == 0) {
pos1 = (char *) strchr(ptr, ' ') + 1; pos1 = memchr(ptr, ' ', rcv_len - (ptr - buf)) + 1;
if (pos1 == NULL) goto err_hdr_fmt; if (pos1 == NULL) goto err_hdr_fmt;
if (pos1 - ptr - 1 >= sizeof(req->method)) { if (pos1 - ptr - 1 >= sizeof(req->method)) {
error("Unable to parse http header: Method name too long"); print(ERR_STR "Unable to parse http header: Method name too long" CLR_STR);
return -2; return 2;
} }
for (int i = 0; i < (pos1 - ptr - 1); i++) { for (int i = 0; i < (pos1 - ptr - 1); i++) {
if (ptr[i] < 'A' || ptr[i] > 'Z') { if (ptr[i] < 'A' || ptr[i] > 'Z') {
error("Unable to parse http header: Invalid method"); print(ERR_STR "Unable to parse http header: Invalid method" CLR_STR);
return -2; return 2;
} }
} }
snprintf(req->method, sizeof(req->method), "%.*s", (int) (pos1 - ptr - 1), ptr); snprintf(req->method, sizeof(req->method), "%.*s", (int) (pos1 - ptr - 1), ptr);
pos2 = (char *) strchr(pos1, ' ') + 1; pos2 = memchr(pos1, ' ', rcv_len - (pos1 - buf)) + 1;
if (pos2 == NULL) { if (pos2 == NULL) {
err_hdr_fmt: err_hdr_fmt:
error("Unable to parse http header: Invalid header format"); print(ERR_STR "Unable to parse http header: Invalid header format" CLR_STR);
return -1; return 1;
} }
if (memcmp(pos2, "HTTP/", 5) != 0 || memcmp(pos2 + 8, "\r\n", 2) != 0) { if (memcmp(pos2, "HTTP/", 5) != 0 || memcmp(pos2 + 8, "\r\n", 2) != 0) {
error("Unable to parse http header: Invalid version"); print(ERR_STR "Unable to parse http header: Invalid version" CLR_STR);
return -3; return 3;
} }
len = pos2 - pos1 - 1; len = pos2 - pos1 - 1;
@@ -203,43 +209,15 @@ int http_parse_request(char *buf, http_req *req) {
sprintf(req->version, "%.3s", pos2 + 5); sprintf(req->version, "%.3s", pos2 + 5);
} else { } else {
int ret = http_parse_header_field(&req->hdr, ptr, pos0, HTTP_MERGE_FIELDS); int ret = http_parse_header_field(&req->hdr, ptr, pos0, HTTP_MERGE_FIELDS);
if (ret != 0) return -ret; if (ret != 0) return ret;
} }
ptr = pos0 + 2; ptr = pos0 + 2;
} }
if (pos0[2] == '\r' && pos0[3] == '\n') { if (pos0[2] == '\r' && pos0[3] == '\n') {
return (int) header_len; break;
} }
return -1;
} }
int http_receive_request(sock *client, http_req *req) {
long rcv_len;
char buf[CLIENT_MAX_HEADER_SIZE];
memset(buf, 0, sizeof(buf));
memset(req->method, 0, sizeof(req->method));
memset(req->version, 0, sizeof(req->version));
req->uri = NULL;
req->hdr.last_field_num = -1;
http_init_hdr(&req->hdr);
rcv_len = sock_recv(client, buf, CLIENT_MAX_HEADER_SIZE - 1, MSG_PEEK);
if (rcv_len <= 0) {
error("Unable to receive http header: %s", sock_strerror(client));
return -1;
}
buf[rcv_len] = 0;
long header_len = http_parse_request(buf, req);
if (header_len < 0)
return (int) -header_len;
rcv_len = sock_recv(client, buf, header_len, 0);
if (rcv_len != header_len)
return -1;
return 0; return 0;
} }
@@ -249,7 +227,7 @@ const char *http_get_header_field(const http_hdr *hdr, const char *field_name) {
const char *http_get_header_field_len(const http_hdr *hdr, const char *field_name, unsigned long len) { const char *http_get_header_field_len(const http_hdr *hdr, const char *field_name, unsigned long len) {
int num = http_get_header_field_num_len(hdr, field_name, len); int num = http_get_header_field_num_len(hdr, field_name, len);
return (num >= 0 && num < list_size(hdr->fields)) ? http_field_get_value(&hdr->fields[num]) : NULL; return (num >= 0 && num < HTTP_MAX_HEADER_FIELD_NUM) ? http_field_get_value(&hdr->fields[num]) : NULL;
} }
int http_get_header_field_num(const http_hdr *hdr, const char *field_name) { int http_get_header_field_num(const http_hdr *hdr, const char *field_name) {
@@ -257,8 +235,16 @@ int http_get_header_field_num(const http_hdr *hdr, const char *field_name) {
} }
int http_get_header_field_num_len(const http_hdr *hdr, const char *field_name, unsigned long len) { int http_get_header_field_num_len(const http_hdr *hdr, const char *field_name, unsigned long len) {
for (int i = 0; i < list_size(hdr->fields); i++) { char field_name_1[256], field_name_2[256];
if (strncasecmp(field_name, http_field_get_name(&hdr->fields[i]), len) == 0) memcpy(field_name_1, field_name, len);
field_name_1[len] = 0;
http_to_camel_case(field_name_1, HTTP_LOWER);
for (int i = 0; i < hdr->field_num; i++) {
strcpy(field_name_2, http_field_get_name(&hdr->fields[i]));
http_to_camel_case(field_name_2, HTTP_LOWER);
if (strcmp(field_name_1, field_name_2) == 0)
return i; return i;
} }
@@ -270,8 +256,10 @@ int http_add_header_field(http_hdr *hdr, const char *field_name, const char *fie
} }
int http_add_header_field_len(http_hdr *hdr, const char *name, unsigned long name_len, const char *value, unsigned long value_len) { int http_add_header_field_len(http_hdr *hdr, const char *name, unsigned long name_len, const char *value, unsigned long value_len) {
http_field *f; if (hdr->field_num >= HTTP_MAX_HEADER_FIELD_NUM)
hdr->fields = list_append_ptr(hdr->fields, (void **) &f); return -1;
http_field *f = &hdr->fields[(int) hdr->field_num];
if (name_len < sizeof(f->normal.name) && value_len < sizeof(f->normal.value)) { if (name_len < sizeof(f->normal.name) && value_len < sizeof(f->normal.value)) {
f->type = HTTP_FIELD_NORMAL; f->type = HTTP_FIELD_NORMAL;
@@ -299,6 +287,7 @@ int http_add_header_field_len(http_hdr *hdr, const char *name, unsigned long nam
http_to_camel_case(f->ex_name.name, HTTP_PRESERVE); http_to_camel_case(f->ex_name.name, HTTP_PRESERVE);
} }
hdr->field_num++;
return 0; return 0;
} }
@@ -324,16 +313,23 @@ void http_append_to_header_field(http_field *field, const char *value, unsigned
} }
void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode) { void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode) {
char field_name_1[256], field_name_2[256];
strcpy(field_name_1, field_name);
http_to_camel_case(field_name_1, HTTP_LOWER);
int i = 0; int i = 0;
int diff = 1; int diff = 1;
if (mode == HTTP_REMOVE_LAST) { if (mode == HTTP_REMOVE_LAST) {
i = list_size(hdr->fields) - 1; i = hdr->field_num - 1;
diff = -1; diff = -1;
} }
for (; i < list_size(hdr->fields) && i >= 0; i += diff) { for (; i < hdr->field_num && i >= 0; i += diff) {
if (strcasecmp(field_name, http_field_get_name(&hdr->fields[i])) == 0) { strcpy(field_name_2, http_field_get_name(&hdr->fields[i]));
http_to_camel_case(field_name_2, HTTP_LOWER);
if (strcmp(field_name_1, field_name_2) == 0) {
http_free_field(&hdr->fields[i]); http_free_field(&hdr->fields[i]);
list_remove(hdr->fields, i); memmove(&hdr->fields[i], &hdr->fields[i + 1], sizeof(hdr->fields[0]) * (hdr->field_num - i));
hdr->field_num--;
if (mode == HTTP_REMOVE_ALL) { if (mode == HTTP_REMOVE_ALL) {
i -= diff; i -= diff;
} else { } else {
@@ -346,7 +342,7 @@ void http_remove_header_field(http_hdr *hdr, const char *field_name, int mode) {
int http_send_response(sock *client, http_res *res) { int http_send_response(sock *client, http_res *res) {
char buf[CLIENT_MAX_HEADER_SIZE]; char buf[CLIENT_MAX_HEADER_SIZE];
long off = sprintf(buf, "HTTP/%s %03i %s\r\n", res->version, res->status->code, res->status->msg); long off = sprintf(buf, "HTTP/%s %03i %s\r\n", res->version, res->status->code, res->status->msg);
for (int i = 0; i < list_size(res->hdr.fields); i++) { for (int i = 0; i < res->hdr.field_num; i++) {
const http_field *f = &res->hdr.fields[i]; const http_field *f = &res->hdr.fields[i];
off += sprintf(buf + off, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f)); off += sprintf(buf + off, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
} }
@@ -360,7 +356,7 @@ int http_send_response(sock *client, http_res *res) {
int http_send_request(sock *server, http_req *req) { int http_send_request(sock *server, http_req *req) {
char buf[CLIENT_MAX_HEADER_SIZE]; char buf[CLIENT_MAX_HEADER_SIZE];
long off = sprintf(buf, "%s %s HTTP/%s\r\n", req->method, req->uri, req->version); long off = sprintf(buf, "%s %s HTTP/%s\r\n", req->method, req->uri, req->version);
for (int i = 0; i < list_size(req->hdr.fields); i++) { for (int i = 0; i < req->hdr.field_num; i++) {
const http_field *f = &req->hdr.fields[i]; const http_field *f = &req->hdr.fields[i];
off += sprintf(buf + off, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f)); off += sprintf(buf + off, "%s: %s\r\n", http_field_get_name(f), http_field_get_value(f));
} }
@@ -373,7 +369,7 @@ int http_send_request(sock *server, http_req *req) {
} }
const http_status *http_get_status(unsigned short status_code) { const http_status *http_get_status(unsigned short status_code) {
for (int i = 0; i < http_statuses_size; i++) { for (int i = 0; i < http_statuses_size / sizeof(http_status); i++) {
if (http_statuses[i].code == status_code) { if (http_statuses[i].code == status_code) {
return &http_statuses[i]; return &http_statuses[i];
} }
@@ -383,7 +379,7 @@ const http_status *http_get_status(unsigned short status_code) {
const http_status_msg *http_get_error_msg(const http_status *status) { const http_status_msg *http_get_error_msg(const http_status *status) {
unsigned short code = status->code; unsigned short code = status->code;
for (int i = 0; i < http_status_messages_size; i++) { for (int i = 0; i < http_status_messages_size / sizeof(http_status_msg); i++) {
if (http_status_messages[i].code == code) { if (http_status_messages[i].code == code) {
return &http_status_messages[i]; return &http_status_messages[i];
} }
@@ -408,8 +404,8 @@ const char *http_get_status_color(const http_status *status) {
} }
char *http_format_date(time_t time, char *buf, size_t size) { char *http_format_date(time_t time, char *buf, size_t size) {
struct tm timeinfo; struct tm *timeinfo = gmtime(&time);
strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", gmtime_r(&time, &timeinfo)); strftime(buf, size, "%a, %d %b %Y %H:%M:%S GMT", timeinfo);
return buf; return buf;
} }
@@ -422,10 +418,10 @@ char *http_get_date(char *buf, size_t size) {
const http_doc_info *http_get_status_info(const http_status *status) { const http_doc_info *http_get_status_info(const http_status *status) {
unsigned short code = status->code; unsigned short code = status->code;
static http_doc_info info[] = { static http_doc_info info[] = {
{"info", HTTP_COLOR_INFO, "/.sesimos/res/icon-info.svg", http_info_doc}, {"info", HTTP_COLOR_INFO, http_info_icon, http_info_document},
{"success", HTTP_COLOR_SUCCESS, "/.sesimos/res/icon-success.svg", http_success_doc}, {"success", HTTP_COLOR_SUCCESS, http_success_icon, http_success_document},
{"warning", HTTP_COLOR_WARNING, "/.sesimos/res/icon-warning.svg", http_warning_doc}, {"warning", HTTP_COLOR_WARNING, http_warning_icon, http_warning_document},
{"error", HTTP_COLOR_ERROR, "/.sesimos/res/icon-error.svg", http_error_doc} {"error", HTTP_COLOR_ERROR, http_error_icon, http_error_document}
}; };
if (code >= 100 && code < 200) { if (code >= 100 && code < 200) {
return &info[0]; return &info[0];

32
src/lib/http.h
View File

@@ -37,14 +37,14 @@
#define HTTP_COLOR_ERROR "#C00000" #define HTTP_COLOR_ERROR "#C00000"
#define CLIENT_MAX_HEADER_SIZE 8192 #define CLIENT_MAX_HEADER_SIZE 8192
#define HTTP_INIT_HEADER_FIELD_NUM 16 #define HTTP_MAX_HEADER_FIELD_NUM 64
#ifndef SERVER_STR #ifndef SERVER_STR
# define SERVER_STR "sesimos" # define SERVER_STR "Sesimos"
#endif #endif
#ifndef SERVER_STR_HTML #ifndef SERVER_STR_HTML
# define SERVER_STR_HTML "sesimos&nbsp;web&nbsp;server" # define SERVER_STR_HTML "Sesimos&nbsp;web&nbsp;server"
#endif #endif
typedef struct { typedef struct {
@@ -69,11 +69,11 @@ typedef struct {
char type; char type;
union { union {
struct { struct {
char name[32]; char name[64];
char value[32]; char value[192];
} normal; } normal;
struct { struct {
char name[64 - sizeof(char *)]; char name[192];
char *value; char *value;
} ex_value; } ex_value;
struct { struct {
@@ -84,8 +84,9 @@ typedef struct {
} http_field; } http_field;
typedef struct { typedef struct {
int last_field_num; char field_num;
http_field *fields; char last_field_num;
http_field fields[HTTP_MAX_HEADER_FIELD_NUM];
} http_hdr; } http_hdr;
typedef struct { typedef struct {
@@ -116,7 +117,16 @@ extern const http_status_msg http_status_messages[];
extern const int http_statuses_size; extern const int http_statuses_size;
extern const int http_status_messages_size; extern const int http_status_messages_size;
extern const char http_error_doc[], http_warning_doc[], http_success_doc[], http_info_doc[]; extern const char http_default_document[];
extern const char http_rev_proxy_document[];
extern const char http_error_document[];
extern const char http_error_icon[];
extern const char http_warning_document[];
extern const char http_warning_icon[];
extern const char http_success_document[];
extern const char http_success_icon[];
extern const char http_info_document[];
extern const char http_info_icon[];
void http_to_camel_case(char *str, int mode); void http_to_camel_case(char *str, int mode);
@@ -124,8 +134,6 @@ const char *http_field_get_name(const http_field *field);
const char *http_field_get_value(const http_field *field); const char *http_field_get_value(const http_field *field);
int http_init_hdr(http_hdr *hdr);
void http_free_field(http_field *f); void http_free_field(http_field *f);
void http_free_hdr(http_hdr *hdr); void http_free_hdr(http_hdr *hdr);
@@ -134,8 +142,6 @@ void http_free_req(http_req *req);
void http_free_res(http_res *res); void http_free_res(http_res *res);
int http_parse_request(char *buf, http_req *req);
int http_receive_request(sock *client, http_req *req); int http_receive_request(sock *client, http_req *req);
int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags); int http_parse_header_field(http_hdr *hdr, const char *buf, const char *end_ptr, int flags);

218
src/lib/http_static.c
View File

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

139
src/lib/list.c
View File

@@ -1,139 +0,0 @@
#include "list.h"
#include <malloc.h>
#include <memory.h>
#include <errno.h>
#define FACTOR 4
typedef struct {
int init_size, elem_size, max_size, size;
} list_meta_t;
static void *list_resize(list_meta_t *list, int new_size) {
if (new_size <= 0)
return NULL;
list_meta_t *new_ptr = realloc(list, sizeof(list_meta_t) + list->elem_size * new_size);
if (new_ptr == NULL)
return NULL;
new_ptr->max_size = new_size;
return new_ptr;
}
void *list_create(int elem_size, int init_elem_n) {
if (elem_size <= 0 || init_elem_n <= 0) {
errno = EINVAL;
return NULL;
}
void *list_ptr = malloc(sizeof(list_meta_t) + elem_size * init_elem_n);
list_meta_t *list = list_ptr;
list->init_size = init_elem_n;
list->elem_size = elem_size;
list->max_size = init_elem_n;
list->size = 0;
return (unsigned char *) list_ptr + sizeof(list_meta_t);
}
int list_size(const void *list_ptr) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
return list->size;
}
int list_find(void *list_ptr, void *elem) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
unsigned char *array = list_ptr;
for (int i = 0; i < list->size; i++) {
if (memcmp(array + i * list->elem_size, elem, list->elem_size) == 0) {
return i;
}
}
return -1;
}
void *list_insert(void *list_ptr, void *elem, int n) {
void *ptr = NULL;
list_ptr = list_insert_ptr(list_ptr, &ptr, n);
if (list_ptr != NULL && ptr != NULL) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
memcpy(ptr, elem, list->elem_size);
}
return list_ptr;
}
void *list_insert_ptr(void *list_ptr, void **elem, int n) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
if (n < 0)
n = list->size + n + 1;
if (list->size >= list->max_size) {
if ((list = list_resize(list, list->max_size * FACTOR)) == NULL) {
return NULL;
}
}
unsigned char *array = (unsigned char *) list + sizeof(list_meta_t);
if (n < list->size)
memmove(array + (n + 1) * list->elem_size, array + n * list->elem_size, (list->size - n) * list->elem_size);
*elem = array + n * list->elem_size;
list->size++;
return (unsigned char *) list + sizeof(list_meta_t);
}
void *list_append(void *list_ptr, void *elem) {
return list_insert(list_ptr, elem, -1);
}
void *list_append_ptr(void *list_ptr, void **elem) {
return list_insert_ptr(list_ptr, elem, -1);
}
void *list_remove(void *list_ptr, int n) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
if (n < 0)
n = list->size + n;
unsigned char *array = list_ptr;
if (list->size > 1 && n < list->size)
memmove(array + n * list->elem_size, array + (n + 1) * list->elem_size, (list->size - n - 1) * list->elem_size);
list->size--;
if (list->size < list->max_size / FACTOR / 2 && list->max_size / FACTOR >= list->init_size) {
if ((list = list_resize(list, list->max_size / FACTOR)) == NULL) {
return NULL;
}
}
return (unsigned char *) list + sizeof(list_meta_t);
}
void *list_delete(void *list_ptr, void *elem) {
int idx = list_find(list_ptr, elem);
if (idx == -1) {
return list_ptr;
} else {
return list_remove(list_ptr, idx);
}
}
void *list_clear(void *list_ptr) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
list->size = 0;
memset(list_ptr, 0, list->max_size * list->elem_size);
list->max_size = list->init_size;
return (unsigned char *) list_resize(list, list->max_size * list->elem_size) + sizeof(list_meta_t);
}
void list_free(void *list_ptr) {
list_meta_t *list = (void *) ((unsigned char *) list_ptr - sizeof(list_meta_t));
free(list);
}

27
src/lib/list.h
View File

@@ -1,27 +0,0 @@
#ifndef SESIMOS_LIST_H
#define SESIMOS_LIST_H
void *list_create(int elem_size, int init_elem_n);
int list_size(const void *list_ptr);
int list_find(void *list_ptr, void *elem);
void *list_insert(void *list_ptr, void *elem, int n);
void *list_insert_ptr(void *list_ptr, void **elem, int n);
void *list_append(void *list_ptr, void *elem);
void *list_append_ptr(void *list_ptr, void **elem);
void *list_remove(void *list_ptr, int n);
void *list_delete(void *list_ptr, void *elem);
void *list_clear(void *list_ptr);
void list_free(void *list_ptr);
#endif //SESIMOS_LIST_H

168
src/lib/mpmc.c
View File

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

27
src/lib/mpmc.h
View File

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

47
src/lib/proxy.h
View File

@@ -1,47 +0,0 @@
/**
* sesimos - secure, simple, modern web server
* @brief Reverse proxy (header file)
* @file src/lib/proxy.h
* @author Lorenz Stechauner
* @date 2021-01-07
*/
#ifndef SESIMOS_PROXY_H
#define SESIMOS_PROXY_H
#define PROXY_CHUNKED 1
#define PROXY_COMPRESS_GZ 2
#define PROXY_COMPRESS_BR 4
#define PROXY_COMPRESS 6
#ifndef SERVER_NAME
# define SERVER_NAME "reverse proxy"
#endif
#include "http.h"
#include "config.h"
typedef struct {
unsigned char initialized:1, in_use:1;
sock proxy;
char *host;
void *client;
} proxy_ctx_t;
int proxy_preload(void);
void proxy_unload(void);
void proxy_close_all(void);
int proxy_request_header(http_req *req, sock *sock);
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_dump(proxy_ctx_t *proxy, char *buf, long len);
#endif //SESIMOS_PROXY_H

62
src/lib/res.h
View File

@@ -1,62 +0,0 @@
/**
* sesimos - secure, simple, modern web server
* @brief HTTP resources (header file)
* @file src/lib/res.h
* @author Lorenz Stechauner
* @date 2022-12-31
*/
#ifndef SESIMOS_RES_H
#define SESIMOS_RES_H
#define http_default_doc _binary_bin_res_default_txt_start
#define http_default_doc_size ((unsigned int) (_binary_bin_res_default_txt_end - _binary_bin_res_default_txt_start) - 1)
#define http_proxy_doc _binary_bin_res_proxy_txt_start
#define http_proxy_doc_size ((unsigned int) (_binary_bin_res_proxy_txt_end - _binary_bin_res_proxy_txt_start) - 1)
#define http_style_doc _binary_bin_res_style_txt_start
#define http_style_doc_size ((unsigned int) (_binary_bin_res_style_txt_end - _binary_bin_res_style_txt_start) - 1)
#define http_icon_error _binary_bin_res_icon_error_txt_start
#define http_icon_error_size ((unsigned int) (_binary_bin_res_icon_error_txt_end - _binary_bin_res_icon_error_txt_start) - 1)
#define http_icon_info _binary_bin_res_icon_info_txt_start
#define http_icon_info_size ((unsigned int) (_binary_bin_res_icon_info_txt_end - _binary_bin_res_icon_info_txt_start) - 1)
#define http_icon_success _binary_bin_res_icon_success_txt_start
#define http_icon_success_size ((unsigned int) (_binary_bin_res_icon_success_txt_end - _binary_bin_res_icon_success_txt_start) - 1)
#define http_icon_warning _binary_bin_res_icon_warning_txt_start
#define http_icon_warning_size ((unsigned int) (_binary_bin_res_icon_warning_txt_end - _binary_bin_res_icon_warning_txt_start) - 1)
#define http_icon_globe _binary_bin_res_globe_txt_start
#define http_icon_globe_size ((unsigned int) (_binary_bin_res_globe_txt_end - _binary_bin_res_globe_txt_start) - 1)
typedef struct {
const char *name;
const char *type;
const char *content;
const unsigned int size;
} res_t;
extern const char _binary_bin_res_default_txt_start[];
extern const char _binary_bin_res_default_txt_end[];
extern const char _binary_bin_res_proxy_txt_start[];
extern const char _binary_bin_res_proxy_txt_end[];
extern const char _binary_bin_res_style_txt_start[];
extern const char _binary_bin_res_style_txt_end[];
extern const char _binary_bin_res_icon_error_txt_start[];
extern const char _binary_bin_res_icon_error_txt_end[];
extern const char _binary_bin_res_icon_info_txt_start[];
extern const char _binary_bin_res_icon_info_txt_end[];
extern const char _binary_bin_res_icon_success_txt_start[];
extern const char _binary_bin_res_icon_success_txt_end[];
extern const char _binary_bin_res_icon_warning_txt_start[];
extern const char _binary_bin_res_icon_warning_txt_end[];
extern const char _binary_bin_res_globe_txt_start[];
extern const char _binary_bin_res_globe_txt_end[];
#endif //SESIMOS_RES_H

323
src/lib/proxy.c → src/lib/rev_proxy.c
View File

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

39
src/lib/rev_proxy.h Normal file
View File

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

67
src/lib/sock.c
View File

@@ -14,6 +14,7 @@
#include <string.h> #include <string.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <unistd.h> #include <unistd.h>
#include <poll.h>
int sock_enc_error(sock *s) { int sock_enc_error(sock *s) {
@@ -21,9 +22,6 @@ int sock_enc_error(sock *s) {
} }
const char *sock_strerror(sock *s) { const char *sock_strerror(sock *s) {
// FIXME sock_strerror not Thread Safe!
// (and ugly)
errno = 0;
if (s->_last_ret == 0) { if (s->_last_ret == 0) {
return "closed"; return "closed";
} else if (s->enc) { } else if (s->enc) {
@@ -31,7 +29,7 @@ const char *sock_strerror(sock *s) {
return NULL; return NULL;
} }
const char *err1 = ERR_reason_error_string(s->_ssl_error); const char *err1 = ERR_reason_error_string(s->_ssl_error);
const char *err2 = strerror(s->_errno); const char *err2 = strerror(errno);
switch (sock_enc_error(s)) { switch (sock_enc_error(s)) {
case SSL_ERROR_NONE: case SSL_ERROR_NONE:
return NULL; return NULL;
@@ -59,23 +57,6 @@ const char *sock_strerror(sock *s) {
} }
} }
int sock_set_timeout_micros(sock *s, long recv_micros, long send_micros) {
struct timeval recv_to = {.tv_sec = recv_micros / 1000000, .tv_usec = recv_micros % 1000000},
send_to = {.tv_sec = send_micros / 1000000, .tv_usec = send_micros % 1000000};
if (setsockopt(s->socket, SOL_SOCKET, SO_RCVTIMEO, &recv_to, sizeof(recv_to)) != 0)
return -1;
if (setsockopt(s->socket, SOL_SOCKET, SO_SNDTIMEO, &send_to, sizeof(send_to)) != 0)
return -1;
return 0;
}
int sock_set_timeout(sock *s, int sec) {
return sock_set_timeout_micros(s, sec * 1000000L, sec * 1000000L);
}
long sock_send(sock *s, void *buf, unsigned long len, int flags) { long sock_send(sock *s, void *buf, unsigned long len, int flags) {
long ret; long ret;
if (s->enc) { if (s->enc) {
@@ -140,25 +121,50 @@ long sock_splice_chunked(sock *dst, sock *src, void *buf, unsigned long buf_len)
} }
int sock_close(sock *s) { int sock_close(sock *s) {
int e = errno; if ((int) s->enc && s->ssl != NULL) {
if (s->enc && s->ssl != NULL) {
if (s->_last_ret >= 0) SSL_shutdown(s->ssl); if (s->_last_ret >= 0) SSL_shutdown(s->ssl);
SSL_free(s->ssl); SSL_free(s->ssl);
s->ssl = NULL; s->ssl = NULL;
} }
shutdown(s->socket, SHUT_RDWR);
close(s->socket); close(s->socket);
s->socket = 0; s->socket = 0;
s->enc = 0; s->enc = 0;
errno = e;
return 0; return 0;
} }
int sock_has_pending(sock *s) { int sock_check(sock *s) {
char buf[1]; char buf;
int e = errno; return recv(s->socket, &buf, 1, MSG_PEEK | MSG_DONTWAIT) == 1;
long ret = sock_recv(s, &buf, 1, MSG_PEEK | MSG_DONTWAIT); }
errno = e;
return ret == 1; int sock_poll(sock *sockets[], sock *ready[], sock *error[], int n_sock, int *n_ready, int *n_error, short events, int timeout_ms) {
struct pollfd fds[n_sock];
for (int i = 0; i < n_sock; i++) {
fds[i].fd = sockets[i]->socket;
fds[i].events = events;
}
int ret = poll(fds, n_sock, timeout_ms);
if (ret < 0 || ready == NULL || error == NULL) return ret;
*n_ready = 0, *n_error = 0;
for (int i = 0; i < n_sock; i++) {
if (fds[i].revents & events)
ready[(*n_ready)++] = sockets[i];
if (fds[i].revents & (POLLERR | POLLHUP | POLLNVAL))
error[(*n_error)++] = sockets[i];
}
return ret;
}
int sock_poll_read(sock *sockets[], sock *readable[], sock *error[], int n_sock, int *n_readable, int *n_error, int timeout_ms) {
return sock_poll(sockets, readable, error, n_sock, n_readable, n_error, POLLIN, timeout_ms);
}
int sock_poll_write(sock *sockets[], sock *writable[], sock *error[], int n_sock, int *n_writable, int *n_error, int timeout_ms) {
return sock_poll(sockets, writable, error, n_sock, n_writable, n_error, POLLOUT, timeout_ms);
} }
long sock_parse_chunk_header(const char *buf, long len, long *ret_len) { long sock_parse_chunk_header(const char *buf, long len, long *ret_len) {
@@ -182,6 +188,7 @@ long sock_get_chunk_header(sock *s) {
char buf[16]; char buf[16];
do { do {
print("debug1"); // TODO remove
ret = sock_recv(s, buf, sizeof(buf), MSG_PEEK); ret = sock_recv(s, buf, sizeof(buf), MSG_PEEK);
if (ret <= 0) return -2; if (ret <= 0) return -2;
else if (ret < 2) continue; else if (ret < 2) continue;

18
src/lib/sock.h
View File

@@ -11,16 +11,10 @@
#include <openssl/crypto.h> #include <openssl/crypto.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <arpa/inet.h>
typedef struct { typedef struct {
unsigned int enc:1; unsigned int enc:1;
int socket; int socket;
union {
struct sockaddr sock;
struct sockaddr_in6 ipv6;
} _addr;
char *addr, *s_addr;
SSL_CTX *ctx; SSL_CTX *ctx;
SSL *ssl; SSL *ssl;
long _last_ret; long _last_ret;
@@ -32,10 +26,6 @@ int sock_enc_error(sock *s);
const char *sock_strerror(sock *s); const char *sock_strerror(sock *s);
int sock_set_timeout_micros(sock *s, long recv_micros, long send_micros);
int sock_set_timeout(sock *s, int sec);
long sock_send(sock *s, void *buf, unsigned long len, int flags); long sock_send(sock *s, void *buf, unsigned long len, int flags);
long sock_recv(sock *s, void *buf, unsigned long len, int flags); long sock_recv(sock *s, void *buf, unsigned long len, int flags);
@@ -46,7 +36,13 @@ long sock_splice_chunked(sock *dst, sock *src, void *buf, unsigned long buf_len)
int sock_close(sock *s); int sock_close(sock *s);
int sock_has_pending(sock *s); int sock_check(sock *s);
int sock_poll(sock *sockets[], sock *ready[], sock *error[], int n_sock, int *n_ready, int *n_error, short events, int timeout_ms);
int sock_poll_read(sock *sockets[], sock *readable[], sock *error[], int n_sock, int *n_readable, int *n_error, int timeout_ms);
int sock_poll_write(sock *sockets[], sock *writable[], sock *error[], int n_sock, int *n_writable, int *n_error, int timeout_ms);
long sock_parse_chunk_header(const char *buf, long len, long *ret_len); long sock_parse_chunk_header(const char *buf, long len, long *ret_len);

9
src/lib/uri.c
View File

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

18
src/lib/uri.h
View File

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

18
src/lib/utils.c
View File

@@ -11,9 +11,10 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h>
char *log_prefix;
static const char base64_encode_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; static const char base64_encode_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const int base64_mod_table[3] = {0, 2, 1}; static const int base64_mod_table[3] = {0, 2, 1};
@@ -26,7 +27,7 @@ char *format_duration(unsigned long micros, char *buf) {
} else if (micros < 60000000 - 1000000) { } else if (micros < 60000000 - 1000000) {
sprintf(buf, "%.1f s", (double) micros / 1000000); sprintf(buf, "%.1f s", (double) micros / 1000000);
} else if (micros < 6000000000) { } else if (micros < 6000000000) {
sprintf(buf, "%li:%02li min", micros / 1000000 / 60, micros / 1000000 % 60); sprintf(buf, "%.1f min", (double) micros / 1000000 / 60);
} else { } else {
sprintf(buf, "%.0f min", (double) micros / 1000000 / 60); sprintf(buf, "%.0f min", (double) micros / 1000000 / 60);
} }
@@ -204,16 +205,3 @@ int base64_encode(void *data, unsigned long data_len, char *output, unsigned lon
return 0; return 0;
} }
long clock_micros(void) {
struct timespec time;
clock_gettime(CLOCK_MONOTONIC, &time);
return time.tv_sec * 1000000 + time.tv_nsec / 1000;
}
long clock_cpu(void) {
struct timespec time;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time);
return time.tv_sec * 1000000000 + time.tv_nsec;
}

17
src/lib/utils.h
View File

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

83
src/lib/websocket.c
View File

@@ -6,14 +6,21 @@
* @date 2022-08-16 * @date 2022-08-16
*/ */
#include "../logger.h" #include "../defs.h"
#include "websocket.h" #include "websocket.h"
#include "utils.h" #include "utils.h"
#include <string.h> #include <string.h>
#include <openssl/sha.h> #include <openssl/sha.h>
#include <errno.h>
#include <signal.h>
static const char ws_key_uuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; static const char ws_key_uuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
static volatile sig_atomic_t terminate = 0;
void ws_terminate(int _) {
terminate = 1;
}
int ws_calc_accept_key(const char *key, char *accept_key) { int ws_calc_accept_key(const char *key, char *accept_key) {
if (key == NULL || accept_key == NULL) if (key == NULL || accept_key == NULL)
@@ -38,10 +45,10 @@ int ws_recv_frame_header(sock *s, ws_frame *frame) {
long ret = sock_recv(s, buf, 2, 0); long ret = sock_recv(s, buf, 2, 0);
if (ret < 0) { if (ret < 0) {
error("Unable to receive from socket"); print(ERR_STR "Unable to receive from socket: %s" CLR_STR, strerror(errno));
return -1; return -1;
} else if (ret != 2) { } else if (ret != 2) {
error("Unable to receive 2 bytes from socket"); print(ERR_STR "Unable to receive 2 bytes from socket" CLR_STR);
return -2; return -2;
} }
@@ -63,10 +70,10 @@ int ws_recv_frame_header(sock *s, ws_frame *frame) {
ret = sock_recv(s, buf, remaining, 0); ret = sock_recv(s, buf, remaining, 0);
if (ret < 0) { if (ret < 0) {
error("Unable to receive from socket"); print(ERR_STR "Unable to receive from socket: %s" CLR_STR, strerror(errno));
return -1; return -1;
} else if (ret != remaining) { } else if (ret != remaining) {
error("Unable to receive correct number of bytes from socket"); print(ERR_STR "Unable to receive correct number of bytes from socket" CLR_STR);
return -2; return -2;
} }
@@ -127,12 +134,74 @@ int ws_send_frame_header(sock *s, ws_frame *frame) {
long ret = sock_send(s, buf, ptr - buf, frame->len != 0 ? MSG_MORE : 0); long ret = sock_send(s, buf, ptr - buf, frame->len != 0 ? MSG_MORE : 0);
if (ret < 0) { if (ret < 0) {
error("Unable to send to socket"); print(ERR_STR "Unable to send to socket: %s" CLR_STR, strerror(errno));
return -1; return -1;
} else if (ret != ptr - buf) { } else if (ret != ptr - buf) {
error("Unable to send to socket"); print(ERR_STR "Unable to send to socket" CLR_STR);
return -2; return -2;
} }
return 0; return 0;
} }
int ws_handle_connection(sock *s1, sock *s2) {
sock *poll_socks[2] = {s1, s2};
sock *readable[2], *error[2];
int n_sock = 2, n_readable = 0, n_error = 0;
ws_frame frame;
char buf[CHUNK_SIZE];
int closes = 0;
long ret;
signal(SIGINT, ws_terminate);
signal(SIGTERM, ws_terminate);
while (!terminate && closes != 3) {
ret = sock_poll_read(poll_socks, readable, error, n_sock, &n_readable, &n_error, WS_TIMEOUT * 1000);
if (terminate) {
break;
} else if (ret < 0) {
print(ERR_STR "Unable to poll sockets: %s" CLR_STR, strerror(errno));
return -1;
} else if (n_readable == 0) {
print(ERR_STR "Connection timed out" CLR_STR);
return -2;
} else if (n_error > 0) {
print(ERR_STR "Peer closed connection" CLR_STR);
return -3;
}
for (int i = 0; i < n_readable; i++) {
sock *s = readable[i];
sock *o = (s == s1) ? s2 : s1;
if (ws_recv_frame_header(s, &frame) != 0) return -3;
// print("WebSocket: Peer %s, Opcode=0x%X, Len=%li", (s == s1) ? "1" : "2", frame.opcode, frame.len);
if (frame.opcode == 0x8) {
n_sock--;
if (s == s1) {
poll_socks[0] = s2;
closes |= 1;
} else {
closes |= 2;
}
}
if (ws_send_frame_header(o, &frame) != 0) return -3;
if (frame.len > 0) {
ret = sock_splice(o, s, buf, sizeof(buf), frame.len);
if (ret < 0) {
print(ERR_STR "Unable to forward data in WebSocket: %s" CLR_STR, strerror(errno));
return -4;
} else if (ret != frame.len) {
print(ERR_STR "Unable to forward correct number of bytes in WebSocket" CLR_STR);
return -4;
}
}
}
}
return 0;
}

2
src/lib/websocket.h
View File

@@ -30,4 +30,6 @@ int ws_recv_frame_header(sock *s, ws_frame *frame);
int ws_send_frame_header(sock *s, ws_frame *frame); int ws_send_frame_header(sock *s, ws_frame *frame);
int ws_handle_connection(sock *s1, sock *s2);
#endif //SESIMOS_WEBSOCKET_H #endif //SESIMOS_WEBSOCKET_H

281
src/logger.c
View File

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

40
src/logger.h
View File

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

444
src/server.c
View File

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

17
src/server.h
View File

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

175
src/worker/fastcgi_handler.c
View File

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

69
src/worker/func.h
View File

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

217
src/worker/local_handler.c
View File

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

163
src/worker/proxy_handler.c
View File

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

391
src/worker/request_handler.c
View File

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

130
src/worker/tcp_acceptor.c
View File

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

94
src/worker/ws_frame_handler.c
View File

@@ -1,94 +0,0 @@
/**
* sesimos - secure, simple, modern web server
* @brief WebSocket frame handler
* @file src/worker/ws_frame_handler.c
* @author Lorenz Stechauner
* @date 2022-12-30
*/
#include "../defs.h"
#include "func.h"
#include "../logger.h"
#include "../lib/websocket.h"
#include "../workers.h"
#include <errno.h>
static int ws_frame_handler(ws_ctx_t *ctx);
void ws_frame_handler_func(ws_ctx_t *ctx) {
logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
if (ws_frame_handler(ctx) == 0) {
if (ctx->client->ws_close == 3) {
ws_close(ctx);
} else {
ws_handle_frame(ctx);
}
} else {
ws_close(ctx);
}
}
int ws_handle_connection(client_ctx_t *ctx) {
info("Upgrading to WebSocket connection");
sock_set_timeout(&ctx->socket, WS_TIMEOUT);
sock_set_timeout(&ctx->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;
ws_handle_frame(a);
ws_handle_frame(b);
return 0;
}
static int ws_frame_handler(ws_ctx_t *ctx) {
ws_frame frame;
char buf[CHUNK_SIZE];
sock *socket = ctx->socket;
sock *other = (ctx->socket == &ctx->client->socket) ? &ctx->client->proxy->proxy : &ctx->client->socket;
if (ws_recv_frame_header(socket, &frame) != 0)
return -1;
debug("WebSocket: Peer %s, Opcode=0x%X, Len=%li", (ctx->socket == &ctx->client->socket) ? "client" : "server", frame.opcode, frame.len);
if (frame.opcode == 0x8) {
ctx->client->ws_close |= (ctx->socket == &ctx->client->socket) ? 1 : 2;
}
if (ws_send_frame_header(other, &frame) != 0)
return -1;
if (frame.len > 0) {
long ret = sock_splice(other, socket, buf, sizeof(buf), frame.len);
if (ret < 0) {
error("Unable to forward data in WebSocket");
return -1;
} else if (ret != frame.len) {
error("Unable to forward correct number of bytes in WebSocket");
return -1;
}
}
return 0;
}
void ws_close(ws_ctx_t *ctx) {
ws_ctx_t *other = ctx->other;
if (other) {
other->other = NULL;
logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->client->socket.s_addr, ctx->client->log_prefix);
info("Closing WebSocket connection");
proxy_close(ctx->client->proxy);
tcp_close(ctx->client);
}
free(ctx);
errno = 0;
}

81
src/workers.c
View File

@@ -1,81 +0,0 @@
/**
* sesimos - secure, simple, modern web server
* @brief Worker interface
* @file src/workers.c
* @author Lorenz Stechauner
* @date 2022-12-29
*/
#include "workers.h"
#include "lib/mpmc.h"
#include "worker/func.h"
#include "async.h"
static mpmc_t tcp_acceptor_ctx, request_handler_ctx, local_handler_ctx, fastcgi_handler_cxt, proxy_handler_ctx,
ws_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, 16, 64, (void (*)(void *)) request_handler_func, "req");
mpmc_init(&local_handler_ctx, 16, 64, (void (*)(void *)) local_handler_func, "local");
mpmc_init(&fastcgi_handler_cxt, 16, 64, (void (*)(void *)) fastcgi_handler_func, "fcgi");
mpmc_init(&proxy_handler_ctx, 16, 64, (void (*)(void *)) proxy_handler_func, "proxy");
mpmc_init(&ws_frame_handler_ctx, 16, 64, (void (*)(void *)) ws_frame_handler_func, "ws");
return -1;
}
void workers_stop(void) {
mpmc_stop(&tcp_acceptor_ctx);
mpmc_stop(&local_handler_ctx);
mpmc_stop(&fastcgi_handler_cxt);
mpmc_stop(&proxy_handler_ctx);
mpmc_stop(&request_handler_ctx);
mpmc_stop(&ws_frame_handler_ctx);
}
void workers_destroy(void) {
mpmc_destroy(&tcp_acceptor_ctx);
mpmc_destroy(&local_handler_ctx);
mpmc_destroy(&fastcgi_handler_cxt);
mpmc_destroy(&proxy_handler_ctx);
mpmc_destroy(&request_handler_ctx);
mpmc_destroy(&ws_frame_handler_ctx);
}
int tcp_accept(client_ctx_t *ctx) {
return mpmc_queue(&tcp_acceptor_ctx, ctx);
}
static int handle_request_cb(client_ctx_t *ctx) {
return mpmc_queue(&request_handler_ctx, ctx);
}
int handle_request(client_ctx_t *ctx) {
if (ctx->c_keep_alive && ctx->s_keep_alive) {
return async(&ctx->socket, ASYNC_WAIT_READ, 0, ctx, (void (*)(void *)) handle_request_cb, (void (*)(void *)) tcp_close);
} else {
tcp_close(ctx);
return 0;
}
}
int local_handle(client_ctx_t *ctx) {
return mpmc_queue(&local_handler_ctx, ctx);
}
int fastcgi_handle(client_ctx_t *ctx) {
return mpmc_queue(&fastcgi_handler_cxt, ctx);
}
int proxy_handle(client_ctx_t *ctx) {
return mpmc_queue(&proxy_handler_ctx, ctx);
}
static int ws_handle_frame_cb(ws_ctx_t *ctx) {
return mpmc_queue(&ws_frame_handler_ctx, ctx);
}
int ws_handle_frame(ws_ctx_t *ctx) {
return async(ctx->socket, ASYNC_WAIT_READ, 0, ctx, (void (*)(void *)) ws_handle_frame_cb, (void (*)(void *)) ws_close);
}

32
src/workers.h
View File

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

92
test/test_list.c
View File

@@ -1,92 +0,0 @@
#include <criterion/criterion.h>
#include <criterion/parameterized.h>
#include "../src/lib/list.h"
Test(list, simple) {
int v;
int *list = list_create(sizeof(int), 16);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 0);
v = 1;
list = list_append(list, &v);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 1);
cr_assert_eq(list[0], 1);
v = 3;
list = list_append(list, &v);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 2);
cr_assert_eq(list[0], 1);
cr_assert_eq(list[1], 3);
v = 2;
list = list_insert(list, &v, 1);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 3);
cr_assert_eq(list[0], 1);
cr_assert_eq(list[1], 2);
cr_assert_eq(list[2], 3);
list = list_remove(list, 0);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 2);
cr_assert_eq(list[0], 2);
cr_assert_eq(list[1], 3);
list = list_remove(list, 1);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 1);
cr_assert_eq(list[0], 2);
list = list_remove(list, 0);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 0);
list_free(list);
}
Test(list, resize) {
int v;
int *list = list_create(sizeof(int), 4);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 0);
for (int i = 0; i < 4096; i++) {
v = 9182 - i;
list = list_append(list, &v);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), i + 1);
for (int j = 0; j <= i; j++) {
cr_assert_eq(list[j], 9182 - j);
}
}
for (int i = 0; i < 4096; i++) {
list = list_remove(list, -1);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 4096 - i - 1);
for (int j = 0; j < 4096 - i; j++) {
cr_assert_eq(list[j], 9182 - j);
}
}
for (int i = 0; i < 4096; i++) {
v = 47391 - i;
list = list_append(list, &v);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), i + 1);
for (int j = 0; j <= i; j++) {
cr_assert_eq(list[j], 47391 - j);
}
}
list = list_clear(list);
cr_assert_not_null(list);
cr_assert_eq(list_size(list), 0);
list_free(list);
}

6
test/test_utils.c
View File

@@ -72,9 +72,9 @@ ParameterizedTestParameters(utils, format_duration) {
{999999, "1.0 s"}, {999999, "1.0 s"},
{1000000, "1.0 s"}, {1000000, "1.0 s"},
{3000000, "3.0 s"}, {3000000, "3.0 s"},
{1000000 * 60, "1:00 min"}, {1000000 * 60, "1.0 min"},
{1000000 * 60 * 30L - 30000000, "29:30 min"}, {1000000 * 60 * 30L - 30000000, "29.5 min"},
{1000000 * 60 * 60L, "60:00 min"}, {1000000 * 60 * 60L, "60.0 min"},
{1000000 * 60 * 120L, "120 min"}, {1000000 * 60 * 120L, "120 min"},
}; };
return cr_make_param_array(struct format_duration_t, params, sizeof(params) / sizeof(struct format_duration_t)); return cr_make_param_array(struct format_duration_t, params, sizeof(params) / sizeof(struct format_duration_t));