Add some checks on allocated memory with errors

Author: codepr

README.md

@@ -98,6 +98,10 @@ static void on_data(ev_tcp_handle *client) {
 
 static void on_connection(ev_tcp_handle *server) {
     ev_tcp_handle *client = malloc(sizeof(*client));
+    if (!client) {
+        fprintf(stderr, "On connection failed: Out of memory");
+        exit(EXIT_FAILURE);
+    }
     int err = ev_tcp_server_accept(server, client, on_data, on_write);
     if (err < 0)
         free(client);
@@ -109,7 +113,11 @@ int main(void) {
 
     ev_context *ctx = ev_get_ev_context();
     ev_tcp_server server;
-    ev_tcp_server_init(&server, ctx, 128);
+    int err = 0;
+    if ((err = ev_tcp_server_init(&server, ctx, 128)) < 0) {
+        fprintf(stderr, "ev_tcp_server_init failed: %s", ev_tcp_err(err));
+        exit(EXIT_FAILURE);
+    }
     // To set TLS using OpenSSL
     // struct ev_tls_options tls_opt = {
     //     .ca = CA,

ev.h

@@ -117,6 +117,7 @@
  * Return codes */
 #define EV_OK   0
 #define EV_ERR  -1
+#define EV_OOM  -2
 
 /*
  * Event types, meant to be OR-ed on a bitmask to define the type of an event
@@ -180,7 +181,7 @@ struct ev {
  * The first thing done is the initialization of the api pointer according to
  * the Mux IO backend found on the host machine
  */
-void ev_init(ev_context *, int);
+int ev_init(ev_context *, int);
 
 /*
  * Just check if the ev_context is running, return 0 if it's not running, 1
@@ -322,12 +323,15 @@ static int epoll_del(int efd, int fd) {
     return epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
 }
 
-static void ev_api_init(ev_context *ctx, int events_nr) {
+static int ev_api_init(ev_context *ctx, int events_nr) {
     struct epoll_api *e_api = malloc(sizeof(*e_api));
+    if (!e_api)
+        return EV_OOM;
     e_api->fd = epoll_create1(0);
     e_api->events = calloc(events_nr, sizeof(struct epoll_event));
     ctx->api = e_api;
     ctx->maxfd = events_nr;
+    return EV_OK;
 }
 
 static void ev_api_destroy(ev_context *ctx) {
@@ -417,13 +421,16 @@ struct poll_api {
     struct pollfd *fds;
 };
 
-static void ev_api_init(ev_context *ctx, int events_nr) {
+static int ev_api_init(ev_context *ctx, int events_nr) {
     struct poll_api *p_api = malloc(sizeof(*p_api));
+    if (!p_api)
+        return EV_OOM;
     p_api->nfds = 0;
     p_api->fds = 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(ev_context *ctx) {
@@ -550,17 +557,20 @@ struct select_api {
     fd_set _rfds, _wfds;
 };
 
-static void ev_api_init(ev_context *ctx, int events_nr) {
+static int ev_api_init(ev_context *ctx, int events_nr) {
     /*
      * fd_set is an array of 32 i32 and each FD is represented by a bit so
      * 32 x 32 = 1024 as hard limit
      */
     assert(events_nr <= SELECT_FDS_HARDCAP);
     struct select_api *s_api = malloc(sizeof(*s_api));
+    if (!s_api)
+        return EV_OOM;
     FD_ZERO(&s_api->rfds);
     FD_ZERO(&s_api->wfds);
     ctx->api = s_api;
     ctx->maxfd = 0;
+    return EV_OK;
 }
 
 static void ev_api_destroy(ev_context *ctx) {
@@ -677,12 +687,15 @@ struct kqueue_api {
     struct kevent *events;
 };
 
-static void ev_api_init(ev_context *ctx, int events_nr) {
+static int ev_api_init(ev_context *ctx, int events_nr) {
     struct kqueue_api *k_api = malloc(sizeof(*k_api));
+    if (!k_api)
+        return EV_OOM;
     k_api->fd = kqueue();
     k_api->events = calloc(events_nr, sizeof(struct kevent));
     ctx->api = k_api;
     ctx->maxfd = events_nr;
+    return EV_OK;
 }
 
 static void ev_api_destroy(ev_context *ctx) {
@@ -891,7 +904,9 @@ ev_context *ev_get_ev_context(void) {
 #endif
         signal(SIGINT, ev_sigint_handler);
         signal(SIGTERM, ev_sigint_handler);
-        ev_init(&ev_default_ctx, EVENTLOOP_MAX_EVENTS);
+        int err = ev_init(&ev_default_ctx, EVENTLOOP_MAX_EVENTS);
+        if (err < EV_OK)
+            return NULL;
 #ifdef __linux__
         ev_register_event(&ev_default_ctx, quit_sig,
                           EV_CLOSEFD | EV_READ, ev_stop_callback, NULL);
@@ -904,14 +919,17 @@ ev_context *ev_get_ev_context(void) {
     return &ev_default_ctx;
 }
 
-void ev_init(ev_context *ctx, int events_nr) {
-    ev_api_init(ctx, events_nr);
+int ev_init(ev_context *ctx, int events_nr) {
+    int err = ev_api_init(ctx, events_nr);
+    if (err < EV_OK)
+        return err;
     ctx->stop = 0;
     ctx->fired_events = 0;
     ctx->is_running = 0;
     ctx->maxevents = events_nr;
     ctx->events_nr = events_nr;
     ctx->events_monitored = calloc(events_nr, sizeof(struct ev));
+    return EV_OK;
 }
 
 int ev_is_running(const ev_context *ctx) {

ev_tcp.h

@@ -62,6 +62,7 @@
 #define EV_TCP_FAILURE          -1
 #define EV_TCP_MISSING_CALLBACK -2
 #define EV_TCP_MISSING_CONTEXT  -3
+#define EV_TCP_OUT_OF_MEMORY    -4
 
 /*
  * Default buffer size for connecting client, can be changed on the host
@@ -335,7 +336,7 @@ static inline int set_nonblocking(int fd) {
     if (result == -1)
         goto err;
 
-    return EV_OK;
+    return EV_TCP_SUCCESS;
 
 err:
 
@@ -415,6 +416,8 @@ static void ev_server_on_stop(ev_context *ctx, void *data) {
 
 static ev_connection *ev_connection_new(int fd) {
     ev_connection *conn = malloc(sizeof(*conn));
+    if (!conn)
+        return NULL;
     conn->fd = fd;
     conn->on_conn = NULL;
     conn->on_recv = NULL;
@@ -448,16 +451,21 @@ static void ev_buf_init(ev_buf *buf, size_t capacity) {
 /*
  * init a fresh new tcp_handle which can be used as a server or a client
  */
-static void ev_tcp_handle_init(ev_tcp_handle *handle, int fd) {
+static int ev_tcp_handle_init(ev_tcp_handle *handle, int fd) {
     handle->c = ev_connection_new(fd);
+    if (!handle->c)
+        return EV_TCP_OUT_OF_MEMORY;
     ev_buf_init(&handle->buffer, EV_TCP_BUFSIZE);
     handle->to_read = handle->to_write = 0;
+    return EV_TCP_SUCCESS;
 }
 
 #ifdef HAVE_OPENSSL
 
 static ev_connection *ev_tls_connection_new(int fd, SSL *ssl) {
     ev_tls_connection *conn = malloc(sizeof(*conn));
+    if (!conn)
+        return NULL;
     conn->c.fd = fd;
     conn->ssl = ssl;
     conn->c.on_conn = NULL;
@@ -569,11 +577,14 @@ static SSL *ssl_accept(SSL_CTX *ctx, int fd) {
     return ssl;
 }
 
-static void ev_tls_tcp_handle_init(ev_tcp_handle *handle, int fd, SSL *ssl) {
+static int ev_tls_tcp_handle_init(ev_tcp_handle *handle, int fd, SSL *ssl) {
     handle->c = ev_tls_connection_new(fd, ssl);
+    if (!handle->c)
+        return EV_TCP_OUT_OF_MEMORY;
     ev_buf_init(&handle->buffer, EV_TCP_BUFSIZE);
     handle->ssl = 1;
     handle->to_read = handle->to_write = 0;
+    return EV_TCP_SUCCESS;
 }
 
 #endif // HAVE_OPENSSL
@@ -600,7 +611,9 @@ int ev_tcp_server_init(ev_tcp_server *server, ev_context *ctx, int backlog) {
                       EV_CLOSEFD|EV_READ, ev_server_on_stop, NULL);
 #endif
     server->handle.c = ev_connection_new(-1);
-    return EV_OK;
+    if (!server->handle.c)
+        return EV_TCP_OUT_OF_MEMORY;
+    return EV_TCP_SUCCESS;
 }
 
 int ev_tcp_server_listen_unix(ev_tcp_server *server, const char *socketpath,
@@ -752,10 +765,13 @@ int ev_tcp_server_accept(ev_tcp_handle *server, ev_tcp_handle *client,
         // XXX placeholder
 #ifdef HAVE_OPENSSL
         if (server->ssl == 1) {
-            ev_tls_tcp_handle_init(client, fd, ssl_accept(server->ssl_ctx, fd));
+            if (ev_tls_tcp_handle_init(client, fd,
+                                       ssl_accept(server->ssl_ctx, fd)) < 0)
+                return EV_TCP_OUT_OF_MEMORY;
         } else {
 #endif
-            ev_tcp_handle_init(client, fd);
+            if (ev_tcp_handle_init(client, fd) < 0)
+                return EV_TCP_OUT_OF_MEMORY;
 #ifdef HAVE_OPENSSL
         }
 #endif
@@ -966,6 +982,8 @@ const char *ev_tcp_err(int rc) {
             return "Failure";
         case EV_TCP_MISSING_CALLBACK:
             return "Missing callback";
+        case EV_TCP_OUT_OF_MEMORY:
+            return "Out of memory";
         default:
             return "Unknown error";
     }

examples/echo_server.c

@@ -210,7 +210,11 @@ int main(void) {
     if (listen(listen_fd, 32) != 0)
         goto err;
 
-    ev_init(&ctx, 32);
+    int err = ev_init(&ctx, 32);
+    if (err < EV_OK) {
+        fprintf(stderr, "Ev context init failed: Out of memory");
+        exit(EXIT_FAILURE);
+    }
 
     /* Register a callback on the listening socket for incoming connections */
     ev_register_event(&ctx, listen_fd, EV_READ, on_connection, &listen_fd);

examples/ev_tcp_server.c

@@ -33,6 +33,10 @@ static void on_data(ev_tcp_handle *client) {
 static void on_connection(ev_tcp_handle *server) {
     int err = 0;
     ev_tcp_handle *client = malloc(sizeof(*client));
+    if (!client) {
+        fprintf(stderr, "On connection failed: Out of memory");
+        exit(EXIT_FAILURE);
+    }
     if ((err = ev_tcp_server_accept(server, client, on_data, on_write)) < 0) {
         if (err == -1)
             fprintf(stderr, "Error occured: %s\n", strerror(errno));
@@ -49,8 +53,12 @@ int main(void) {
 
     ev_context *ctx = ev_get_ev_context();
     ev_tcp_server server;
-    ev_tcp_server_init(&server, ctx, BACKLOG);
-    int err = ev_tcp_server_listen(&server, HOST, PORT, on_connection);
+    int err = 0;
+    if ((err = ev_tcp_server_init(&server, ctx, BACKLOG)) < 0) {
+        fprintf(stderr, "ev_tcp_server_init failed: %s", ev_tcp_err(err));
+        exit(EXIT_FAILURE);
+    }
+    err = ev_tcp_server_listen(&server, HOST, PORT, on_connection);
     if (err < 0) {
         if (err == -1)
             fprintf(stderr, "Error occured: %s\n", strerror(errno));

examples/ev_tcp_server_stats.c

@@ -36,6 +36,10 @@ static void on_data(ev_tcp_handle *client) {
 static void on_connection(ev_tcp_handle *server) {
     int err = 0;
     ev_tcp_handle *client = malloc(sizeof(*client));
+    if (!client) {
+        fprintf(stderr, "On connection failed: Out of memory");
+        exit(EXIT_FAILURE);
+    }
     if ((err = ev_tcp_server_accept(server, client, on_data, NULL)) < 0) {
         if (err == -1)
             fprintf(stderr, "Error occured: %s\n", strerror(errno));
@@ -54,8 +58,12 @@ int main(void) {
     ev_context *ctx = ev_get_ev_context();
     ev_register_cron(ctx, print_stats, NULL, STATS_PERIOD, 0);
     ev_tcp_server server;
-    ev_tcp_server_init(&server, ctx, BACKLOG);
-    int err = ev_tcp_server_listen(&server, HOST, PORT, on_connection);
+    int err = 0;
+    if ((err = ev_tcp_server_init(&server, ctx, BACKLOG)) < 0) {
+        fprintf(stderr, "ev_tcp_server_init failed: %s", ev_tcp_err(err));
+        exit(EXIT_FAILURE);
+    }
+    err = ev_tcp_server_listen(&server, HOST, PORT, on_connection);
     if (err < 0) {
         if (err == -1)
             fprintf(stderr, "Error occured: %s\n", strerror(errno));

examples/ev_tls_tcp_server.c

@@ -31,6 +31,10 @@ static void on_data(ev_tcp_handle *client) {
 static void on_connection(ev_tcp_handle *server) {
     int err = 0;
     ev_tcp_handle *client = malloc(sizeof(*client));
+    if (!client) {
+        fprintf(stderr, "On connection failed: Out of memory");
+        exit(EXIT_FAILURE);
+    }
     if ((err = ev_tcp_server_accept(server, client, on_data, NULL)) < 0) {
         if (err == -1)
             fprintf(stderr, "Something went wrong %s\n", strerror(errno));
@@ -52,9 +56,13 @@ int main(void) {
         .key = KEY
     };
     tls_opt.protocols = EV_TLSvAll;
-    ev_tcp_server_init(&server, ctx, BACKLOG);
+    int err = 0;
+    if ((err = ev_tcp_server_init(&server, ctx, BACKLOG)) < 0) {
+        fprintf(stderr, "ev_tcp_server_init failed: %s", ev_tcp_err(err));
+        exit(EXIT_FAILURE);
+    }
     ev_tcp_server_set_tls(&server, &tls_opt);
-    int err = ev_tcp_server_listen(&server, HOST, PORT, on_connection);
+    err = ev_tcp_server_listen(&server, HOST, PORT, on_connection);
     if (err < 0) {
         if (err == -1)
             fprintf(stderr, "Something went wrong %s\n", strerror(errno));

examples/ping_pong.c

@@ -19,7 +19,11 @@ static void pong(ev_context *ctx, void *data) {
 
 int main(void) {
     ev_context ctx;
-    ev_init(&ctx, 32);
+    int err = ev_init(&ctx, 32);
+    if (err < EV_OK) {
+        fprintf(stderr, "Ev context init failed: Out of memory");
+        exit(EXIT_FAILURE);
+    }
     ev_register_cron(&ctx, ping, NULL, PING_SECONDS, 0);
     ev_register_cron(&ctx, pong, NULL, PONG_SECONDS, 0);
     ev_run(&ctx);