From 5dfbdc43c0afeba7d7a06b503414435bd0d419fb Mon Sep 17 00:00:00 2001 From: Alexander Rosenberg Date: Mon, 25 May 2026 23:13:27 -0700 Subject: [PATCH] Update stuff --- Makefile | 12 +++-- http.c | 83 ++++++++++++++------------------- main.c | 126 ++++++++++++++++++++++----------------------------- server.c | 24 ++++++---- server.h | 2 +- threadpool.c | 37 +++++++-------- util.c | 17 +++---- 7 files changed, 133 insertions(+), 168 deletions(-) diff --git a/Makefile b/Makefile index 52eb6a3..ded7e31 100644 --- a/Makefile +++ b/Makefile @@ -1,9 +1,15 @@ -CC=gcc -CFLAGS=-Wall -Wextra -Wpedantic -std=c23 -D_POSIX_C_SOURCE=200809L -pthread -O2 -CFLAGS+=-Og -g -fsanitize=address,undefined +# If set to 1, the autograder +BAD_ERROR_REPORTING_FOR_AUTOGRADER=1 + +CC=clang +CFLAGS=-Wall -Wextra -Wpedantic -Werror -std=c23 -D_POSIX_C_SOURCE=200809L -pthread -O2 +#CFLAGS+=-Og -g -fsanitize=address,undefined SRCS=main.c threadpool.c util.c server.c http.c OBJS=$(SRCS:%.c=bin/%.o) +ifeq ($(BAD_ERROR_REPORTING_FOR_AUTOGRADER),1) + CFLAGS+=-DBAD_ERROR_REPORTING_FOR_AUTOGRADER=1 +endif all: httpserver diff --git a/http.c b/http.c index 65dd909..f8c7efd 100644 --- a/http.c +++ b/http.c @@ -5,12 +5,10 @@ #include #include -static const char* EMPTY_STRING = ""; +static const char *EMPTY_STRING = ""; -HTTPHeaderList* http_header_list_push(HTTPHeaderList* list, const char* key, - const char* value) -{ - HTTPHeaderList* new = malloc(sizeof(HTTPHeaderList)); +HTTPHeaderList *http_header_list_push(HTTPHeaderList *list, const char *key, const char *value) { + HTTPHeaderList *new = malloc(sizeof(HTTPHeaderList)); if (!new) { return NULL; } @@ -33,10 +31,9 @@ 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; + HTTPHeaderList *next = list->next; free(list->key); free(list->value); free(list); @@ -44,9 +41,7 @@ void free_http_header_list(HTTPHeaderList* list) } } -const char* http_header_list_search(HTTPHeaderList* list, const char* key, - const char* def) -{ +const char *http_header_list_search(HTTPHeaderList *list, const char *key, const char *def) { while (list) { if (strcmp(list->key, key) == 0) { return list->value; @@ -56,23 +51,21 @@ const char* http_header_list_search(HTTPHeaderList* list, const char* key, return def; } -#define MAX_REQUEST_LENGTH 16384 -#define MAX_METHOD_LENGTH 16 -#define MAX_URI_LENGTH 256 -#define MAX_VERSION_LENGTH 3 -#define MAX_HEADER_KEY_LENGTH 2048 +#define MAX_REQUEST_LENGTH 16384 +#define MAX_METHOD_LENGTH 16 +#define MAX_URI_LENGTH 256 +#define MAX_VERSION_LENGTH 3 +#define MAX_HEADER_KEY_LENGTH 2048 #define MAX_HEADER_VALUE_LENGTH 2048 -#define RETURN_IF_READ_ERROR(s) \ - if (ferror((s))) { \ - return HRPR_READ_FAILED; \ +#define RETURN_IF_READ_ERROR(s) \ + if (ferror((s))) { \ + return HRPR_READ_FAILED; \ } // 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) -{ +static HTTPRequestParseResult parse_method_uri_line( + FILE *stream, size_t *restrict bytes_read, HTTPRequest *restrict req) { // allow for some leeway in passing incorrect methods char method[MAX_METHOD_LENGTH + 1]; char uri[MAX_URI_LENGTH + 1]; @@ -80,9 +73,8 @@ static HTTPRequestParseResult parse_method_uri_line(FILE* stream, char whitespace[4]; ssize_t signed_bytes_read; #define S1(s) #s -#define S(s) S1(s) - int nconv = fscanf( - stream, +#define S(s) S1(s) + int nconv = fscanf(stream, // clang-format off "%" S(MAX_METHOD_LENGTH) "[A-Z]" "%c" @@ -92,8 +84,8 @@ static HTTPRequestParseResult parse_method_uri_line(FILE* stream, "%c%c" "%zn", // clang-format on - method, &whitespace[0], uri, &whitespace[1], version_str, - &whitespace[2], &whitespace[3], &signed_bytes_read); + method, &whitespace[0], uri, &whitespace[1], version_str, &whitespace[2], &whitespace[3], + &signed_bytes_read); #undef S *bytes_read = signed_bytes_read; RETURN_IF_READ_ERROR(stream); @@ -117,10 +109,8 @@ static HTTPRequestParseResult parse_method_uri_line(FILE* stream, // return true if there are more headers and no error occurred, false otherwise // 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) -{ +static bool next_header(FILE *stream, size_t *restrict bytes_read, + HTTPRequestParseResult *restrict res, HTTPHeaderList *restrict *restrict list) { char c = fgetc(stream); RETURN_IF_READ_ERROR(stream); if (c == '\r') { @@ -140,7 +130,7 @@ static bool next_header(FILE* stream, size_t* restrict bytes_read, char whitespace[3]; ssize_t signed_bytes_read; #define S1(s) #s -#define S(s) S1(s) +#define S(s) S1(s) int nconv = fscanf(stream, // clang-format off "%" S(MAX_HEADER_KEY_LENGTH) "[a-zA-Z0-9.-]" @@ -149,8 +139,7 @@ static bool next_header(FILE* stream, size_t* restrict bytes_read, "%c%c" "%zn", // clang-format on - key, &whitespace[0], value, &whitespace[1], &whitespace[2], - &signed_bytes_read); + key, &whitespace[0], value, &whitespace[1], &whitespace[2], &signed_bytes_read); #undef S *bytes_read = signed_bytes_read; RETURN_IF_READ_ERROR(stream); @@ -165,9 +154,7 @@ static bool next_header(FILE* stream, size_t* restrict bytes_read, return true; } -HTTPRequestParseResult parse_http_request(FILE* stream, - HTTPRequest* restrict out) -{ +HTTPRequestParseResult parse_http_request(FILE *stream, HTTPRequest *restrict out) { out->uri = EMPTY_STRING; out->path = EMPTY_STRING; out->method = EMPTY_STRING; @@ -187,22 +174,20 @@ 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); + free((char *) req->method); } if (req->uri != EMPTY_STRING) { - free((char*)req->uri); + free((char *) req->uri); } 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; + const char *msg; size_t size; } CODES[] = { #define P(s, m) { s, m, sizeof(m) - 1 } @@ -228,13 +213,11 @@ 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)); + fprintf(stream, "HTTP/1.1 %d %s\r\n", resp->status, status_code_to_message(resp->status, NULL)); fprintf(stream, "Content-Length: %zu\r\n", resp->body_length); - for (HTTPHeaderList* h = resp->headers; h; h = h->next) { + for (HTTPHeaderList *h = resp->headers; h; h = h->next) { fwrite(h->key, 1, h->key_length, stream); fwrite(": ", 1, 2, stream); fwrite(h->value, 1, h->value_length, stream); diff --git a/main.c b/main.c index 7917c89..48dafd1 100644 --- a/main.c +++ b/main.c @@ -28,7 +28,7 @@ typedef struct { bool help_flag; uint32_t port; size_t parallelism; - const char* address; + const char *address; } GlobalFlags; static const GlobalFlags DEFAULT_FLAGS = { @@ -40,36 +40,44 @@ 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) -{ +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; + 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) { + } 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) -{ - constexpr size_t MAX_PARALLELISM = SIZE_MAX; - constexpr uint32_t MAX_PORT = 65535; +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) { + while ((c = getopt(argc, (char *const *) argv, ":ha:p:")) >= 0) { if (isprint(c)) { snprintf(pretty_flag, sizeof(pretty_flag), "%c", optopt); } else { @@ -81,9 +89,7 @@ static void parse_cli_options(int argc, const char** argv, GlobalFlags* flags) #pragma GCC diagnostic pop } switch (c) { - case 'h': - flags->help_flag = true; - return; + case 'h': flags->help_flag = true; return; case 'p': { uintmax_t conv; if (!parse_uint(optarg, 1, MAX_PARALLELISM, &conv)) { @@ -91,9 +97,7 @@ static void parse_cli_options(int argc, const char** argv, GlobalFlags* flags) } flags->parallelism = conv; } break; - case 'a': - flags->address = optarg; - break; + case 'a': flags->address = optarg; break; case ':': flags->opt_error = true; log_error("flag requires argument: '%s'", pretty_flag); @@ -120,31 +124,25 @@ static void parse_cli_options(int argc, const char** argv, GlobalFlags* flags) } } -static void print_help(FILE* file) -{ - fprintf(file, - "usage: httpserver [-h] [-a ADDRESS] [-p PARALLELISM] \n"); +static void print_help(FILE *file) { + fprintf(file, "usage: httpserver [-h] [-a ADDRESS] [-p PARALLELISM] \n"); fprintf(file, " -h print this message, then exit\n"); - fprintf( - file, - " -p use PARALLELISM threads for processing requests (default: 1)\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"); } -constexpr int WORKER_BLOCKED_SIGNALS[] = { SIGTERM, SIGINT, SIGHUP }; -constexpr size_t N_WORKER_BLOCKED_SIGNALS = sizeof(WORKER_BLOCKED_SIGNALS) / sizeof(int); +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) -{ +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, @@ -158,27 +156,20 @@ 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; + 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(); + 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) -{ +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); + const char *status_msg = status_code_to_message(status, &status_msg_len); HTTPResponse resp = { .status = status, .headers = NULL, @@ -189,18 +180,16 @@ 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); - FILE* file_handle = fopen(req->path, "r"); + FILE *file_handle = fopen(req->path, "r"); if (!file_handle) { if (errno == ENOENT) { status = 404; @@ -242,25 +231,22 @@ static void handle_get_request(FILE* conn, HTTPRequest* restrict req) fclose(file_handle); } -static ssize_t get_content_length(HTTPRequest* restrict req) -{ - const char* text = http_header_list_search(req->headers, "Content-Length", NULL); +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; + char *endptr; uintmax_t conv = strtoumax(text, &endptr, 10); - if (*endptr || (conv == UINTMAX_MAX && errno == ERANGE) - || conv > SIZE_MAX) { + if (*endptr || (conv == UINTMAX_MAX && errno == ERANGE) || conv > SIZE_MAX) { return -1; } 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); @@ -278,9 +264,8 @@ static void handle_put_request(FILE* conn, HTTPRequest* restrict req) 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), + (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); @@ -322,9 +307,8 @@ write_status_and_unlock: } } -static void handle_connection(void* arg) -{ - FILE* conn = arg; +static void handle_connection(void *arg) { + FILE *conn = arg; HTTPRequest req; HTTPRequestParseResult res = parse_http_request(conn, &req); if (res != HRPR_OK) { @@ -346,13 +330,11 @@ 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); @@ -367,11 +349,11 @@ int main(int argc, const char** argv) 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); + Server *server = make_server(flags.address, flags.port); if (!server) { return EXIT_FAILURE; } - ThreadPool* pool = make_thread_pool(flags.parallelism, worker_block_set); + ThreadPool *pool = make_thread_pool(flags.parallelism, worker_block_set); if (!pool) { destroy_server(server); return EXIT_FAILURE; @@ -387,7 +369,7 @@ int main(int argc, const char** argv) } else if (conn_fd < 0) { continue; } - FILE* conn = fdopen(conn_fd, "w+"); + FILE *conn = fdopen(conn_fd, "w+"); if (!conn) { close(conn_fd); continue; diff --git a/server.c b/server.c index 037299f..a28c4dd 100644 --- a/server.c +++ b/server.c @@ -8,12 +8,15 @@ #include #include +#ifdef BAD_ERROR_REPORTING_FOR_AUTOGRADER +#include +#endif + 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), @@ -22,7 +25,7 @@ Server* make_server(const char* text_addr, uint32_t port) log_error("bad IPv4 address: \"%s\"", text_addr); return NULL; } - Server* server = malloc_safe(sizeof(Server)); + Server *server = malloc_safe(sizeof(Server)); server->socket = socket(AF_INET, SOCK_STREAM, 0); if (server->socket < 0) { log_errno("socket"); @@ -30,15 +33,18 @@ Server* make_server(const char* text_addr, uint32_t port) return NULL; } int on = 1; - if (setsockopt(server->socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) - < 0) { + if (setsockopt(server->socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { log_errno("setsockopt SO_REUSEADDR"); close(server->socket); free(server); return NULL; } - if (bind(server->socket, (struct sockaddr*)&addr, sizeof(addr)) < 0) { + if (bind(server->socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) { +#ifdef BAD_ERROR_REPORTING_FOR_AUTOGRADER + fprintf(stderr, "Invalid Port\n"); +#else log_errno("bind"); +#endif close(server->socket); free(server); return NULL; @@ -52,13 +58,11 @@ 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); } diff --git a/server.h b/server.h index 310aa11..5876a18 100644 --- a/server.h +++ b/server.h @@ -4,7 +4,7 @@ #include #include -constexpr int SERVER_BACKLOG = 32; +#define SERVER_BACKLOG 32 typedef struct _Server Server; diff --git a/threadpool.c b/threadpool.c index 5cba2be..0daf685 100644 --- a/threadpool.c +++ b/threadpool.c @@ -7,25 +7,24 @@ struct thread_pool_queue { Task task; - void* arg; + void *arg; FreeFunc ff; - struct thread_pool_queue* next; + struct thread_pool_queue *next; }; struct _ThreadPool { bool running; size_t nthreads; sigset_t thread_sig_mask; - pthread_t* threads; + pthread_t *threads; pthread_cond_t queue_cnd; pthread_mutex_t queue_mtx; - struct thread_pool_queue* queue; + struct thread_pool_queue *queue; }; // 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); @@ -37,7 +36,7 @@ static bool get_task(ThreadPool* pool, Task* task, void** task_arg) pthread_mutex_unlock(&pool->queue_mtx); return false; } - struct thread_pool_queue* ent = pool->queue; + struct thread_pool_queue *ent = pool->queue; if (ent) { pool->queue = pool->queue->next; pthread_mutex_unlock(&pool->queue_mtx); @@ -50,21 +49,19 @@ static bool get_task(ThreadPool* pool, Task* task, void** task_arg) abort(); } -static void* pool_thread_function(void* arg) -{ - ThreadPool* pool = arg; +static void *pool_thread_function(void *arg) { + ThreadPool *pool = arg; pthread_sigmask(SIG_SETMASK, &pool->thread_sig_mask, NULL); Task task; - void* task_arg; + void *task_arg; while (get_task(pool, &task, &task_arg)) { task(task_arg); } return NULL; } -ThreadPool* make_thread_pool(size_t parallelism, sigset_t sig_mask) -{ - ThreadPool* pool = malloc_safe(sizeof(ThreadPool)); +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); pool->running = true; @@ -84,8 +81,7 @@ 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); @@ -96,9 +92,9 @@ void destroy_thread_pool(ThreadPool* pool) free(pool->threads); pthread_mutex_destroy(&pool->queue_mtx); pthread_cond_destroy(&pool->queue_cnd); - struct thread_pool_queue* queue = pool->queue; + struct thread_pool_queue *queue = pool->queue; while (queue) { - struct thread_pool_queue* next = queue->next; + struct thread_pool_queue *next = queue->next; if (queue->ff) { queue->ff(queue->arg); } @@ -108,10 +104,9 @@ 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 = malloc_safe(sizeof(struct thread_pool_queue)); + struct thread_pool_queue *new = malloc_safe(sizeof(struct thread_pool_queue)); new->task = task; new->arg = arg; new->ff = ff; diff --git a/util.c b/util.c index 99dc7a8..e2c5039 100644 --- a/util.c +++ b/util.c @@ -7,10 +7,9 @@ #include #include -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); + void *ptr = realloc(oldptr, size); if (size && !ptr) { fwrite(OOM_MSG, 1, sizeof(OOM_MSG) - 1, stderr); abort(); @@ -18,14 +17,12 @@ 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; @@ -38,8 +35,7 @@ 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); @@ -53,7 +49,6 @@ 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)); }