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

Rev proxy working again

Browse Source
This commit is contained in:
Lorenz Stechauner
2022-12-30 18:56:44 +01:00
parent 28d7cf68df
commit 9ad1ecf1da
15 changed files with 208 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/defs.h
View File

@ -14,6 +14,7 @@
#define SERVER_STR_HTML "Sesimos web server " SERVER_VERSION #define SERVER_STR_HTML "Sesimos web server " 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"

176
src/lib/proxy.c
View File

@ -12,6 +12,7 @@
#include "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>
@ -19,18 +20,55 @@
#include <openssl/err.h> #include <openssl/err.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <sys/time.h> #include <sys/time.h>
#include <netdb.h>
static SSL_CTX *proxy_ctx = NULL;
sock proxy; static void *proxies = NULL;
char *proxy_host = NULL;
struct timeval server_timeout = {.tv_sec = SERVER_TIMEOUT, .tv_usec = 0};
int proxy_preload(void) { int proxy_preload(void) {
proxy.ctx = SSL_CTX_new(TLS_client_method()); 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++;
}
// FIXME return value check
proxy_ctx = SSL_CTX_new(TLS_client_method());
proxies = malloc(n * PROXY_ARRAY_SIZE);
memset(proxies, 0, n * PROXY_ARRAY_SIZE);
return 0; return 0;
} }
int proxy_request_header(http_req *req, int enc, client_ctx_t *ctx) { void proxy_unload(void) {
SSL_CTX_free(proxy_ctx);
free(proxies);
}
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++;
}
void *ptr = proxies + n * PROXY_ARRAY_SIZE;
for (int i = 0; i < MAX_PROXY_CNX_PER_HOST; i++, ptr += PROXY_ARRAY_SIZE) {
proxy_ctx_t *ctx = ptr;
if (!ctx->in_use) {
return ctx;
}
}
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;
@ -50,13 +88,13 @@ int proxy_request_header(http_req *req, int enc, client_ctx_t *ctx) {
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(ctx->addr, ':') != NULL; int client_ipv6 = strchr(sock->addr, ':') != NULL;
int server_ipv6 = strchr(ctx->s_addr, ':') != NULL; int server_ipv6 = strchr(sock->s_addr, ':') != NULL;
p_len = snprintf(buf1, sizeof(buf1), "by=%s%s%s;for=%s%s%s;host=%s;proto=%s", p_len = snprintf(buf1, sizeof(buf1), "by=%s%s%s;for=%s%s%s;host=%s;proto=%s",
server_ipv6 ? "\"[" : "", ctx->s_addr, server_ipv6 ? "]\"" : "", server_ipv6 ? "\"[" : "", sock->s_addr, server_ipv6 ? "]\"" : "",
client_ipv6 ? "\"[" : "", ctx->addr, client_ipv6 ? "]\"" : "", client_ipv6 ? "\"[" : "", sock->addr, client_ipv6 ? "]\"" : "",
host, enc ? "https" : "http"); host, sock->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"); error("Appended part of header field 'Forwarded' too long");
return -1; return -1;
@ -76,9 +114,9 @@ int proxy_request_header(http_req *req, int enc, client_ctx_t *ctx) {
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", ctx->addr); http_add_header_field(&req->hdr, "X-Forwarded-For", sock->addr);
} else { } else {
sprintf(buf1, "%s, %s", xff, ctx->addr); sprintf(buf1, "%s, %s", xff, sock->addr);
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);
} }
@ -107,7 +145,7 @@ int proxy_request_header(http_req *req, int enc, client_ctx_t *ctx) {
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", enc ? "https" : "http"); http_add_header_field(&req->hdr, "X-Forwarded-Proto", sock->enc ? "https" : "http");
} else { } else {
char *ptr = strchr(forwarded, ','); char *ptr = strchr(forwarded, ',');
unsigned long len; unsigned long len;
@ -180,36 +218,41 @@ int proxy_response_header(http_req *req, http_res *res, host_config_t *conf) {
return 0; return 0;
} }
int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t *conf, sock *client, client_ctx_t *cctx, http_status *custom_status, char *err_msg) { proxy_ctx_t *proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t *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;
struct timeval server_timeout = {.tv_sec = SERVER_TIMEOUT, .tv_usec = 0};
if (proxy.socket != 0 && strcmp(proxy_host, conf->name) == 0 && sock_check(&proxy) == 0) proxy_ctx_t *proxy = proxy_get_by_conf(conf);
proxy->in_use = 1;
if (proxy->initialized && sock_check(&proxy->proxy) == 0)
goto proxy; goto proxy;
retry: retry:
if (proxy.socket != 0) { if (proxy->initialized) {
info(BLUE_STR "Closing proxy connection"); info(BLUE_STR "Closing proxy connection");
sock_close(&proxy); sock_close(&proxy->proxy);
proxy->initialized = 0;
} }
retry = 0; retry = 0;
tries++; tries++;
proxy.socket = socket(AF_INET6, SOCK_STREAM, 0); proxy->proxy.socket = socket(AF_INET6, SOCK_STREAM, 0);
if (proxy.socket < 0) { if (proxy->proxy.socket < 0) {
error("Unable to create socket"); error("Unable to create socket");
res->status = http_get_status(500); res->status = http_get_status(500);
ctx->origin = INTERNAL; ctx->origin = INTERNAL;
return -1; return NULL;
} }
server_timeout.tv_sec = SERVER_TIMEOUT_INIT; server_timeout.tv_sec = SERVER_TIMEOUT_INIT;
server_timeout.tv_usec = 0; server_timeout.tv_usec = 0;
if (setsockopt(proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0) if (setsockopt(proxy->proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
goto proxy_timeout_err; goto proxy_timeout_err;
if (setsockopt(proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) if (setsockopt(proxy->proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
goto proxy_timeout_err; goto proxy_timeout_err;
struct hostent *host_ent = gethostbyname2(conf->proxy.hostname, AF_INET6); struct hostent *host_ent = gethostbyname2(conf->proxy.hostname, AF_INET6);
@ -236,7 +279,7 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
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); info(BLUE_STR "Connecting to " BLD_STR "[%s]:%i" CLR_STR BLUE_STR "...", buffer, conf->proxy.port);
if (connect(proxy.socket, (struct sockaddr *) &address, sizeof(address)) < 0) { if (connect(proxy->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;
@ -254,9 +297,9 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
server_timeout.tv_sec = SERVER_TIMEOUT; server_timeout.tv_sec = SERVER_TIMEOUT;
server_timeout.tv_usec = 0; server_timeout.tv_usec = 0;
if (setsockopt(proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0) if (setsockopt(proxy->proxy.socket, SOL_SOCKET, SO_RCVTIMEO, &server_timeout, sizeof(server_timeout)) < 0)
goto proxy_timeout_err; goto proxy_timeout_err;
if (setsockopt(proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) { if (setsockopt(proxy->proxy.socket, SOL_SOCKET, SO_SNDTIMEO, &server_timeout, sizeof(server_timeout)) < 0) {
proxy_timeout_err: proxy_timeout_err:
res->status = http_get_status(500); res->status = http_get_status(500);
ctx->origin = INTERNAL; ctx->origin = INTERNAL;
@ -266,25 +309,26 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
} }
if (conf->proxy.enc) { if (conf->proxy.enc) {
proxy.ssl = SSL_new(proxy.ctx); proxy->proxy.ssl = SSL_new(proxy_ctx);
SSL_set_fd(proxy.ssl, proxy.socket); SSL_set_fd(proxy->proxy.ssl, proxy->proxy.socket);
SSL_set_connect_state(proxy.ssl); SSL_set_connect_state(proxy->proxy.ssl);
ret = SSL_do_handshake(proxy.ssl); ret = SSL_do_handshake(proxy->proxy.ssl);
proxy._last_ret = ret; proxy->proxy._last_ret = ret;
proxy._errno = errno; proxy->proxy._errno = errno;
proxy._ssl_error = ERR_get_error(); proxy->proxy._ssl_error = ERR_get_error();
proxy.enc = 1; proxy->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)); error("Unable to perform handshake: %s", sock_strerror(&proxy->proxy));
sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&proxy)); sprintf(err_msg, "Unable to perform handshake: %s.", sock_strerror(&proxy->proxy));
goto proxy_err; goto proxy_err;
} }
} }
proxy_host = conf->name; proxy->initialized = 1;
proxy->host = conf->name;
info(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i", buffer, conf->proxy.port); info(BLUE_STR "Established new connection with " BLD_STR "[%s]:%i", buffer, conf->proxy.port);
proxy: proxy:
@ -297,26 +341,26 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
} else { } else {
res->status = http_get_status(501); res->status = http_get_status(501);
ctx->origin = INTERNAL; ctx->origin = INTERNAL;
return -1; return NULL;
} }
} else { } else {
http_remove_header_field(&req->hdr, "Connection", HTTP_REMOVE_ALL); http_remove_header_field(&req->hdr, "Connection", HTTP_REMOVE_ALL);
http_add_header_field(&req->hdr, "Connection", "keep-alive"); http_add_header_field(&req->hdr, "Connection", "keep-alive");
} }
ret = proxy_request_header(req, (int) client->enc, cctx); ret = proxy_request_header(req, client);
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 NULL;
} }
ret = http_send_request(&proxy, req); ret = http_send_request(&proxy->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)); error("Unable to send request to server (1): %s", sock_strerror(&proxy->proxy));
sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&proxy)); sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&proxy->proxy));
retry = tries < 4; retry = tries < 4;
goto proxy_err; goto proxy_err;
} }
@ -327,17 +371,17 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
ret = 0; ret = 0;
if (content_len > 0) { if (content_len > 0) {
ret = sock_splice(&proxy, client, buffer, sizeof(buffer), content_len); ret = sock_splice(&proxy->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, client, buffer, sizeof(buffer)); ret = sock_splice_chunked(&proxy->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)); error("Unable to send request to server (2): %s", sock_strerror(&proxy->proxy));
sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&proxy)); sprintf(err_msg, "Unable to send request to server: %s.", sock_strerror(&proxy->proxy));
retry = tries < 4; retry = tries < 4;
goto proxy_err; goto proxy_err;
} else if (ret == -2) { } else if (ret == -2) {
@ -345,17 +389,17 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
ctx->origin = CLIENT_REQ; ctx->origin = CLIENT_REQ;
error("Unable to receive request from client: %s", sock_strerror(client)); error("Unable to receive request from client: %s", 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 NULL;
} }
res->status = http_get_status(500); res->status = http_get_status(500);
ctx->origin = INTERNAL; ctx->origin = INTERNAL;
error("Unknown Error"); error("Unknown Error");
return -1; return NULL;
} }
ret = sock_recv(&proxy, buffer, sizeof(buffer), MSG_PEEK); ret = sock_recv(&proxy->proxy, buffer, sizeof(buffer), MSG_PEEK);
if (ret <= 0) { if (ret <= 0) {
int enc_err = sock_enc_error(&proxy); int enc_err = sock_enc_error(&proxy->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)
{ {
@ -365,8 +409,8 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
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)); error("Unable to receive response from server: %s", sock_strerror(&proxy->proxy));
sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&proxy)); sprintf(err_msg, "Unable to receive response from server: %s.", sock_strerror(&proxy->proxy));
retry = tries < 4; retry = tries < 4;
goto proxy_err; goto proxy_err;
} }
@ -440,23 +484,24 @@ int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t
} }
ptr = pos0 + 2; ptr = pos0 + 2;
} }
sock_recv(&proxy, buffer, header_len, 0); sock_recv(&proxy->proxy, buffer, header_len, 0);
ret = proxy_response_header(req, res, conf); ret = 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;
return -1; return NULL;
} }
return 0; return proxy;
proxy_err: proxy_err:
errno = 0;
if (retry) goto retry; if (retry) goto retry;
return -1; return NULL;
} }
int proxy_send(sock *client, unsigned long len_to_send, int flags) { int proxy_send(proxy_ctx_t *proxy, 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;
@ -479,12 +524,12 @@ int proxy_send(sock *client, unsigned long len_to_send, int flags) {
do { do {
snd_len = 0; snd_len = 0;
if (flags & PROXY_CHUNKED) { if (flags & PROXY_CHUNKED) {
ret = sock_get_chunk_header(&proxy); ret = sock_get_chunk_header(&proxy->proxy);
if (ret < 0) { if (ret < 0) {
if (ret == -1) { if (ret == -1) {
error("Unable to receive from server: Malformed chunk header"); error("Unable to receive from server: Malformed chunk header");
} else { } else {
error("Unable to receive from server: %s", sock_strerror(&proxy)); error("Unable to receive from server: %s", sock_strerror(&proxy->proxy));
} }
break; break;
} }
@ -502,9 +547,9 @@ int proxy_send(sock *client, unsigned long len_to_send, int flags) {
} }
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, buffer, CHUNK_SIZE < (len_to_send - snd_len) ? CHUNK_SIZE : len_to_send - snd_len, 0); ret = sock_recv(&proxy->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)); error("Unable to receive from server: %s", sock_strerror(&proxy->proxy));
break; break;
} }
len = ret; len = ret;
@ -544,7 +589,7 @@ int proxy_send(sock *client, unsigned long len_to_send, int flags) {
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, buffer, 2, 0); if (flags & PROXY_CHUNKED) sock_recv(&proxy->proxy, buffer, 2, 0);
} while ((flags & PROXY_CHUNKED) && len_to_send > 0); } while ((flags & PROXY_CHUNKED) && len_to_send > 0);
if (ret <= 0) return -1; if (ret <= 0) return -1;
@ -560,8 +605,7 @@ int proxy_send(sock *client, unsigned long len_to_send, int flags) {
return 0; return 0;
} }
int proxy_dump(char *buf, long len) { int proxy_dump(proxy_ctx_t *proxy, char *buf, long len) {
sock_recv(&proxy, buf, len, 0); sock_recv(&proxy->proxy, buf, len, 0);
sock_close(&proxy);
return 0; return 0;
} }

