533 lines
21 KiB
C
533 lines
21 KiB
C
/**
|
|
* Necronda Web Server
|
|
* Client connection and request handlers
|
|
* src/client.c
|
|
* Lorenz Stechauner, 2020-12-03
|
|
*/
|
|
|
|
#include "necronda-server.h"
|
|
#include "utils.h"
|
|
#include "uri.h"
|
|
#include "http.h"
|
|
#include "fastcgi.h"
|
|
|
|
|
|
int server_keep_alive = 1;
|
|
char *client_addr_str, *client_addr_str_ptr, *server_addr_str, *server_addr_str_ptr,
|
|
*log_client_prefix, *log_conn_prefix, *log_req_prefix,
|
|
*client_host_str;
|
|
|
|
struct timeval client_timeout = {.tv_sec = CLIENT_TIMEOUT, .tv_usec = 0};
|
|
|
|
char *get_webroot(const char *http_host) {
|
|
char *webroot = malloc(strlen(webroot_base) + strlen(http_host) + 1);
|
|
unsigned long len = strlen(webroot_base);
|
|
while (webroot_base[len - 1] == '/') len--;
|
|
long pos = strchr(http_host, ':') - http_host;
|
|
sprintf(webroot, "%.*s/%.*s", (int) len, webroot_base, (int) (pos < 0 ? strlen(http_host) : pos), http_host);
|
|
return webroot;
|
|
}
|
|
|
|
void client_terminate() {
|
|
server_keep_alive = 0;
|
|
}
|
|
|
|
int client_websocket_handler() {
|
|
// TODO implement client_websocket_handler
|
|
return 0;
|
|
}
|
|
|
|
int client_request_handler(sock *client, unsigned long client_num, unsigned int req_num) {
|
|
struct timespec begin, end;
|
|
int ret, client_keep_alive, dir_mode;
|
|
char buf0[1024], buf1[1024];
|
|
char msg_buf[4096], msg_pre_buf[4096], err_msg[256];
|
|
char buffer[CHUNK_SIZE];
|
|
err_msg[0] = 0;
|
|
char *host, *hdr_connection, *webroot;
|
|
long content_length = 0;
|
|
FILE *file = NULL;
|
|
msg_buf[0] = 0;
|
|
int accept_if_modified_since = 0;
|
|
int use_fastcgi = 0;
|
|
fastcgi_conn php_fpm = {.socket = 0, .req_id = 0};
|
|
|
|
http_res res;
|
|
sprintf(res.version, "1.1");
|
|
res.status = http_get_status(501);
|
|
res.hdr.field_num = 0;
|
|
http_add_header_field(&res.hdr, "Date", http_get_date(buf0, sizeof(buf0)));
|
|
http_add_header_field(&res.hdr, "Server", SERVER_STR);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &begin);
|
|
|
|
fd_set socket_fds;
|
|
FD_ZERO(&socket_fds);
|
|
FD_SET(client->socket, &socket_fds);
|
|
client_timeout.tv_sec = CLIENT_TIMEOUT;
|
|
client_timeout.tv_usec = 0;
|
|
ret = select(client->socket + 1, &socket_fds, NULL, NULL, &client_timeout);
|
|
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 header: Invalid header format.");
|
|
} else if (ret == 2) {
|
|
sprintf(err_msg, "Unable to parse header: Invalid method.");
|
|
} else if (ret == 3) {
|
|
sprintf(err_msg, "Unable to parse header: Invalid version.");
|
|
} else if (ret == 4) {
|
|
sprintf(err_msg, "Unable to parse header: Header contains illegal characters.");
|
|
} else if (ret == 5) {
|
|
sprintf(err_msg, "Unable to parse 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 && strncmp(hdr_connection, "keep-alive", 10) == 0;
|
|
host = http_get_header_field(&req.hdr, "Host");
|
|
if (host == NULL || strchr(host, '/') != NULL) {
|
|
res.status = http_get_status(400);
|
|
sprintf(err_msg, "The client provided no or an invalid Host header field.");
|
|
goto respond;
|
|
}
|
|
|
|
sprintf(log_req_prefix, "[%s%24s%s]%s ", BLD_STR, host, CLR_STR, log_client_prefix);
|
|
log_prefix = log_req_prefix;
|
|
print(BLD_STR "%s %s" CLR_STR, req.method, req.uri);
|
|
|
|
webroot = get_webroot(host);
|
|
if (webroot == NULL) {
|
|
res.status = http_get_status(307);
|
|
sprintf(buf0, "https://%s%s", NECRONDA_DEFAULT, req.uri);
|
|
http_add_header_field(&req.hdr, "Location", buf0);
|
|
goto respond;
|
|
}
|
|
|
|
dir_mode = URI_DIR_MODE_FORBIDDEN;
|
|
http_uri uri;
|
|
ret = uri_init(&uri, webroot, req.uri, dir_mode);
|
|
if (ret != 0) {
|
|
if (ret == 1) {
|
|
sprintf(err_msg, "Invalid URI: has to start with slash.");
|
|
} else if (ret == 2) {
|
|
sprintf(err_msg, "Invalid URI: contains relative path change (/../).");
|
|
}
|
|
res.status = http_get_status(400);
|
|
goto respond;
|
|
}
|
|
|
|
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 = sizeof(buf0);
|
|
encode_url(uri.uri, buf0, &size);
|
|
if (change_proto) {
|
|
sprintf(buf1, "https://%s%s", host, buf0);
|
|
http_add_header_field(&res.hdr, "Location", buf1);
|
|
} else {
|
|
http_add_header_field(&res.hdr, "Location", buf0);
|
|
}
|
|
goto respond;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
if (uri.is_static) {
|
|
res.status = http_get_status(200);
|
|
http_add_header_field(&res.hdr, "Allow", "GET, HEAD");
|
|
http_add_header_field(&res.hdr, "Accept-Ranges", "bytes");
|
|
if (strncmp(req.method, "GET", 3) != 0 && strncmp(req.method, "HEAD", 4) != 0) {
|
|
res.status = http_get_status(405);
|
|
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;
|
|
}
|
|
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);
|
|
if (uri.meta->etag[0] != 0) {
|
|
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");
|
|
}
|
|
|
|
char *if_modified_since = http_get_header_field(&req.hdr, "If-Modified-Since");
|
|
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 && strncmp(if_modified_since, last_modified, strlen(last_modified)) == 0)) {
|
|
res.status = http_get_status(304);
|
|
goto respond;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
char *accept_encoding = http_get_header_field(&req.hdr, "Accept-Encoding");
|
|
if (uri.meta->filename_comp[0] != 0 && accept_encoding != NULL && strstr(accept_encoding, "deflate") != NULL) {
|
|
file = fopen(uri.meta->filename_comp, "rb");
|
|
if (file == NULL) {
|
|
cache_filename_comp_invalid(uri.filename);
|
|
goto not_compressed;
|
|
}
|
|
http_add_header_field(&res.hdr, "Content-Encoding", "deflate");
|
|
} else {
|
|
not_compressed:
|
|
file = fopen(uri.filename, "rb");
|
|
}
|
|
fseek(file, 0, SEEK_END);
|
|
content_length = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
} else {
|
|
struct stat statbuf;
|
|
stat(uri.filename, &statbuf);
|
|
char *last_modified = http_format_date(statbuf.st_mtime, buf0, sizeof(buf0));
|
|
http_add_header_field(&res.hdr, "Last-Modified", last_modified);
|
|
|
|
res.status = http_get_status(200);
|
|
if (fastcgi_init(&php_fpm, client_num, req_num, client, &req, &uri) != 0) {
|
|
res.status = http_get_status(502);
|
|
sprintf(err_msg, "Unable to communicate with PHP-FPM.");
|
|
goto respond;
|
|
}
|
|
|
|
if (strncmp(req.method, "POST", 4) == 0 || strncmp(req.method, "PUT", 3) == 0) {
|
|
char *client_content_length = http_get_header_field(&req.hdr, "Content-Length");
|
|
unsigned long client_content_len = 0;
|
|
if (client_content_length == NULL) {
|
|
goto fastcgi_end;
|
|
}
|
|
client_content_len = strtoul(client_content_length, NULL, 10);
|
|
ret = fastcgi_receive(&php_fpm, client, client_content_len);
|
|
if (ret != 0) {
|
|
if (ret < 0) {
|
|
goto abort;
|
|
} else {
|
|
sprintf(err_msg, "Unable to communicate with PHP-FPM.");
|
|
}
|
|
res.status = http_get_status(502);
|
|
goto respond;
|
|
}
|
|
}
|
|
fastcgi_end:
|
|
fastcgi_close_stdin(&php_fpm);
|
|
|
|
ret = fastcgi_header(&php_fpm, &res, err_msg);
|
|
if (ret != 0) {
|
|
if (ret < 0) {
|
|
goto abort;
|
|
} else {
|
|
sprintf(err_msg, "Unable to communicate with PHP-FPM.");
|
|
}
|
|
res.status = http_get_status(502);
|
|
goto respond;
|
|
}
|
|
char *status = http_get_header_field(&res.hdr, "Status");
|
|
if (status != NULL) {
|
|
res.status = http_get_status(strtoul(status, NULL, 10));
|
|
http_remove_header_field(&res.hdr, "Status", HTTP_REMOVE_ALL);
|
|
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;
|
|
}
|
|
}
|
|
|
|
char *accept_encoding = http_get_header_field(&req.hdr, "Accept-Encoding");
|
|
if (accept_encoding != NULL && strstr(accept_encoding, "deflate") != NULL) {
|
|
http_add_header_field(&res.hdr, "Content-Encoding", "deflate");
|
|
}
|
|
|
|
content_length = -1;
|
|
use_fastcgi = 1;
|
|
if (http_get_header_field(&res.hdr, "Content-Length") == NULL) {
|
|
http_add_header_field(&res.hdr, "Transfer-Encoding", "chunked");
|
|
}
|
|
|
|
}
|
|
|
|
respond:
|
|
if (http_get_header_field(&res.hdr, "Accept-Ranges") == NULL) {
|
|
http_add_header_field(&res.hdr, "Accept-Ranges", "none");
|
|
}
|
|
if (!use_fastcgi && file == NULL && res.status->code >= 400 && res.status->code < 600) {
|
|
http_error_msg *http_msg = http_get_error_msg(res.status->code);
|
|
sprintf(msg_pre_buf, http_error_document, res.status->code, res.status->msg,
|
|
http_msg != NULL ? http_msg->err_msg : "", err_msg[0] != 0 ? err_msg : "");
|
|
content_length = sprintf(msg_buf, http_default_document, res.status->code, res.status->msg,
|
|
msg_pre_buf, res.status->code >= 300 && res.status->code < 400 ? "info" : "error",
|
|
http_error_icon, "#C00000");
|
|
http_add_header_field(&res.hdr, "Content-Type", "text/html; charset=UTF-8");
|
|
}
|
|
if (content_length >= 0) {
|
|
sprintf(buf0, "%li", content_length);
|
|
http_add_header_field(&res.hdr, "Content-Length", buf0);
|
|
} else if (http_get_header_field(&res.hdr, "Transfer-Encoding") == NULL) {
|
|
server_keep_alive = 0;
|
|
}
|
|
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);
|
|
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%03i %s%s%s (%s)%s", http_get_status_color(res.status), res.status->code, res.status->msg,
|
|
location != NULL ? " -> " : "", location != NULL ? location : "", format_duration(micros, buf0), CLR_STR);
|
|
|
|
if (strncmp(req.method, "HEAD", 4) != 0) {
|
|
unsigned long snd_len = 0;
|
|
unsigned long len = 0;
|
|
if (msg_buf[0] != 0) {
|
|
while (snd_len < content_length) {
|
|
if (client->enc) {
|
|
ret = SSL_write(client->ssl, msg_buf, (int) (content_length - snd_len));
|
|
if (ret <= 0) {
|
|
print(ERR_STR "Unable to send: %s" CLR_STR, ssl_get_error(client->ssl, ret));
|
|
}
|
|
} else {
|
|
ret = send(client->socket, msg_buf, content_length - snd_len, 0);
|
|
if (ret <= 0) {
|
|
print(ERR_STR "Unable to send: %s" CLR_STR, strerror(errno));
|
|
}
|
|
}
|
|
if (ret <= 0) {
|
|
break;
|
|
}
|
|
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;
|
|
}
|
|
if (client->enc) {
|
|
ret = SSL_write(client->ssl, buffer, (int) len);
|
|
if (ret <= 0) {
|
|
print(ERR_STR "Unable to send: %s" CLR_STR, ssl_get_error(client->ssl, ret));
|
|
}
|
|
} else {
|
|
ret = send(client->socket, buffer, len, 0);
|
|
if (ret <= 0) {
|
|
print(ERR_STR "Unable to send: %s" CLR_STR, strerror(errno));
|
|
}
|
|
}
|
|
if (ret <= 0) {
|
|
break;
|
|
}
|
|
snd_len += ret;
|
|
}
|
|
} else if (use_fastcgi) {
|
|
char *transfer_encoding = http_get_header_field(&res.hdr, "Transfer-Encoding");
|
|
int chunked = transfer_encoding != NULL && strncmp(transfer_encoding, "chunked", 7) == 0;
|
|
char *content_encoding = http_get_header_field(&res.hdr, "Content-Encoding");
|
|
int comp = content_encoding != NULL && strncmp(content_encoding, "deflate", 7) == 0;
|
|
int flags = (chunked ? FASTCGI_CHUNKED : 0) | (comp ? FASTCGI_COMPRESS : 0);
|
|
fastcgi_send(&php_fpm, client, flags);
|
|
}
|
|
}
|
|
|
|
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 (php_fpm.socket != 0) close(php_fpm.socket);
|
|
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[16];
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &begin);
|
|
|
|
// TODO get geoip data for ip address
|
|
// TODO Reverse DNS request
|
|
client_host_str = client_addr_str;
|
|
|
|
print("Connection accepted from %s (%s) [%s]", client_addr_str, client_host_str, "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);
|
|
if (ret <= 0) {
|
|
print(ERR_STR "Unable to perform handshake: %s" CLR_STR, ssl_get_error(client->ssl, ret));
|
|
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:
|
|
if (client->enc) {
|
|
SSL_shutdown(client->ssl);
|
|
SSL_free(client->ssl);
|
|
}
|
|
shutdown(client->socket, SHUT_RDWR);
|
|
close(client->socket);
|
|
|
|
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], INET_ADDRSTRLEN, client_addr_str,
|
|
ntohs(client_addr->sin6_port), CLR_STR);
|
|
|
|
log_conn_prefix = malloc(256);
|
|
sprintf(log_conn_prefix, "[%24s]%s ", 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);
|
|
free(server_addr_str_ptr);
|
|
free(log_conn_prefix);
|
|
free(log_req_prefix);
|
|
free(log_client_prefix);
|
|
return ret;
|
|
}
|