420 lines
12 KiB
C
420 lines
12 KiB
C
/*
|
|
* Design Doc:
|
|
* The server is broken into the following files:
|
|
* - main.c: Argument parsing and high-level control
|
|
* - http.c: HTTP request parsing and response formatting
|
|
* - server.c: Abstraction over sockets
|
|
* - threadpool.c: Thread pool and wokr queue implementation
|
|
* - util.c: Misc. utility functions
|
|
*/
|
|
#include "http.h"
|
|
#include "server.h"
|
|
#include "threadpool.h"
|
|
#include "util.h"
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <pthread.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
typedef struct {
|
|
bool opt_error;
|
|
bool help_flag;
|
|
uint32_t port;
|
|
size_t parallelism;
|
|
const char* address;
|
|
} GlobalFlags;
|
|
|
|
static const GlobalFlags DEFAULT_FLAGS = {
|
|
.opt_error = false,
|
|
.help_flag = false,
|
|
.port = 0,
|
|
.parallelism = 1,
|
|
.address = "127.0.0.1",
|
|
};
|
|
|
|
// Return false on failure, true on success
|
|
static bool parse_uint(const char* str, uintmax_t min, uintmax_t max, uintmax_t* output)
|
|
{
|
|
if (isspace(*str) || *str == '+' || *str == '-') {
|
|
#ifdef BAD_ERROR_REPORTING_FOR_AUTOGRADER
|
|
fprintf(stderr, "Invalid Port\n");
|
|
#else
|
|
log_error("malformed number: \"%s\"", str);
|
|
#endif
|
|
return false;
|
|
}
|
|
errno = 0;
|
|
char* endptr;
|
|
uintmax_t conv = strtoumax(str, &endptr, 10);
|
|
if (!*str || *endptr) {
|
|
#ifdef BAD_ERROR_REPORTING_FOR_AUTOGRADER
|
|
fprintf(stderr, "Invalid Port\n");
|
|
#else
|
|
log_error("malformed number: \"%s\"", str);
|
|
#endif
|
|
return false;
|
|
} else if ((conv == UINTMAX_MAX && errno == ERANGE) || conv < min || conv > max) {
|
|
#ifdef BAD_ERROR_REPORTING_FOR_AUTOGRADER
|
|
fprintf(stderr, "Invalid Port\n");
|
|
#else
|
|
log_error("out of range: %s", str);
|
|
#endif
|
|
return false;
|
|
}
|
|
*output = conv;
|
|
return true;
|
|
}
|
|
|
|
static void parse_cli_options(int argc, const char** argv, GlobalFlags* flags)
|
|
{
|
|
#define MAX_PARALLELISM SIZE_MAX
|
|
#define MAX_PORT 65535
|
|
opterr = false;
|
|
int c;
|
|
char pretty_flag[8];
|
|
while ((c = getopt(argc, (char* const*)argv, ":ha:p:")) >= 0) {
|
|
if (isprint(c)) {
|
|
snprintf(pretty_flag, sizeof(pretty_flag), "%c", optopt);
|
|
} else {
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wformat-truncation"
|
|
// `c` is actually in the range [0,255], and so will be at most 2
|
|
// hex digits
|
|
snprintf(pretty_flag, sizeof(pretty_flag), "0x%02x", optopt);
|
|
#pragma GCC diagnostic pop
|
|
}
|
|
switch (c) {
|
|
case 'h':
|
|
flags->help_flag = true;
|
|
return;
|
|
case 'p': {
|
|
uintmax_t conv;
|
|
if (!parse_uint(optarg, 1, MAX_PARALLELISM, &conv)) {
|
|
flags->opt_error = true;
|
|
}
|
|
flags->parallelism = conv;
|
|
} break;
|
|
case 'a':
|
|
flags->address = optarg;
|
|
break;
|
|
case ':':
|
|
flags->opt_error = true;
|
|
log_error("flag requires argument: '%s'", pretty_flag);
|
|
break;
|
|
case '?':
|
|
flags->opt_error = true;
|
|
log_error("unknown flag: '%s'", pretty_flag);
|
|
break;
|
|
}
|
|
}
|
|
uintmax_t port_conv;
|
|
if (flags->opt_error) {
|
|
return;
|
|
} else if (optind == argc) {
|
|
flags->opt_error = true;
|
|
log_error("no port provided");
|
|
} else if (optind != argc - 1) {
|
|
flags->opt_error = true;
|
|
log_error("extra positional arguments after port");
|
|
} else if (!parse_uint(argv[optind], 1, MAX_PORT, &port_conv)) {
|
|
flags->opt_error = true;
|
|
} else {
|
|
flags->port = port_conv;
|
|
}
|
|
}
|
|
|
|
static void print_help(FILE* file)
|
|
{
|
|
fprintf(file, "usage: httpserver [-h] [-a ADDRESS] [-p PARALLELISM] <PORT>\n");
|
|
fprintf(file, " -h print this message, then exit\n");
|
|
fprintf(file, " -p use PARALLELISM threads for processing requests (default: 1)\n");
|
|
fprintf(file, " -a bind to ADDRESS (default: 127.0.0.1)\n");
|
|
}
|
|
|
|
static const int WORKER_BLOCKED_SIGNALS[] = { SIGTERM, SIGINT, SIGHUP };
|
|
static const size_t N_WORKER_BLOCKED_SIGNALS = sizeof(WORKER_BLOCKED_SIGNALS) / sizeof(int);
|
|
static bool shutdown_flag = false;
|
|
|
|
static void signal_handler(int signal)
|
|
{
|
|
if (shutdown_flag) {
|
|
_exit(signal == SIGTERM ? 0 : EXIT_FAILURE);
|
|
}
|
|
shutdown_flag = true;
|
|
}
|
|
|
|
static void setup_signals()
|
|
{
|
|
struct sigaction pipe_act = {
|
|
.sa_flags = 0,
|
|
.sa_handler = SIG_IGN,
|
|
};
|
|
sigemptyset(&pipe_act.sa_mask);
|
|
if (sigaction(SIGPIPE, &pipe_act, NULL) < 0) {
|
|
log_errno("sigaction");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
struct sigaction act = {
|
|
.sa_handler = signal_handler,
|
|
.sa_flags = 0,
|
|
};
|
|
sigemptyset(&act.sa_mask);
|
|
for (size_t i = 0; i < N_WORKER_BLOCKED_SIGNALS; ++i) {
|
|
if (sigaction(WORKER_BLOCKED_SIGNALS[i], &act, NULL) < 0) {
|
|
log_errno("sigaction");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int parse_result_to_status(HTTPRequestParseResult res)
|
|
{
|
|
switch (res) {
|
|
case HRPR_OK:
|
|
return 200;
|
|
case HRPR_NO_MEM:
|
|
case HRPR_READ_FAILED:
|
|
return 500;
|
|
case HRPR_BAD_VERSION:
|
|
return 505;
|
|
case HRPR_BAD_FORMAT:
|
|
return 400;
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
|
|
static void send_simple_response(FILE* stream, int status)
|
|
{
|
|
size_t status_msg_len;
|
|
const char* status_msg = status_code_to_message(status, &status_msg_len);
|
|
HTTPResponse resp = {
|
|
.status = status,
|
|
.headers = NULL,
|
|
.body_length = status_msg_len + 1,
|
|
};
|
|
format_http_response(stream, &resp);
|
|
write(fileno(stream), status_msg, status_msg_len);
|
|
write(fileno(stream), "\n", 1);
|
|
}
|
|
|
|
static void write_audit_log_entry(HTTPRequest* restrict req, int status)
|
|
{
|
|
fprintf(stderr, "%s,%s,%d,%s\n", req->method, req->uri, status,
|
|
http_header_list_search(req->headers, "Request-ID", "0"));
|
|
}
|
|
|
|
static pthread_mutex_t file_access_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
static void handle_get_request(FILE* conn, HTTPRequest* restrict req)
|
|
{
|
|
int status = 200;
|
|
struct stat statbuf;
|
|
pthread_mutex_lock(&file_access_mutex);
|
|
FILE* file_handle = fopen(req->path, "r");
|
|
if (!file_handle) {
|
|
if (errno == ENOENT) {
|
|
status = 404;
|
|
} else if (errno == EACCES) {
|
|
status = 403;
|
|
} else {
|
|
status = 500;
|
|
}
|
|
}
|
|
if (file_handle && fstat(fileno(file_handle), &statbuf) < 0) {
|
|
status = errno == EACCES ? 403 : 500;
|
|
}
|
|
write_audit_log_entry(req, status);
|
|
pthread_mutex_unlock(&file_access_mutex);
|
|
if (status != 200) {
|
|
if (file_handle) {
|
|
fclose(file_handle);
|
|
}
|
|
send_simple_response(conn, status);
|
|
return;
|
|
}
|
|
HTTPResponse resp = {
|
|
.status = 200,
|
|
.headers = NULL,
|
|
.body_length = statbuf.st_size,
|
|
};
|
|
format_http_response(conn, &resp);
|
|
char read_buf[4096];
|
|
while (!feof(file_handle)) {
|
|
if (ferror(file_handle)) {
|
|
// can't really do anything about it here, just break
|
|
break;
|
|
}
|
|
size_t count = fread(read_buf, 1, sizeof(read_buf), file_handle);
|
|
if (count) {
|
|
write(fileno(conn), read_buf, count);
|
|
}
|
|
}
|
|
fclose(file_handle);
|
|
}
|
|
|
|
static ssize_t get_content_length(HTTPRequest* restrict req)
|
|
{
|
|
const char* text = http_header_list_search(req->headers, "Content-Length", NULL);
|
|
if (!text) {
|
|
return 0;
|
|
} else if (isspace(*text) || *text == '-' || *text == '+') {
|
|
return -1;
|
|
}
|
|
char* endptr;
|
|
uintmax_t conv = strtoumax(text, &endptr, 10);
|
|
if (*endptr || (conv == UINTMAX_MAX && errno == ERANGE) || conv > SIZE_MAX) {
|
|
return -1;
|
|
}
|
|
return conv;
|
|
}
|
|
|
|
static void handle_put_request(FILE* conn, HTTPRequest* restrict req)
|
|
{
|
|
ssize_t content_length = get_content_length(req);
|
|
if (content_length < 0) {
|
|
write_audit_log_entry(req, 400);
|
|
send_simple_response(conn, 400);
|
|
fclose(conn);
|
|
return;
|
|
}
|
|
char temp_file[] = "temp_fileXXXXXX";
|
|
int temp_fd = mkstemp(temp_file);
|
|
if (temp_fd < 0) {
|
|
write_audit_log_entry(req, 500);
|
|
send_simple_response(conn, 500);
|
|
return;
|
|
}
|
|
char read_buff[4096];
|
|
while (content_length) {
|
|
ssize_t read_size = fread(read_buff, 1,
|
|
(size_t)content_length < sizeof(read_buff) ? (size_t)content_length
|
|
: sizeof(read_buff),
|
|
conn);
|
|
if (ferror(conn) || write(temp_fd, read_buff, read_size) < 0) {
|
|
write_audit_log_entry(req, 500);
|
|
send_simple_response(conn, 500);
|
|
close(temp_fd);
|
|
unlink(temp_file);
|
|
return;
|
|
}
|
|
content_length -= read_size;
|
|
}
|
|
close(temp_fd);
|
|
int status;
|
|
bool need_unlink = true;
|
|
pthread_mutex_lock(&file_access_mutex);
|
|
int creat_fd = open(req->path, O_RDONLY | O_CREAT | O_EXCL, 0644);
|
|
if (creat_fd < 0 && errno == EEXIST) {
|
|
// file existed
|
|
status = 200;
|
|
} else if (creat_fd <= 0) {
|
|
// actual error
|
|
status = errno == EACCES ? 403 : 500;
|
|
goto write_status_and_unlock;
|
|
} else {
|
|
// created the file
|
|
status = 201;
|
|
close(creat_fd);
|
|
}
|
|
if (rename(temp_file, req->path) < 0) {
|
|
status = errno == EACCES ? 403 : 500;
|
|
goto write_status_and_unlock;
|
|
}
|
|
need_unlink = false;
|
|
write_status_and_unlock:
|
|
write_audit_log_entry(req, status);
|
|
pthread_mutex_unlock(&file_access_mutex);
|
|
send_simple_response(conn, status);
|
|
if (need_unlink) {
|
|
unlink(temp_file);
|
|
}
|
|
}
|
|
|
|
static void handle_connection(void* arg)
|
|
{
|
|
FILE* conn = arg;
|
|
HTTPRequest req;
|
|
HTTPRequestParseResult res = parse_http_request(conn, &req);
|
|
if (res != HRPR_OK) {
|
|
int status = parse_result_to_status(res);
|
|
write_audit_log_entry(&req, status);
|
|
send_simple_response(conn, status);
|
|
} else if (strchr(req.path, '/')) {
|
|
write_audit_log_entry(&req, 400);
|
|
send_simple_response(conn, 400);
|
|
} else if (strcmp(req.method, "GET") == 0) {
|
|
handle_get_request(conn, &req);
|
|
} else if (strcmp(req.method, "PUT") == 0) {
|
|
handle_put_request(conn, &req);
|
|
} else {
|
|
write_audit_log_entry(&req, 501);
|
|
send_simple_response(conn, 501);
|
|
}
|
|
free_http_request(&req);
|
|
shutdown(fileno(conn), SHUT_RDWR);
|
|
fclose(conn);
|
|
}
|
|
|
|
static void fclose_free_func(void* file)
|
|
{
|
|
fclose(file);
|
|
}
|
|
|
|
int main(int argc, const char** argv)
|
|
{
|
|
setenv("POSIXLY_CORRECT", "1", true);
|
|
GlobalFlags flags = DEFAULT_FLAGS;
|
|
parse_cli_options(argc, argv, &flags);
|
|
if (flags.help_flag) {
|
|
print_help(stdout);
|
|
return flags.opt_error ? EXIT_FAILURE : 0;
|
|
} else if (flags.opt_error) {
|
|
return EXIT_FAILURE;
|
|
}
|
|
sigset_t worker_block_set;
|
|
sigemptyset(&worker_block_set);
|
|
for (size_t i = 0; i < N_WORKER_BLOCKED_SIGNALS; ++i) {
|
|
sigaddset(&worker_block_set, WORKER_BLOCKED_SIGNALS[i]);
|
|
}
|
|
Server* server = make_server(flags.address, flags.port);
|
|
if (!server) {
|
|
return EXIT_FAILURE;
|
|
}
|
|
ThreadPool* pool = make_thread_pool(flags.parallelism, worker_block_set);
|
|
if (!pool) {
|
|
destroy_server(server);
|
|
return EXIT_FAILURE;
|
|
}
|
|
setup_signals();
|
|
while (true) {
|
|
int conn_fd = server_accept(server);
|
|
if (shutdown_flag) {
|
|
if (conn_fd >= 0) {
|
|
close(conn_fd);
|
|
}
|
|
break;
|
|
} else if (conn_fd < 0) {
|
|
continue;
|
|
}
|
|
FILE* conn = fdopen(conn_fd, "r+");
|
|
if (!conn) {
|
|
close(conn_fd);
|
|
continue;
|
|
}
|
|
thread_pool_enqueue(pool, handle_connection, conn, fclose_free_func);
|
|
}
|
|
destroy_thread_pool(pool);
|
|
destroy_server(server);
|
|
return 0;
|
|
}
|