Workaround in poll_set_fd for STDIN_FILENO: avoid returning EPERM (it can be actually polled). Hopefully fixed tests on osx.

Author: FedeDP

Lib/module.c

@@ -2,6 +2,7 @@
 #include "poll_priv.h"
 #include <string.h>
 #include <stdarg.h>
+#include <errno.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);
@@ -12,6 +13,7 @@ static int tell_if(void *data, void *m);
 static pubsub_msg_t *create_pubsub_msg(const unsigned char *message, const self_t *sender, const char *topic, enum msg_type type, const size_t size);
 static module_ret_code tell_pubsub_msg(pubsub_msg_t *m, module *mod, m_context *c);
 static int manage_fds(module *mod, m_context *c, int flag, int stop);
+static int _poll_set_new_evt(module_poll_t *t, m_context *c, int flag);
 static module_ret_code start(const self_t *self, const enum module_states mask, const char *err_str);
 static module_ret_code stop(const self_t *self, const enum module_states mask, const char *err_str, int stop);
 
@@ -196,7 +198,7 @@ module_ret_code module_register_fd(const self_t *self, const int fd, const bool
 
     /* If a fd is registered at runtime, start polling on it */
     if (module_is(self, RUNNING)) {
-        int ret = poll_set_new_evt(tmp, c, ADD);
+        int ret = _poll_set_new_evt(tmp, c, ADD);
         return !ret ? MOD_OK : MOD_ERR;
     }
     return MOD_OK;
@@ -216,7 +218,7 @@ module_ret_code module_deregister_fd(const self_t *self, const int fd) {
             *tmp = (*tmp)->prev;
             /* If a fd is deregistered for a RUNNING module, stop polling on it */
             if (module_is(self, RUNNING)) {
-                ret = poll_set_new_evt(t, c, RM);
+                ret = _poll_set_new_evt(t, c, RM);
             }
             if (t->autoclose) {
                 close(t->fd);
@@ -445,12 +447,25 @@ static int manage_fds(module *mod, m_context *c, int flag, int stop) {
         if (flag == RM && stop) {
             ret = module_deregister_fd(&mod->self, t->fd);
         } else {
-            ret = poll_set_new_evt(t, c, flag);
+            ret = _poll_set_new_evt(t, c, flag);
         }
     }
     return ret;
 }
 
+/* 
+ * Just a call to poll_set_new_evt + some filtering:
+ * STDIN_FILENO returns EPERM but it is actually pollable
+ */
+static int _poll_set_new_evt(module_poll_t *t, m_context *c, int flag) {
+    int ret = poll_set_new_evt(t, c, flag);
+    /* Workaround for STDIN_FILENO */
+    if (ret == -1 && t->fd == STDIN_FILENO && errno == EPERM) {
+        ret = 0;
+    }
+    return ret;
+}
+
 static module_ret_code start(const self_t *self, const enum module_states mask, const char *err_str) {
     GET_MOD_IN_STATE(self, mask);
 

Lib/poll_plugins/kqueue_priv.c

@@ -7,9 +7,9 @@ int poll_create(void) {
     int fd;
 #ifdef __APPLE__
     fd = kqueue();
-#ifdef O_CLOEXEC
+// #ifdef FD_CLOEXEC
     fcntl(fd, F_SETFD, FD_CLOEXEC);
-#endif
+// #endif
 #else
     fd = kqueue1(O_CLOEXEC);
 #endif
@@ -68,9 +68,9 @@ int _pipe(int fd[2]) {
                 flags = 0;
             }
             fcntl(fd[i], F_SETFL, flags | O_NONBLOCK);
-#ifdef O_CLOEXEC
+// #ifdef FD_CLOEXEC
             fcntl(fd[i], F_SETFD, FD_CLOEXEC);
-#endif
+// #endif
         }
     }
     return ret;

TODO.md

@@ -6,7 +6,11 @@
 - [x] module_stop can be called on PAUSED modules too!
 - [x] Document module states! (STOP is same as IDLE; IDLE means it is registered but still never started. STOPPED it means it is registered, was started and was stopped.)
 
-- [x] Set O_CLOEXEC flag in non-linux poll implementation for both pipe and kqueue
+- [x] Set FD_CLOEXEC flag in non-linux poll implementation for both pipe and kqueue
+
+- [x] Fix CMakeLists to runt tests even if valgrind could not be found
+
+- [ ] Fix tests on osx? module_(de)register_fd fails
 
 ## 3.1.0
 

tests/test_module.c

@@ -12,7 +12,6 @@ static void recv(const msg_t *msg, const void *userdata);
 static void destroy(void);
 
 const self_t *self = NULL;
-int fd;
 
 void test_module_register_NULL_name(void **state) {
     (void) state; /* unused */
@@ -212,22 +211,21 @@ void test_module_become(void **state) {
 void test_module_add_wrong_fd(void **state) {
     (void) state; /* unused */
 
-    module_ret_code ret = module_register_fd(self, -1, 1, NULL);
+    module_ret_code ret = module_register_fd(self, -1, true, NULL);
     assert_false(ret == MOD_OK);
 }
 
 void test_module_add_fd_NULL_self(void **state) {
     (void) state; /* unused */
 
-    fd = open("/dev/tty", O_RDWR);
-    module_ret_code ret = module_register_fd(NULL, fd, 1, NULL);
+    module_ret_code ret = module_register_fd(NULL, STDIN_FILENO, true, NULL);
     assert_false(ret == MOD_OK);
 }
 
 void test_module_add_fd(void **state) {
     (void) state; /* unused */
 
-    module_ret_code ret = module_register_fd(self, fd, 1, NULL);
+    module_ret_code ret = module_register_fd(self, STDIN_FILENO, true, NULL);
     assert_true(ret == MOD_OK);
 }
 
@@ -241,14 +239,14 @@ void test_module_rm_wrong_fd(void **state) {
 void test_module_rm_wrong_fd_2(void **state) {
     (void) state; /* unused */
 
-    module_ret_code ret = module_deregister_fd(self, fd + 1);
+    module_ret_code ret = module_deregister_fd(self, STDIN_FILENO + 1);
     assert_false(ret == MOD_OK);
 }
 
 void test_module_rm_fd_NULL_self(void **state) {
     (void) state; /* unused */
 
-    module_ret_code ret = module_deregister_fd(NULL, fd);
+    module_ret_code ret = module_deregister_fd(NULL, STDIN_FILENO);
     assert_false(ret == MOD_OK);
 }
 
@@ -259,11 +257,11 @@ static int fd_is_valid(int fd) {
 void test_module_rm_fd(void **state) {
     (void) state; /* unused */
 
-    module_ret_code ret = module_deregister_fd(self, fd);
+    module_ret_code ret = module_deregister_fd(self, STDIN_FILENO);
     assert_true(ret == MOD_OK);
 
     /* Fd is now closed (module_deregister_fd with 1 flag) thus is no more valid */
-    assert_false(fd_is_valid(fd));
+    assert_false(fd_is_valid(STDIN_FILENO));
 }
 
 void test_module_subscribe_NULL_topic(void **state) {