Fix last commit

.clang-format

@@ -0,0 +1,25 @@
+---
+BasedOnStyle: WebKit
+IndentWidth: 4
+---
+Language: Cpp
+AlignConsecutiveMacros: true
+AlignEscapedNewlines: Right
+AlignOperands: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: Never
+ColumnLimit: 100
+IncludeBlocks: Regroup
+IndentCaseLabels: false
+IndentWrappedFunctionNames: true
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: false
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceBeforeAssignmentOperators: true
+SpaceAfterControlStatementKeyword: true
+BreakBeforeBraces: Attach
+---

Makefile

@@ -11,9 +11,9 @@ httpserver: $(OBJS)
 	$(CC) $(CFLAGS) -o $@ $^
 
 # Auto-rebuild if Makefile changes
-bin/%.o: src/%.c Makefile
+bin/%.o: %.c Makefile
 	@mkdir -p bin/deps/
-	$(CC) $(CFLAGS) -MD -MF $(patsubst src/%.c,bin/deps/%.d,$<) -c -o $@ $<
+	$(CC) $(CFLAGS) -MD -MF $(patsubst %.c,bin/deps/%.d,$<) -c -o $@ $<
 
 include $(SRCS:%.c/bin/deps/%.d)
 

http.c

@@ -8,7 +8,8 @@
 static const char* EMPTY_STRING = "";
 
 HTTPHeaderList* http_header_list_push(HTTPHeaderList* list, const char* key,
-                                      const char *value) {
+    const char* value)
+{
     HTTPHeaderList* new = malloc(sizeof(HTTPHeaderList));
     if (!new) {
         return NULL;
@@ -32,7 +33,8 @@ HTTPHeaderList *http_header_list_push(HTTPHeaderList *list, const char *key,
     return new;
 }
 
-void free_http_header_list(HTTPHeaderList *list) {
+void free_http_header_list(HTTPHeaderList* list)
+{
     while (list) {
         HTTPHeaderList* next = list->next;
         free(list->key);
@@ -43,7 +45,8 @@ void free_http_header_list(HTTPHeaderList *list) {
 }
 
 const char* http_header_list_search(HTTPHeaderList* list, const char* key,
-                                    const char *def) {
+    const char* def)
+{
     while (list) {
         if (strcmp(list->key, key) == 0) {
             return list->value;
@@ -68,7 +71,8 @@ const char *http_header_list_search(HTTPHeaderList *list, const char *key,
 // if an error occured, req->uri is not allocated
 static HTTPRequestParseResult parse_method_uri_line(FILE* stream,
     size_t* restrict bytes_read,
-                                                    HTTPRequest *restrict req) {
+    HTTPRequest* restrict req)
+{
     // allow for some leeway in passing incorrect methods
     char method[MAX_METHOD_LENGTH + 1];
     char uri[MAX_URI_LENGTH + 1];
@@ -115,7 +119,8 @@ static HTTPRequestParseResult parse_method_uri_line(FILE *stream,
 // this will *not* free LIST if an error occurs
 static bool next_header(FILE* stream, size_t* restrict bytes_read,
     HTTPRequestParseResult* restrict res,
-                        HTTPHeaderList *restrict *restrict list) {
+    HTTPHeaderList* restrict* restrict list)
+{
     char c = fgetc(stream);
     RETURN_IF_READ_ERROR(stream);
     if (c == '\r') {
@@ -136,8 +141,7 @@ static bool next_header(FILE *stream, size_t *restrict bytes_read,
     ssize_t signed_bytes_read;
 #define S1(s) #s
 #define S(s) S1(s)
-    int nconv =
+    int nconv = fscanf(stream,
-        fscanf(stream,
         // clang-format off
                "%" S(MAX_HEADER_KEY_LENGTH) "[a-zA-Z0-9.-]"
                ":%c"
@@ -162,7 +166,8 @@ static bool next_header(FILE *stream, size_t *restrict bytes_read,
 }
 
 HTTPRequestParseResult parse_http_request(FILE* stream,
-                                          HTTPRequest *restrict out) {
+    HTTPRequest* restrict out)
+{
     out->uri = EMPTY_STRING;
     out->path = EMPTY_STRING;
     out->method = EMPTY_STRING;
@@ -182,7 +187,8 @@ HTTPRequestParseResult parse_http_request(FILE *stream,
     return res;
 }
 
-void free_http_request(HTTPRequest *restrict req) {
+void free_http_request(HTTPRequest* restrict req)
+{
     if (req->method != EMPTY_STRING) {
         free((char*)req->method);
     }
@@ -192,7 +198,8 @@ void free_http_request(HTTPRequest *restrict req) {
     free_http_header_list(req->headers);
 }
 
-const char *status_code_to_message(int status, size_t *restrict length) {
+const char* status_code_to_message(int status, size_t* restrict length)
+{
     static const struct {
         int code;
         const char* msg;
@@ -221,7 +228,8 @@ const char *status_code_to_message(int status, size_t *restrict length) {
     return NULL;
 }
 
-void format_http_response(FILE *stream, HTTPResponse *restrict resp) {
+void format_http_response(FILE* stream, HTTPResponse* restrict resp)
+{
     assert(status_code_to_message(resp->status, NULL));
     fprintf(stream, "HTTP/1.1 %d %s\r\n", resp->status,
         status_code_to_message(resp->status, NULL));

http.h

@@ -14,13 +14,11 @@ struct _HTTPHeaderList {
     HTTPHeaderList *next;
 };
 
-HTTPHeaderList *http_header_list_push(HTTPHeaderList *list, const char *key,
+HTTPHeaderList *http_header_list_push(HTTPHeaderList *list, const char *key, const char *value);
-                                      const char *value);
 
 void free_http_header_list(HTTPHeaderList *list);
 
-const char *http_header_list_search(HTTPHeaderList *list, const char *key,
+const char *http_header_list_search(HTTPHeaderList *list, const char *key, const char *def);
-                                    const char *def);
 
 typedef enum {
     HRPR_OK,
@@ -39,8 +37,7 @@ typedef struct {
     HTTPHeaderList *headers;
 } HTTPRequest;
 
-HTTPRequestParseResult parse_http_request(FILE *stream,
+HTTPRequestParseResult parse_http_request(FILE *stream, HTTPRequest *restrict out);
-                                          HTTPRequest *restrict out);
 
 void free_http_request(HTTPRequest *restrict req);
 

main.c

@@ -41,7 +41,8 @@ static const GlobalFlags DEFAULT_FLAGS = {
 
 // Return false on failure, true on success
 static bool parse_uint(const char* str, uintmax_t min, uintmax_t max,
-                       uintmax_t *output) {
+    uintmax_t* output)
+{
     if (isspace(*str) || *str == '+' || *str == '-') {
         log_error("malformed number: \"%s\"", str);
         return false;
@@ -61,7 +62,8 @@ static bool parse_uint(const char *str, uintmax_t min, uintmax_t max,
     return true;
 }
 
-static void parse_cli_options(int argc, const char **argv, GlobalFlags *flags) {
+static void parse_cli_options(int argc, const char** argv, GlobalFlags* flags)
+{
     constexpr size_t MAX_PARALLELISM = SIZE_MAX;
     constexpr uint32_t MAX_PORT = 65535;
     opterr = false;
@@ -118,7 +120,8 @@ static void parse_cli_options(int argc, const char **argv, GlobalFlags *flags) {
     }
 }
 
-static void print_help(FILE *file) {
+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");
@@ -129,18 +132,19 @@ static void print_help(FILE *file) {
 }
 
 constexpr int WORKER_BLOCKED_SIGNALS[] = { SIGTERM, SIGINT, SIGHUP };
-constexpr size_t N_WORKER_BLOCKED_SIGNALS =
+constexpr size_t N_WORKER_BLOCKED_SIGNALS = sizeof(WORKER_BLOCKED_SIGNALS) / sizeof(int);
-    sizeof(WORKER_BLOCKED_SIGNALS) / sizeof(int);
 static bool shutdown_flag = false;
 
-static void signal_handler(int signal) {
+static void signal_handler(int signal)
+{
     if (shutdown_flag) {
         _exit(signal == SIGTERM ? 0 : EXIT_FAILURE);
     }
     shutdown_flag = true;
 }
 
-static void setup_signals() {
+static void setup_signals()
+{
     struct sigaction act = {
         .sa_handler = signal_handler,
         .sa_flags = 0,
@@ -154,7 +158,8 @@ static void setup_signals() {
     }
 }
 
-static int parse_result_to_status(HTTPRequestParseResult res) {
+static int parse_result_to_status(HTTPRequestParseResult res)
+{
     switch (res) {
     case HRPR_OK:
         return 200;
@@ -170,7 +175,8 @@ static int parse_result_to_status(HTTPRequestParseResult res) {
     }
 }
 
-static void send_simple_response(FILE *stream, int status) {
+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 = {
@@ -183,12 +189,14 @@ static void send_simple_response(FILE *stream, int status) {
     fputc('\n', stream);
 }
 
-static void write_audit_log_entry(HTTPRequest *restrict req, int status) {
+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 void handle_get_request(FILE *conn, HTTPRequest *restrict req) {
+static void handle_get_request(FILE* conn, HTTPRequest* restrict req)
+{
     int status = 200;
     struct stat statbuf;
     flockfile(stderr);
@@ -234,9 +242,9 @@ static void handle_get_request(FILE *conn, HTTPRequest *restrict req) {
     fclose(file_handle);
 }
 
-static ssize_t get_content_length(HTTPRequest *restrict req) {
+static ssize_t get_content_length(HTTPRequest* restrict req)
-    const char *text =
+{
-        http_header_list_search(req->headers, "Content-Length", NULL);
+    const char* text = http_header_list_search(req->headers, "Content-Length", NULL);
     if (!text) {
         return 0;
     } else if (isspace(*text) || *text == '-' || *text == '+') {
@@ -251,7 +259,8 @@ static ssize_t get_content_length(HTTPRequest *restrict req) {
     return conv;
 }
 
-static void handle_put_request(FILE *conn, HTTPRequest *restrict req) {
+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);
@@ -313,7 +322,8 @@ write_status_and_unlock:
     }
 }
 
-static void handle_connection(void *arg) {
+static void handle_connection(void* arg)
+{
     FILE* conn = arg;
     HTTPRequest req;
     HTTPRequestParseResult res = parse_http_request(conn, &req);
@@ -336,11 +346,13 @@ static void handle_connection(void *arg) {
     fclose(conn);
 }
 
-static void fclose_free_func(void *file) {
+static void fclose_free_func(void* file)
+{
     fclose(file);
 }
 
-int main(int argc, const char **argv) {
+int main(int argc, const char** argv)
+{
     setenv("POSIXLY_CORRECT", "1", true);
     GlobalFlags flags = DEFAULT_FLAGS;
     parse_cli_options(argc, argv, &flags);

server.c

@@ -12,7 +12,8 @@ struct _Server {
     int socket;
 };
 
-Server *make_server(const char *text_addr, uint32_t port) {
+Server* make_server(const char* text_addr, uint32_t port)
+{
     struct sockaddr_in addr = {
         .sin_family = AF_INET,
         .sin_port = htons(port),
@@ -51,11 +52,13 @@ Server *make_server(const char *text_addr, uint32_t port) {
     return server;
 }
 
-void destroy_server(Server *server) {
+void destroy_server(Server* server)
+{
     close(server->socket);
     free(server);
 }
 
-int server_accept(Server *server) {
+int server_accept(Server* server)
+{
     return accept(server->socket, NULL, NULL);
 }

threadpool.c

@@ -24,7 +24,8 @@ struct _ThreadPool {
 };
 
 // return false if we need to stop
-static bool get_task(ThreadPool *pool, Task *task, void **task_arg) {
+static bool get_task(ThreadPool* pool, Task* task, void** task_arg)
+{
     pthread_mutex_lock(&pool->queue_mtx);
     if (!pool->running) {
         pthread_mutex_unlock(&pool->queue_mtx);
@@ -49,7 +50,8 @@ static bool get_task(ThreadPool *pool, Task *task, void **task_arg) {
     abort();
 }
 
-static void *pool_thread_function(void *arg) {
+static void* pool_thread_function(void* arg)
+{
     ThreadPool* pool = arg;
     pthread_sigmask(SIG_SETMASK, &pool->thread_sig_mask, NULL);
     Task task;
@@ -60,7 +62,8 @@ static void *pool_thread_function(void *arg) {
     return NULL;
 }
 
-ThreadPool *make_thread_pool(size_t parallelism, sigset_t sig_mask) {
+ThreadPool* make_thread_pool(size_t parallelism, sigset_t sig_mask)
+{
     ThreadPool* pool = malloc_safe(sizeof(ThreadPool));
     pthread_mutex_init(&pool->queue_mtx, NULL);
     pthread_cond_init(&pool->queue_cnd, NULL);
@@ -81,7 +84,8 @@ ThreadPool *make_thread_pool(size_t parallelism, sigset_t sig_mask) {
     return pool;
 }
 
-void destroy_thread_pool(ThreadPool *pool) {
+void destroy_thread_pool(ThreadPool* pool)
+{
     pthread_mutex_lock(&pool->queue_mtx);
     pool->running = false;
     pthread_cond_broadcast(&pool->queue_cnd);
@@ -104,10 +108,10 @@ void destroy_thread_pool(ThreadPool *pool) {
     free(pool);
 }
 
-void thread_pool_enqueue(ThreadPool *pool, Task task, void *arg, FreeFunc ff) {
+void thread_pool_enqueue(ThreadPool* pool, Task task, void* arg, FreeFunc ff)
+{
     pthread_mutex_lock(&pool->queue_mtx);
-    struct thread_pool_queue *new =
+    struct thread_pool_queue* new = malloc_safe(sizeof(struct thread_pool_queue));
-        malloc_safe(sizeof(struct thread_pool_queue));
     new->task = task;
     new->arg = arg;
     new->ff = ff;

util.c

@@ -7,7 +7,8 @@
 #include <string.h>
 #include <time.h>
 
-void *realloc_safe(void *oldptr, size_t size) {
+void* realloc_safe(void* oldptr, size_t size)
+{
     static const char OOM_MSG[] = "fatal: out of memory\n";
     void* ptr = realloc(oldptr, size);
     if (size && !ptr) {
@@ -17,12 +18,14 @@ void *realloc_safe(void *oldptr, size_t size) {
     return ptr;
 }
 
-void *malloc_safe(size_t size) {
+void* malloc_safe(size_t size)
+{
     return realloc_safe(NULL, size);
 }
 
 // asprintf is not POSIX
-int alloc_sprintf(char *restrict *restrict out, const char *restrict fmt, ...) {
+int alloc_sprintf(char* restrict* restrict out, const char* restrict fmt, ...)
+{
     va_list args;
     va_start(args, fmt);
     va_list args2;
@@ -35,7 +38,8 @@ int alloc_sprintf(char *restrict *restrict out, const char *restrict fmt, ...) {
     return written;
 }
 
-void log_error(const char *restrict fmt, ...) {
+void log_error(const char* restrict fmt, ...)
+{
     time_t cur_time = time(NULL);
     struct tm tm;
     localtime_r(&cur_time, &tm);
@@ -49,6 +53,7 @@ void log_error(const char *restrict fmt, ...) {
     fputc('\n', stderr);
 }
 
-void log_errno(const char *detail) {
+void log_errno(const char* detail)
+{
     log_error("%s: %s", detail, strerror(errno));
 }