Moved memory functions to their own module, making explicit that they can fail

Author: codepr

CMakeLists.txt

@@ -14,7 +14,7 @@ set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})
 include_directories(include)
 file(GLOB SOURCES src/*.c)
 file(GLOB TEST src/hashtable.c src/bst.c src/config.c src/list.c src/trie.c
-    src/util.c src/iterator.c src/logging.c tests/*.c)
+    src/util.c src/iterator.c src/logging.c src/memory.c tests/*.c)
 
 set(AUTHOR "Andrea Giacomo Baldan")
 set(LICENSE "BSD2 license")

src/bst.c

@@ -27,13 +27,14 @@
  */
 
 #include "bst.h"
+#include "memory.h"
 
 #define MAX(a, b) a > b ? a : b
 #define HEIGHT(n) !n ? 0 : n->height
 #define BALANCE(n) !n ? 0 : (HEIGHT(n->left)) - (HEIGHT(n->right))
 
 struct bst_node *bst_new(unsigned char key, const void *data) {
-    struct bst_node *node = xmalloc(sizeof(*node));
+    struct bst_node *node = try_alloc(sizeof(*node));
     node->key = key;
     node->height = 1;
     node->left = NULL;
@@ -187,7 +188,7 @@ struct bst_node *bst_delete(struct bst_node *node, unsigned char key) {
                 node = NULL;
             } else
                 *node = *tmp;
-            xfree(tmp);
+            free_memory(tmp);
         } else {
             struct bst_node *tmp = bst_min(node->right);
             node->key = tmp->key;

src/bst.h

@@ -1,7 +1,7 @@
 /*
  * BSD 2-Clause License
  *
- * Copyright (c) 2018, 2019 Andrea Giacomo Baldan All rights reserved.
+ * Copyright (c) 2020 Andrea Giacomo Baldan All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,8 +29,6 @@
 #ifndef BST_H
 #define BST_H
 
-#include "util.h"
-
 struct bst_node {
     unsigned char key;
     int height;

src/config.c

@@ -33,6 +33,7 @@
 #include <unistd.h>
 #endif
 #include "util.h"
+#include "memory.h"
 #include "config.h"
 #include "network.h"
 #include "logging.h"
@@ -117,25 +118,25 @@ char *memory_to_string(size_t memory) {
         translated_memory = memory;
         numlen = number_len(translated_memory);
         // +1 for 'b' +1 for nul terminating
-        mstring = xmalloc(numlen + 1);
+        mstring = try_alloc(numlen + 1);
         snprintf(mstring, numlen + 1, "%db", translated_memory);
     } else if (memory < 1048576) {
         translated_memory = memory / 1024;
         numlen = number_len(translated_memory);
         // +2 for 'Kb' +1 for nul terminating
-        mstring = xmalloc(numlen + 2);
+        mstring = try_alloc(numlen + 2);
         snprintf(mstring, numlen + 2, "%dKb", translated_memory);
     } else if (memory < 1073741824) {
         translated_memory = memory / (1024 * 1024);
         numlen = number_len(translated_memory);
         // +2 for 'Mb' +1 for nul terminating
-        mstring = xmalloc(numlen + 2);
+        mstring = try_alloc(numlen + 2);
         snprintf(mstring, numlen + 2, "%dMb", translated_memory);
     } else {
         translated_memory = memory / (1024 * 1024 * 1024);
         numlen = number_len(translated_memory);
         // +2 for 'Gb' +1 for nul terminating
-        mstring = xmalloc(numlen + 2);
+        mstring = try_alloc(numlen + 2);
         snprintf(mstring, numlen + 2, "%dGb", translated_memory);
     }
 
@@ -155,25 +156,25 @@ char *time_to_string(size_t time) {
         translated_time = time;
         numlen = number_len(translated_time);
         // +1 for 's' +1 for nul terminating
-        tstring = xmalloc(numlen + 1);
+        tstring = try_alloc(numlen + 1);
         snprintf(tstring, numlen + 1, "%ds", translated_time);
     } else if (time < 60 * 60) {
         translated_time = time / 60;
         numlen = number_len(translated_time);
         // +1 for 'm' +1 for nul terminating
-        tstring = xmalloc(numlen + 1);
+        tstring = try_alloc(numlen + 1);
         snprintf(tstring, numlen + 1, "%dm", translated_time);
     } else if (time < 60 * 60 * 24) {
         translated_time = time / (60 * 60);
         numlen = number_len(translated_time);
         // +1 for 'h' +1 for nul terminating
-        tstring = xmalloc(numlen + 1);
+        tstring = try_alloc(numlen + 1);
         snprintf(tstring, numlen + 1, "%dh", translated_time);
     } else {
         translated_time = time / (60 * 60 * 24);
         numlen = number_len(translated_time);
         // +1 for 'd' +1 for nul terminating
-        tstring = xmalloc(numlen + 1);
+        tstring = try_alloc(numlen + 1);
         snprintf(tstring, numlen + 1, "%dd", translated_time);
     }
 
@@ -399,8 +400,8 @@ void config_print(void) {
         const char *human_memory = memory_to_string(config.max_memory);
         log_info("Max memory: %s", human_memory);
         log_info("Event loop backend: %s", EVENTLOOP_BACKEND);
-        xfree((char *) human_memory);
-        xfree((char *) human_rsize);
+        free_memory((char *) human_memory);
+        free_memory((char *) human_rsize);
     }
 }
 
@@ -437,9 +438,9 @@ bool config_read_passwd_file(const char *path, struct authentication **auth_map)
         while (*puname != '\n')
             password[i++] = *puname++;
 
-        struct authentication *auth = xmalloc(sizeof(*auth));
-        auth->username = xstrdup(username);
-        auth->salt = xstrdup(password);
+        struct authentication *auth = try_alloc(sizeof(*auth));
+        auth->username = try_strdup(username);
+        auth->salt = try_strdup(password);
         HASH_ADD_STR(*auth_map, username, auth);
     }
 

src/config.h

@@ -146,9 +146,9 @@ struct authentication {
     struct authentication *auth, *dummy;        \
     HASH_ITER(hh, (auth_map), auth, dummy) {    \
         HASH_DEL((auth_map), auth);             \
-        xfree(auth->username);                  \
-        xfree(auth->salt);                      \
-        xfree(auth);                            \
+        free_memory(auth->username);            \
+        free_memory(auth->salt);                \
+        free_memory(auth);                      \
     }                                           \
 } while (0);
 

src/ev.c

@@ -37,6 +37,7 @@
 #endif
 #include "ev.h"
 #include "util.h"
+#include "memory.h"
 #include "config.h"
 
 #if defined(EPOLL)
@@ -103,20 +104,18 @@ static int epoll_del(int efd, int fd) {
 }
 
 static int ev_api_init(struct ev_ctx *ctx, int events_nr) {
-    struct epoll_api *e_api = xmalloc(sizeof(*e_api));
-    if (!e_api)
-        return -EV_OOM;
+    struct epoll_api *e_api = try_alloc(sizeof(*e_api));
     e_api->fd = epoll_create1(0);
-    e_api->events = xcalloc(events_nr, sizeof(struct epoll_event));
+    e_api->events = try_calloc(events_nr, sizeof(struct epoll_event));
     ctx->api = e_api;
     ctx->maxfd = events_nr;
     return EV_OK;
 }
 
 static void ev_api_destroy(struct ev_ctx *ctx) {
     close(((struct epoll_api *) ctx->api)->fd);
-    xfree(((struct epoll_api *) ctx->api)->events);
-    xfree(ctx->api);
+    free_memory(((struct epoll_api *) ctx->api)->events);
+    free_memory(ctx->api);
 }
 
 static int ev_api_get_event_type(struct ev_ctx *ctx, int idx) {
@@ -200,20 +199,18 @@ struct poll_api {
 };
 
 static int ev_api_init(struct ev_ctx *ctx, int events_nr) {
-    struct poll_api *p_api = xmalloc(sizeof(*p_api));
-    if (!p_api)
-        return -EV_OOM;
+    struct poll_api *p_api = try_alloc(sizeof(*p_api));
     p_api->nfds = 0;
-    p_api->fds = xcalloc(events_nr, sizeof(struct pollfd));
+    p_api->fds = try_calloc(events_nr, sizeof(struct pollfd));
     p_api->events_monitored = events_nr;
     ctx->api = p_api;
     ctx->maxfd = events_nr;
     return EV_OK;
 }
 
 static void ev_api_destroy(struct ev_ctx *ctx) {
-    xfree(((struct poll_api *) ctx->api)->fds);
-    xfree(ctx->api);
+    free_memory(((struct poll_api *) ctx->api)->fds);
+    free_memory(ctx->api);
 }
 
 static int ev_api_get_event_type(struct ev_ctx *ctx, int idx) {
@@ -249,7 +246,7 @@ static int ev_api_watch_fd(struct ev_ctx *ctx, int fd) {
     p_api->nfds++;
     if (p_api->nfds >= p_api->events_monitored) {
         p_api->events_monitored *= 2;
-        p_api->fds = xrealloc(p_api->fds,
+        p_api->fds = try_realloc(p_api->fds,
                                  p_api->events_monitored * sizeof(struct pollfd));
     }
     return EV_OK;
@@ -282,7 +279,7 @@ static int ev_api_register_event(struct ev_ctx *ctx, int fd, int mask) {
     p_api->nfds++;
     if (p_api->nfds >= p_api->events_monitored) {
         p_api->events_monitored *= 2;
-        p_api->fds = xrealloc(p_api->fds,
+        p_api->fds = try_realloc(p_api->fds,
                                  p_api->events_monitored * sizeof(struct pollfd));
     }
     return EV_OK;
@@ -337,9 +334,7 @@ static int ev_api_init(struct ev_ctx *ctx, int events_nr) {
      * 32 x 32 = 1024 as hard limit
      */
     assert(events_nr <= 1024);
-    struct select_api *s_api = xmalloc(sizeof(*s_api));
-    if (!s_api)
-        return -EV_OOM;
+    struct select_api *s_api = try_alloc(sizeof(*s_api));
     FD_ZERO(&s_api->rfds);
     FD_ZERO(&s_api->wfds);
     ctx->api = s_api;
@@ -348,7 +343,7 @@ static int ev_api_init(struct ev_ctx *ctx, int events_nr) {
 }
 
 static void ev_api_destroy(struct ev_ctx *ctx) {
-    xfree(ctx->api);
+    free_memory(ctx->api);
 }
 
 static int ev_api_get_event_type(struct ev_ctx *ctx, int idx) {
@@ -462,20 +457,18 @@ struct kqueue_api {
 };
 
 static int ev_api_init(struct ev_ctx *ctx, int events_nr) {
-    struct kqueue_api *k_api = xmalloc(sizeof(*k_api));
-    if (!k_api)
-        return -EV_OOM;
+    struct kqueue_api *k_api = try_alloc(sizeof(*k_api));
     k_api->fd = kqueue();
-    k_api->events = xcalloc(events_nr, sizeof(struct kevent));
+    k_api->events = try_calloc(events_nr, sizeof(struct kevent));
     ctx->api = k_api;
     ctx->maxfd = events_nr;
     return EV_OK;
 }
 
 static void ev_api_destroy(struct ev_ctx *ctx) {
     close(((struct kqueue_api *) ctx->api)->fd);
-    xfree(((struct kqueue_api *) ctx->api)->events);
-    xfree(ctx->api);
+    free_memory(((struct kqueue_api *) ctx->api)->events);
+    free_memory(ctx->api);
 }
 
 static int ev_api_get_event_type(struct ev_ctx *ctx, int idx) {
@@ -620,8 +613,8 @@ static void ev_add_monitored(struct ev_ctx *ctx, int fd, int mask,
         int i = ctx->maxevents;
         ctx->maxevents = fd;
         if (fd > ctx->events_nr) {
-            ctx->events_monitored =
-                xrealloc(ctx->events_monitored, (fd + 1) * sizeof(struct ev));
+            ctx->events_monitored = try_realloc(ctx->events_monitored,
+                                                (fd + 1) * sizeof(struct ev));
             for (; i < ctx->maxevents; ++i)
                 ctx->events_monitored[i].mask = EV_NONE;
         }
@@ -650,7 +643,7 @@ int ev_init(struct ev_ctx *ctx, int events_nr) {
     ctx->fired_events = 0;
     ctx->maxevents = events_nr;
     ctx->events_nr = events_nr;
-    ctx->events_monitored = xcalloc(events_nr, sizeof(struct ev));
+    ctx->events_monitored = try_calloc(events_nr, sizeof(struct ev));
     return EV_OK;
 }
 
@@ -660,7 +653,7 @@ void ev_destroy(struct ev_ctx *ctx) {
             ctx->events_monitored[i].mask != EV_NONE)
             ev_del_fd(ctx, ctx->events_monitored[i].fd);
     }
-    xfree(ctx->events_monitored);
+    free_memory(ctx->events_monitored);
     ev_api_destroy(ctx);
 }
 

src/handlers.c

@@ -29,9 +29,10 @@
 #include "mqtt.h"
 #include "config.h"
 #include "server.h"
+#include "memory.h"
 #include "logging.h"
-#include "sol_internal.h"
 #include "handlers.h"
+#include "sol_internal.h"
 
 /* Prototype for a command handler */
 typedef int handler(struct io_event *);
@@ -384,9 +385,9 @@ static int connect_handler(struct io_event *e) {
             .publish = (struct mqtt_publish) {
                 .pkt_id = 0,  // placeholder
                 .topiclen = tpc_len,
-                .topic = (unsigned char *) xstrdup(will_topic),
+                .topic = (unsigned char *) try_strdup(will_topic),
                 .payloadlen = msg_len,
-                .payload = (unsigned char *) xstrdup(will_message)
+                .payload = (unsigned char *) try_strdup(will_message)
             }
         };
 
@@ -397,9 +398,7 @@ static int connect_handler(struct io_event *e) {
         // We must store the retained message in the topic
         if (c->bits.will_retain == 1) {
             size_t publen = mqtt_size(&cc->session->lwt_msg, NULL);
-            unsigned char *payload = xmalloc(publen);
-            if (!payload)
-                log_fatal("connect_handler failed: Out of memory")
+            unsigned char *payload = try_alloc(publen);
             mqtt_pack(&cc->session->lwt_msg, payload);
             // We got a ready-to-be-sent bytestring in the retained message
             // field
@@ -447,13 +446,9 @@ static int disconnect_handler(struct io_event *e) {
 
 static inline void add_wildcard(const char *topic, struct subscriber *s,
                                 bool wildcard) {
-    struct subscription *subscription = xmalloc(sizeof(*subscription));
-    if (!subscription)
-        log_fatal("add_wildcard failed: Out of memory");
+    struct subscription *subscription = try_alloc(sizeof(*subscription));
     subscription->subscriber = s;
-    subscription->topic = xstrdup(topic);
-    if (!subscription->topic)
-        log_fatal("add_wildcard failed: Out of memory");
+    subscription->topic = try_strdup(topic);
     subscription->multilevel = wildcard;
     INCREF(s, struct subscriber);
     server.wildcards = list_push(server.wildcards, subscription);
@@ -560,7 +555,7 @@ static int subscribe_handler(struct io_event *e) {
         // Retained message? Publish it
         // TODO move after SUBACK response
         if (t->retained_msg) {
-            size_t len = xmalloc_size(t->retained_msg);
+            size_t len = alloc_size(t->retained_msg);
             memcpy(c->wbuf + c->towrite, t->retained_msg, len);
             c->towrite += len;
         }
@@ -695,9 +690,7 @@ static int publish_handler(struct io_event *e) {
     pkt->publish = e->data.publish;
 
     if (hdr->bits.retain == 1) {
-        t->retained_msg = xmalloc(mqtt_size(&e->data, NULL));
-        if (!t->retained_msg)
-            log_fatal("publish_handler failed: Out of memory");
+        t->retained_msg = try_alloc(mqtt_size(&e->data, NULL));
         mqtt_pack(&e->data, t->retained_msg);
     }
 #if THREADSNR > 0