20
src/lib/proxy.h
View File

@ -18,22 +18,30 @@
# define SERVER_NAME "reverse proxy" # define SERVER_NAME "reverse proxy"
#endif #endif
#define PROXY_ARRAY_SIZE (MAX_PROXY_CNX_PER_HOST * sizeof(proxy_ctx_t))
#include "http.h" #include "http.h"
#include "config.h" #include "config.h"
#include "../server.h"
extern sock proxy; typedef struct {
unsigned char initialized:1;
unsigned char in_use:1;
sock proxy;
char *host;
} proxy_ctx_t;
int proxy_preload(void); int proxy_preload(void);
int proxy_request_header(http_req *req, int enc, client_ctx_t *ctx); void proxy_unload(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_response_header(http_req *req, http_res *res, host_config_t *conf);
int proxy_init(http_req *req, http_res *res, http_status_ctx *ctx, host_config_t *conf, sock *client, client_ctx_t *cctx, http_status *custom_status, char *err_msg); proxy_ctx_t *proxy_init(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(sock *client, unsigned long len_to_send, int flags); int proxy_send(proxy_ctx_t *proxy, sock *client, unsigned long len_to_send, int flags);
int proxy_dump(char *buf, long len); int proxy_dump(proxy_ctx_t *proxy, char *buf, long len);
#endif //SESIMOS_PROXY_H #endif //SESIMOS_PROXY_H

3
src/lib/sock.h
View File

@ -19,7 +19,8 @@ typedef struct {
union { union {
struct sockaddr sock; struct sockaddr sock;
struct sockaddr_in6 ipv6; struct sockaddr_in6 ipv6;
} addr; } _addr;
char *addr, *s_addr;
SSL_CTX *ctx; SSL_CTX *ctx;
SSL *ssl; SSL *ssl;
long _last_ret; long _last_ret;

5
src/server.c
View File

@ -16,6 +16,7 @@
#include "lib/proxy.h" #include "lib/proxy.h"
#include "lib/geoip.h" #include "lib/geoip.h"
#include "workers.h" #include "workers.h"
#include "worker/func.h"
#include <stdio.h> #include <stdio.h>
#include <getopt.h> #include <getopt.h>
@ -70,8 +71,8 @@ static void accept_cb(void *arg) {
sock *client = &client_ctx->socket; sock *client = &client_ctx->socket;
client->ctx = contexts[0]; client->ctx = contexts[0];
socklen_t addr_len = sizeof(client->addr); socklen_t addr_len = sizeof(client->_addr);
int client_fd = accept(fd, &client->addr.sock, &addr_len); int client_fd = accept(fd, &client->_addr.sock, &addr_len);
if (client_fd < 0) { if (client_fd < 0) {
critical("Unable to accept connection"); critical("Unable to accept connection");
return; return;

32
src/server.h
View File

@ -9,16 +9,7 @@
#ifndef SESIMOS_SERVER_H #ifndef SESIMOS_SERVER_H
#define SESIMOS_SERVER_H #define SESIMOS_SERVER_H
#include "lib/sock.h"
#include "lib/http.h"
#include "lib/uri.h"
#include "lib/config.h"
#include "lib/fastcgi.h"
#include <sys/time.h>
#include <maxminddb.h>
#include <signal.h> #include <signal.h>
#include <arpa/inet.h>
#define NUM_SOCKETS 2 #define NUM_SOCKETS 2
#define LISTEN_BACKLOG 16 #define LISTEN_BACKLOG 16
@ -31,29 +22,6 @@
#define CNX_HANDLER_WORKERS 8 #define CNX_HANDLER_WORKERS 8
#define REQ_HANDLER_WORKERS 16 #define REQ_HANDLER_WORKERS 16
typedef struct {
sock socket;
int req_num;
char *addr, *s_addr;
unsigned char in_use: 1, s_keep_alive:1, c_keep_alive:1;
char cc[3], host[256];
char req_host[256], err_msg[256];
char log_prefix[512];
char _c_addr[INET6_ADDRSTRLEN + 1], _s_addr[INET6_ADDRSTRLEN + 1];
struct timespec begin, end;
http_req req;
http_res res;
http_uri uri;
http_status_ctx status;
http_status custom_status;
int use_fastcgi, use_proxy;
host_config_t *conf;
FILE *file;
long content_length;
char msg_buf[8192], msg_content[1024];
} client_ctx_t;
extern volatile sig_atomic_t server_alive; extern volatile sig_atomic_t server_alive;
#endif //SESIMOS_SERVER_H #endif //SESIMOS_SERVER_H

3
src/worker/fastcgi_handler.c
View File

@ -11,6 +11,7 @@
#include "../lib/utils.h" #include "../lib/utils.h"
#include "../lib/compress.h" #include "../lib/compress.h"
#include "../workers.h" #include "../workers.h"
#include "../lib/fastcgi.h"
#include <string.h> #include <string.h>
@ -39,7 +40,7 @@ static int fastcgi_handler_1(client_ctx_t *ctx, fastcgi_cnx_t *fcgi_cnx) {
fcgi_cnx->socket = 0; fcgi_cnx->socket = 0;
fcgi_cnx->req_id = 0; fcgi_cnx->req_id = 0;
fcgi_cnx->r_addr = ctx->addr; fcgi_cnx->r_addr = ctx->socket.addr;
fcgi_cnx->r_host = (ctx->host[0] != 0) ? ctx->host : NULL; fcgi_cnx->r_host = (ctx->host[0] != 0) ? ctx->host : NULL;
char buf[1024]; char buf[1024];

35
src/worker/func.h
View File

@ -9,7 +9,38 @@
#ifndef SESIMOS_FUNC_H #ifndef SESIMOS_FUNC_H
#define SESIMOS_FUNC_H #define SESIMOS_FUNC_H
#include "../server.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;
char cc[3], host[256];
char req_host[256], err_msg[256];
char log_prefix[512];
char _c_addr[INET6_ADDRSTRLEN + 1], _s_addr[INET6_ADDRSTRLEN + 1];
struct timespec begin, end;
http_req req;
http_res res;
http_uri uri;
http_status_ctx status;
http_status custom_status;
int use_fastcgi, use_proxy;
host_config_t *conf;
FILE *file;
long content_length;
char msg_buf[8192], msg_content[1024];
proxy_ctx_t *proxy;
} client_ctx_t;
typedef struct {
client_ctx_t *client;
sock *s1, *s2, *s, *r;
} ws_ctx_t;
void tcp_acceptor_func(client_ctx_t *ctx); void tcp_acceptor_func(client_ctx_t *ctx);
@ -23,7 +54,7 @@ void fastcgi_handler_func(client_ctx_t *ctx);
void proxy_handler_func(client_ctx_t *ctx); void proxy_handler_func(client_ctx_t *ctx);
void ws_frame_handler_func(client_ctx_t *ctx); void ws_frame_handler_func(ws_ctx_t *ctx);
int respond(client_ctx_t *ctx); int respond(client_ctx_t *ctx);

1
src/worker/local_handler.c
View File

@ -44,6 +44,7 @@ static int local_handler(client_ctx_t *ctx) {
int accept_if_modified_since = 0; int accept_if_modified_since = 0;
if (strcmp(req->method, "TRACE") == 0) { if (strcmp(req->method, "TRACE") == 0) {
// FIXME not working?
res->status = http_get_status(200); res->status = http_get_status(200);
http_add_header_field(&res->hdr, "Content-Type", "message/http"); http_add_header_field(&res->hdr, "Content-Type", "message/http");

14
src/worker/proxy_handler.c
View File

@ -31,11 +31,7 @@ void proxy_handler_func(client_ctx_t *ctx) {
static int proxy_handler_1(client_ctx_t *ctx) { static int proxy_handler_1(client_ctx_t *ctx) {
http_res *res = &ctx->res; http_res *res = &ctx->res;
http_req *req = &ctx->req;
http_uri *uri = &ctx->uri;
http_status_ctx *status = &ctx->status; http_status_ctx *status = &ctx->status;
sock *client = &ctx->socket;
char *err_msg = ctx->err_msg;
char buf[1024]; char buf[1024];
@ -43,8 +39,8 @@ static int proxy_handler_1(client_ctx_t *ctx) {
http_remove_header_field(&res->hdr, "Date", HTTP_REMOVE_ALL); 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, "Server", HTTP_REMOVE_ALL);
int ret = proxy_init(req, res, status, ctx->conf, client, ctx, &ctx->custom_status, err_msg); ctx->proxy = proxy_init(&ctx->req, res, status, ctx->conf, &ctx->socket, &ctx->custom_status, ctx->err_msg);
ctx->use_proxy = (ret == 0); ctx->use_proxy = (ctx->proxy != NULL);
if (res->status->code == 101) { if (res->status->code == 101) {
const char *connection = http_get_header_field(&res->hdr, "Connection"); const char *connection = http_get_header_field(&res->hdr, "Connection");
@ -77,7 +73,7 @@ static int proxy_handler_1(client_ctx_t *ctx) {
status->origin = res->status->code >= 400 ? SERVER : NONE; status->origin = res->status->code >= 400 ? SERVER : NONE;
} }
ctx->use_proxy = 0; ctx->use_proxy = 0;
proxy_dump(ctx->msg_content, content_len); proxy_dump(ctx->proxy, ctx->msg_content, content_len);
} }
} }
} }
@ -120,7 +116,9 @@ static int proxy_handler_2(client_ctx_t *ctx) {
} }
int flags = (chunked ? PROXY_CHUNKED : 0) | (ctx->use_proxy & PROXY_COMPRESS); int flags = (chunked ? PROXY_CHUNKED : 0) | (ctx->use_proxy & PROXY_COMPRESS);
int ret = proxy_send(&ctx->socket, len_to_send, flags); int ret = proxy_send(ctx->proxy, &ctx->socket, len_to_send, flags);
ctx->proxy->in_use = 0;
ctx->proxy = NULL;
if (ret < 0) { if (ret < 0) {
ctx->c_keep_alive = 0; ctx->c_keep_alive = 0;

31
src/worker/request_handler.c
View File

@ -12,18 +12,17 @@
#include "../lib/mpmc.h" #include "../lib/mpmc.h"
#include "../logger.h" #include "../logger.h"
#include "../lib/utils.h" #include "../lib/utils.h"
#include "../lib/proxy.h"
#include "../lib/websocket.h" #include "../lib/websocket.h"
#include "../server.h"
#include <string.h> #include <string.h>
#include <openssl/err.h> #include <openssl/err.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <unistd.h>
static int request_handler(client_ctx_t *ctx); static int request_handler(client_ctx_t *ctx);
void request_handler_func(client_ctx_t *ctx) { void request_handler_func(client_ctx_t *ctx) {
logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->s_addr, ctx->log_prefix); logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
switch (request_handler(ctx)) { switch (request_handler(ctx)) {
case 0: case 0:
@ -51,8 +50,15 @@ static int request_handler(client_ctx_t *ctx) {
err_msg[0] = 0; err_msg[0] = 0;
ctx->file = NULL;
ctx->proxy = NULL;
ctx->use_fastcgi = 0; ctx->use_fastcgi = 0;
ctx->use_proxy = 0; ctx->use_proxy = 0;
ctx->proxy = NULL;
ctx->msg_content[0] = 0;
ctx->msg_buf[0] = 0;
ctx->req_host[0] = 0;
ctx->err_msg[0] = 0;
http_res *res = &ctx->res; http_res *res = &ctx->res;
res->status = http_get_status(501); res->status = http_get_status(501);
@ -67,18 +73,19 @@ static int request_handler(client_ctx_t *ctx) {
clock_gettime(CLOCK_MONOTONIC, &ctx->begin); clock_gettime(CLOCK_MONOTONIC, &ctx->begin);
//ret = sock_poll_read(&client, NULL, NULL, 1, NULL, NULL, CLIENT_TIMEOUT * 1000); // FIXME async poll
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, "Date", http_get_date(buf0, sizeof(buf0)));
http_add_header_field(&res->hdr, "Server", SERVER_STR); http_add_header_field(&res->hdr, "Server", SERVER_STR);
/*if (ret <= 0) { if (ret <= 0) {
if (errno != 0) return 0; if (errno != 0) return 0;
ctx->c_keep_alive = 0; ctx->c_keep_alive = 0;
res->status = http_get_status(408); res->status = http_get_status(408);
return 0; return 0;
}*/ }
//clock_gettime(CLOCK_MONOTONIC, &begin); clock_gettime(CLOCK_MONOTONIC, &ctx->begin);
http_req *req = &ctx->req; http_req *req = &ctx->req;
ret = http_receive_request(client, req); ret = http_receive_request(client, req);
@ -110,10 +117,10 @@ static int request_handler(client_ctx_t *ctx) {
sprintf(err_msg, "Host header field is too long."); sprintf(err_msg, "Host header field is too long.");
return 0; return 0;
} else if (host_ptr == NULL || strchr(host_ptr, '/') != NULL) { } else if (host_ptr == NULL || strchr(host_ptr, '/') != NULL) {
if (strchr(ctx->addr, ':') == NULL) { if (strchr(ctx->socket.addr, ':') == NULL) {
strcpy(ctx->req_host, ctx->addr); strcpy(ctx->req_host, ctx->socket.addr);
} else { } else {
sprintf(ctx->req_host, "[%s]", ctx->addr); sprintf(ctx->req_host, "[%s]", ctx->socket.addr);
} }
res->status = http_get_status(400); res->status = http_get_status(400);
sprintf(err_msg, "The client provided no or an invalid Host header field."); sprintf(err_msg, "The client provided no or an invalid Host header field.");
@ -303,7 +310,7 @@ int respond(client_ctx_t *ctx) {
if (ctx->use_proxy == 2) { if (ctx->use_proxy == 2) {
// WebSocket // WebSocket
info("Upgrading connection to WebSocket connection"); info("Upgrading connection to WebSocket connection");
ret = ws_handle_connection(client, &proxy); ret = ws_handle_connection(client, &ctx->proxy->proxy);
if (ret != 0) { if (ret != 0) {
ctx->c_keep_alive = 0; ctx->c_keep_alive = 0;
close_proxy = 1; close_proxy = 1;
@ -335,7 +342,7 @@ int respond(client_ctx_t *ctx) {
} else if (ctx->use_fastcgi) { } else if (ctx->use_fastcgi) {
return 2; return 2;
} else if (ctx->use_proxy) { } else if (ctx->use_proxy) {
return 3; return 3;
} }
if (ret < 0) { if (ret < 0) {

23
src/worker/tcp_acceptor.c
View File

@ -13,6 +13,7 @@
#include "../lib/utils.h" #include "../lib/utils.h"
#include "../lib/geoip.h" #include "../lib/geoip.h"
#include "../workers.h" #include "../workers.h"
#include "../server.h"
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
@ -32,27 +33,27 @@ void tcp_acceptor_func(client_ctx_t *ctx) {
static int tcp_acceptor(client_ctx_t *ctx) { static int tcp_acceptor(client_ctx_t *ctx) {
struct sockaddr_in6 server_addr; 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)); inet_ntop(ctx->socket._addr.ipv6.sin6_family, &ctx->socket._addr.ipv6.sin6_addr, ctx->_c_addr, sizeof(ctx->_c_addr));
if (strncmp(ctx->_c_addr, "::ffff:", 7) == 0) { if (strncmp(ctx->_c_addr, "::ffff:", 7) == 0) {
ctx->addr = ctx->_c_addr + 7; ctx->socket.addr = ctx->_c_addr + 7;
} else { } else {
ctx->addr = ctx->_c_addr; ctx->socket.addr = ctx->_c_addr;
} }
socklen_t len = sizeof(server_addr); socklen_t len = sizeof(server_addr);
getsockname(ctx->socket.socket, (struct sockaddr *) &server_addr, &len); 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)); inet_ntop(server_addr.sin6_family, (void *) &server_addr.sin6_addr, ctx->_s_addr, sizeof(ctx->_s_addr));
if (strncmp(ctx->_s_addr, "::ffff:", 7) == 0) { if (strncmp(ctx->_s_addr, "::ffff:", 7) == 0) {
ctx->s_addr = ctx->_s_addr + 7; ctx->socket.s_addr = ctx->_s_addr + 7;
} else { } else {
ctx->s_addr = ctx->_s_addr; 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, 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->addr, ntohs(server_addr.sin6_port), CLR_STR, /*color_table[0]*/ "", INET6_ADDRSTRLEN, ctx->socket.addr,
ntohs(ctx->socket.addr.ipv6.sin6_port), CLR_STR); ntohs(ctx->socket._addr.ipv6.sin6_port), CLR_STR);
logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->s_addr, ctx->log_prefix); logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
int ret; int ret;
char buf[1024]; char buf[1024];
@ -61,7 +62,7 @@ static int tcp_acceptor(client_ctx_t *ctx) {
clock_gettime(CLOCK_MONOTONIC, &ctx->begin); clock_gettime(CLOCK_MONOTONIC, &ctx->begin);
if (config.dns_server[0] != 0) { if (config.dns_server[0] != 0) {
sprintf(buf, "dig @%s +short +time=1 -x %s", config.dns_server, ctx->addr); sprintf(buf, "dig @%s +short +time=1 -x %s", config.dns_server, ctx->socket.addr);
FILE *dig = popen(buf, "r"); FILE *dig = popen(buf, "r");
if (dig == NULL) { if (dig == NULL) {
error("Unable to start dig: %s", strerror(errno)); error("Unable to start dig: %s", strerror(errno));
@ -85,9 +86,9 @@ static int tcp_acceptor(client_ctx_t *ctx) {
} }
ctx->cc[0] = 0; ctx->cc[0] = 0;
geoip_lookup_country(&client->addr.sock, ctx->cc); geoip_lookup_country(&client->_addr.sock, ctx->cc);
info("Connection accepted from %s %s%s%s[%s]", ctx->addr, ctx->host[0] != 0 ? "(" : "", 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->host[0] != 0 ? ctx->host : "", ctx->host[0] != 0 ? ") " : "",
ctx->cc[0] != 0 ? ctx->cc : "N/A"); ctx->cc[0] != 0 ? ctx->cc : "N/A");

2
src/worker/tcp_closer.c
View File

@ -13,7 +13,7 @@
#include <memory.h> #include <memory.h>
void tcp_closer_func(client_ctx_t *ctx) { void tcp_closer_func(client_ctx_t *ctx) {
logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->s_addr, ctx->log_prefix); logger_set_prefix("[%*s]%s", INET6_ADDRSTRLEN, ctx->socket.s_addr, ctx->log_prefix);
sock_close(&ctx->socket); sock_close(&ctx->socket);

6
src/worker/ws_frame_handler.c
View File

@ -8,12 +8,12 @@
#include "func.h" #include "func.h"
static int ws_frame_handler(client_ctx_t *ctx); static int ws_frame_handler(ws_ctx_t *ctx);
void ws_frame_handler_func(client_ctx_t *ctx) { void ws_frame_handler_func(ws_ctx_t *ctx) {
} }
static int ws_frame_handler(client_ctx_t *ctx) { static int ws_frame_handler(ws_ctx_t *ctx) {
return 0; return 0;
} }

2
src/workers.h
View File

@ -9,7 +9,7 @@
#ifndef SESIMOS_WORKERS_H #ifndef SESIMOS_WORKERS_H
#define SESIMOS_WORKERS_H #define SESIMOS_WORKERS_H
#include "server.h" #include "worker/func.h"
int workers_init(void); int workers_init(void);