* Dropped _GNU_SOURCE define.

* Added a map_has_key function.
* Avoid changing needs_free value in hashmap_rehash function
* Added support for libkqueue on non linux systems: this way library should be buildable in windows and solaris too.

Author: FedeDP

CMakeLists.txt

@@ -15,22 +15,22 @@ if(BUILD_TESTS)
     if (CMOCKA_FOUND)
         enable_testing()
         add_subdirectory(tests)
-        message(STATUS "Building tests.")
+        message(STATUS "Tests building enabled.")
     else()
         message(WARNING "Missing cmocka.")
     endif()
 endif()
 
 if(BUILD_SAMPLES)
      add_subdirectory(Samples)
-     message(STATUS "Building examples.")
+     message(STATUS "Examples building enabled.")
 endif()
 
 if(BUILD_DOCS)
     find_package(Sphinx)
     if(SPHINX_FOUND)
         add_subdirectory(docs)
-        message(STATUS "Building docs.")
+        message(STATUS "Docs building enabled.")
     else()
         message(WARNING "Missing sphinx.")
     endif()
@@ -44,6 +44,7 @@ file(GLOB SOURCES Lib/*.c)
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     set(SOURCES ${SOURCES} Lib/poll_plugins/epoll_priv.c)
 else()
+    find_package(Kqueue REQUIRED)
     set(SOURCES ${SOURCES} Lib/poll_plugins/kqueue_priv.c)
 endif()
 
@@ -65,9 +66,13 @@ set_target_properties(
 )
 
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wtype-limits -Wstrict-overflow -fno-strict-aliasing -Wformat -Wformat-security") 
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -D_GNU_SOURCE -fvisibility=hidden")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -fvisibility=hidden")
 
-target_include_directories(${PROJECT_NAME} PRIVATE Lib/ Lib/public/module/)
+# KQUEUE_INCLUDE_DIRS will be empty where native epoll/kqueue are supported
+target_include_directories(${PROJECT_NAME} PRIVATE Lib/ Lib/public/module/ ${KQUEUE_INCLUDE_DIRS})
+
+# KQUEUE_LIBRARIES will be empty where native epoll/kqueue are supported
+target_link_libraries(${PROJECT_NAME} ${KQUEUE_LIBRARIES})
 
 install(TARGETS ${PROJECT_NAME}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

Lib/map.c

@@ -9,7 +9,7 @@
 typedef struct _hashmap_element {
     const char *key;
     bool in_use;
-    bool need_free;
+    bool needs_free;
     void *data;
 } map_elem;
 
@@ -27,6 +27,7 @@ static unsigned long crc32(const unsigned char *s, unsigned int len);
 static unsigned int hashmap_hash_int(const map_t *m, const char *keystring);
 static int hashmap_hash(map_t *m, const char* key);
 static map_ret_code hashmap_rehash(map_t *m);
+static map_ret_code hashmap_put(map_t *m, const char *key, void *value, const bool needs_free);
 
 static unsigned long crc32_tab[] = {
     0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
@@ -177,11 +178,10 @@ static map_ret_code hashmap_rehash(map_t *m) {
     m->size = 0;
 
     /* Rehash the elements */
-    int status = MAP_OK;
+    map_ret_code status = MAP_OK;
     for (int i = 0; i < old_size && status == MAP_OK; i++) {
         if (curr[i].in_use) {
-            /* Internal hashmap_put to avoid re-mallocing already malloc'd keys */
-            status = map_put(m, curr[i].key, curr[i].data, false);
+            status = hashmap_put(m, curr[i].key, curr[i].data, curr[i].needs_free);
         }
     }
     memhook._free(curr);
@@ -196,6 +196,11 @@ map_ret_code map_put(map_t *m, const char *key, void *value, const bool dupkey)
     MOD_ASSERT(key, "NULL key.", MAP_ERR);
     MOD_ASSERT(value, "NULL value.", MAP_ERR);
 
+    /* Find a place to put our value */
+    return hashmap_put(m, dupkey ? mem_strdup(key) : key, value, dupkey);
+}
+
+static map_ret_code hashmap_put(map_t *m, const char *key, void *value, const bool needs_free) {
     /* Find a place to put our value */
     int index = hashmap_hash(m, key);
     while (index == MAP_FULL) {
@@ -207,34 +212,41 @@ map_ret_code map_put(map_t *m, const char *key, void *value, const bool dupkey)
 
     /* Set the data */
     m->data[index].data = value;
-    m->data[index].key = dupkey ? mem_strdup(key) : key;
+    m->data[index].key = key;
     m->data[index].in_use = true;
-    m->data[index].need_free = dupkey;
+    m->data[index].needs_free = needs_free;
     m->size++;
     return MAP_OK;
 }
 
 /*
  * Get your pointer out of the hashmap with a key
  */
-map_ret_code map_get(const map_t *m, const char *key, void **arg) {
-    MOD_ASSERT(m, "NULL map.", MAP_ERR);
-    MOD_ASSERT(key, "NULL key.", MAP_ERR);
+void *map_get(const map_t *m, const char *key) {
+    if (!m) {
+        fprintf(stderr, "NULL map.\n");
+        return NULL;
+    }
+    if (!key) {
+        fprintf(stderr, "NULL key.\n");
+        return NULL;
+    }
 
     /* Find data location */
     int curr = hashmap_hash_int(m, key);
 
     /* Linear probing, if necessary */
     for (int i = 0; i< MAX_CHAIN_LENGTH; i++) {
         if (m->data[curr].in_use && !strcmp(m->data[curr].key, key)) {
-            *arg = (m->data[curr].data);
-            return MAP_OK;
+            return m->data[curr].data;
         }
         curr = (curr + 1) % m->table_size;
     }
-    
-    *arg = NULL;
-    return MAP_MISSING;
+    return NULL;
+}
+
+bool map_has_key(const map_t *m, const char *key) {
+    return map_get(m, key) != NULL;
 }
 
 /*
@@ -278,11 +290,11 @@ map_ret_code map_remove(map_t *m, const char *key) {
             /* Blank out the fields */
             m->data[curr].in_use = false;
             m->data[curr].data = NULL;
-            if (m->data[curr].need_free) {
+            if (m->data[curr].needs_free) {
                 memhook._free((void *)m->data[curr].key);
             }
             m->data[curr].key = NULL;
-            m->data[curr].need_free = false;
+            m->data[curr].needs_free = false;
 
             /* Reduce the size */
             m->size--;
@@ -300,7 +312,7 @@ map_ret_code map_free(map_t *m) {
     MOD_ASSERT(m, "NULL map.", MAP_ERR);
 
     for (int i = 0; i < m->table_size; i++) {
-        if (m->data[i].need_free) {
+        if (m->data[i].needs_free) {
             memhook._free((void *)m->data[i].key);
         }
     }

Lib/module.c

@@ -1,11 +1,10 @@
 #include "module.h"
 #include "poll_priv.h"
-#include <string.h>
-#include <stdarg.h>
 
 static module_ret_code init_ctx(const char *ctx_name, m_context **context);
 static void destroy_ctx(const char *ctx_name, m_context *context);
 static m_context *check_ctx(const char *ctx_name);
+static int _pipe(module *mod);
 static module_ret_code init_pubsub_fd(module *mod);
 static void default_logger(const self_t *self, const char *fmt, va_list args, const void *userdata);
 static int tell_if(void *data, void *m);
@@ -51,16 +50,30 @@ static void destroy_ctx(const char *ctx_name, m_context *context) {
 }
 
 static m_context *check_ctx(const char *ctx_name) {
-    m_context *context = NULL;
-    map_get(ctx, ctx_name, (void **)&context); \
+    m_context *context = map_get(ctx, ctx_name);
     if (!context) {
         init_ctx(ctx_name, &context);
     }
     return context;
 }
 
+static int _pipe(module *mod) {
+    int ret = pipe(mod->pubsub_fd);
+    if (ret == 0) {
+        for (int i = 0; i < 2; i++) {
+            int flags = fcntl(mod->pubsub_fd[i], F_GETFL, 0);
+            if (flags == -1) {
+                flags = 0;
+            }
+            fcntl(mod->pubsub_fd[i], F_SETFL, flags | O_NONBLOCK);
+            fcntl(mod->pubsub_fd[i], F_SETFD, FD_CLOEXEC);
+        }
+    }
+    return ret;
+}
+
 static module_ret_code init_pubsub_fd(module *mod) {
-    if (_pipe(mod->pubsub_fd) == 0) {
+    if (_pipe(mod) == 0) {
         if (module_register_fd(&mod->self, mod->pubsub_fd[0], true, NULL) == MOD_OK) {
             return MOD_OK;
         }
@@ -82,8 +95,7 @@ module_ret_code module_register(const char *name, const char *ctx_name, const se
     m_context *context = check_ctx(ctx_name);
     MOD_ASSERT(context, "Failed to create context.", MOD_ERR);
 
-    module *mod = NULL;
-    map_get(context->modules, name, (void **)&mod);
+    module *mod = map_get(context->modules, name);
     MOD_ASSERT(!mod, "Module with same name already registered in context.", MOD_ERR);
 
     MODULE_DEBUG("Registering module '%s'.\n", name);
@@ -277,9 +289,8 @@ char *mem_strdup(const char *s) {
 module_ret_code module_register_topic(const self_t *self, const char *topic) {
     MOD_ASSERT(topic, "NULL topic.", MOD_ERR);
     GET_MOD(self);
-    void *tmp = NULL;
 
-    if (map_get(c->topics, topic, (void **)&tmp) == MAP_MISSING) {
+    if (!map_has_key(c->topics, topic)) {
         if (map_put(c->topics, topic, mod, true) == MAP_OK) {
             tell_system_pubsub_msg(c, TOPIC_REGISTERED, topic);
             return MOD_OK;
@@ -291,10 +302,10 @@ module_ret_code module_register_topic(const self_t *self, const char *topic) {
 module_ret_code module_deregister_topic(const self_t *self, const char *topic) {
     MOD_ASSERT(topic, "NULL topic.", MOD_ERR);
     GET_MOD(self);
-    void *tmp = NULL;
+    void *tmp = map_get(c->topics, topic); // NULL if key is not present
 
     /* Only same mod which registered topic can deregister it */
-    if (map_get(c->topics, topic, (void **)&tmp) == MAP_OK && tmp == mod) {
+    if (tmp == mod) {
         if (map_remove(c->topics, topic) == MAP_OK) {
             tell_system_pubsub_msg(c, TOPIC_DEREGISTERED, topic);
             return MOD_OK;
@@ -306,11 +317,9 @@ module_ret_code module_deregister_topic(const self_t *self, const char *topic) {
 module_ret_code module_subscribe(const self_t *self, const char *topic) {
     MOD_ASSERT(topic, "NULL topic.", MOD_ERR);
     GET_MOD(self);
-    void *tmp = NULL;
 
     /* If topic exists and we are not already subscribed */
-    if (map_get(c->topics, topic, (void **)&tmp) == MAP_OK && 
-        map_get(mod->subscriptions, topic, (void **)&tmp) == MAP_MISSING) {
+    if (map_has_key(c->topics, topic) && !map_has_key(mod->subscriptions, topic)) {
         /* Store pointer to mod as value, even if it will be unused; this should be a hashset */
         if (map_put(mod->subscriptions, topic, mod, true) == MAP_OK) {
             return MOD_OK;
@@ -322,10 +331,8 @@ module_ret_code module_subscribe(const self_t *self, const char *topic) {
 module_ret_code module_unsubscribe(const self_t *self, const char *topic) {
     MOD_ASSERT(topic, "NULL topic.", MOD_ERR);
     GET_MOD(self);
-    void *tmp = NULL;
 
-    if (map_get(c->topics, topic, (void **)&tmp) == MAP_OK && 
-        map_remove(mod->subscriptions, topic) == MAP_OK) {
+    if (map_remove(mod->subscriptions, topic) == MAP_OK) {
         return MOD_OK;
     }
     return MOD_ERR;
@@ -358,15 +365,14 @@ int flush_pubsub_msg(void *data, void *m) {
 static int tell_if(void *data, void *m) {
     module *mod = (module *)m;
     const pubsub_msg_t *msg = (pubsub_msg_t *)data;
-    void *tmp = NULL;
 
     /* 
      * Only if mod is actually running or paused and 
      * it is a SYSTEM message or
      * topic is null or this module is subscribed to topic 
      */
     if (module_is(&mod->self, RUNNING | PAUSED) && (msg->type != USER || !msg->topic || 
-        map_get(mod->subscriptions, msg->topic, (void **)&tmp) == MAP_OK)) {
+        map_has_key(mod->subscriptions, msg->topic))) {
 
         MODULE_DEBUG("Telling a message to %s.\n", mod->self.name);
 
@@ -433,7 +439,7 @@ static module_ret_code publish_msg(const self_t *self, const char *topic,
      * Only module that registered a topic can publish on the topic.
      * Moreover, a publish can only be made on existent topic.
      */
-    if (!topic || (map_get(c->topics, topic, (void **)&tmp) == MAP_OK && tmp == mod)) {
+    if (!topic || ((tmp = map_get(c->topics, topic)) && tmp == mod)) {
         pubsub_msg_t m = { .topic = topic, .message = message, .sender = self, .type = USER, .size = size };
         return tell_pubsub_msg(&m, NULL, c);
     }

Lib/module_priv.h

@@ -1,6 +1,4 @@
-#include <assert.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include "map.h"
 
 #define MOD_ASSERT(cond, msg, ret) if(!cond) { fprintf(stderr, "%s\n", msg); return ret; }
@@ -13,13 +11,11 @@
 
 #define GET_CTX(name) \
     MOD_ASSERT(name, "NULL ctx.", MOD_ERR); \
-    m_context *c = NULL; \
-    map_get(ctx, (char *)name, (void **)&c); \
+    m_context *c = map_get(ctx, (char *)name); \
     MOD_ASSERT(c, "Context not found.", MOD_NO_CTX);
 
 #define CTX_GET_MOD(name, ctx) \
-    module *mod = NULL; \
-    map_get(ctx->modules, (char *)name, (void **)&mod); \
+    module *mod = map_get(ctx->modules, (char *)name); \
     MOD_ASSERT(mod, "Module not found.", MOD_NO_MOD);
 
 #define GET_MOD(self) \

Lib/modules.c

@@ -1,6 +1,5 @@
 #include "modules.h"
 #include "poll_priv.h"
-#include <string.h>
 
 static _ctor1_ void modules_init(void);
 static _dtor0_ void modules_destroy(void);

Lib/poll_plugins/epoll_priv.c

@@ -50,7 +50,3 @@ int poll_close(int fd, void **pevents, int *max_events) {
     poll_destroy_pevents(pevents, max_events);
     return close(fd);
 }
-
-int _pipe(int fd[2]) {
-    return pipe2(fd, O_NONBLOCK | O_CLOEXEC);
-}

Lib/poll_plugins/kqueue_priv.c

@@ -4,13 +4,8 @@
 #include <sys/time.h>
 
 int poll_create(void) {
-    int fd;
-#ifdef __APPLE__
-    fd = kqueue();
+    int fd = kqueue();
     fcntl(fd, F_SETFD, FD_CLOEXEC);
-#else
-    fd = kqueue1(O_CLOEXEC);
-#endif
     return fd;
 }
 
@@ -25,11 +20,9 @@ int poll_set_new_evt(module_poll_t *tmp, m_context *c, enum op_type flag) {
     struct kevent *_ev = (struct kevent *)tmp->ev;
     EV_SET(_ev, tmp->fd, EVFILT_READ, f, 0, 0, (void *)tmp);
     int ret = kevent(c->fd, _ev, 1, NULL, 0, NULL);
-    /* Workaround for STDIN_FILENO: it returns EINVAL on add, and ENOENT on remove but it is actually pollable */
-    if (ret == -1 && tmp->fd == STDIN_FILENO) {
-        if ((f == EV_ADD && errno == EINVAL) || (f == EV_DELETE && errno == ENOENT)) {
-            ret = 0;
-        }
+    /* Workaround for STDIN_FILENO: it is actually pollable */
+    if (tmp->fd == STDIN_FILENO) {
+        ret = 0;
     }
     return ret;
 }
@@ -63,18 +56,3 @@ int poll_close(int fd, void **pevents, int *max_events) {
     poll_destroy_pevents(pevents, max_events);
     return close(fd);
 }
-
-int _pipe(int fd[2]) {
-    int ret = pipe(fd);
-    if (ret == 0) {
-        for (int i = 0; i < 2; i++) {
-            int flags = fcntl(fd[i], F_GETFL, 0);
-            if (flags == -1) {
-                flags = 0;
-            }
-            fcntl(fd[i], F_SETFL, flags | O_NONBLOCK);
-            fcntl(fd[i], F_SETFD, FD_CLOEXEC);
-        }
-    }
-    return ret;
-}