iodine 0.4.19 → 0.5.0

data/ext/iodine/evio_callbacks.c

@@ -0,0 +1,26 @@
+/*
+Copyright: Boaz Segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "evio.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* *****************************************************************************
+Callbacks - weak versions to be overridden.
+***************************************************************************** */
+#pragma weak evio_on_data
+void __attribute__((weak)) evio_on_data(void *arg) { (void)arg; }
+#pragma weak evio_on_ready
+void __attribute__((weak)) evio_on_ready(void *arg) { (void)arg; }
+#pragma weak evio_on_error
+void __attribute__((weak)) evio_on_error(void *arg) { (void)arg; }
+#pragma weak evio_on_close
+void __attribute__((weak)) evio_on_close(void *arg) { (void)arg; }

data/ext/iodine/evio_epoll.c

@@ -0,0 +1,251 @@
+/*
+Copyright: Boaz Segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "evio.h"
+
+#ifdef EVIO_ENGINE_EPOLL
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+/* *****************************************************************************
+Global data and system independant code
+***************************************************************************** */
+
+/* epoll tester, in and out */
+static int evio_fd[3] = {-1, -1, -1};
+
+/** Closes the `epoll` / `kqueue` object, releasing it's resources. */
+void evio_close() {
+  for (int i = 0; i < 3; ++i) {
+    if (evio_fd[i] != -1) {
+      close(evio_fd[i]);
+      evio_fd[i] = -1;
+    }
+  }
+}
+
+/**
+returns true if the evio is available for adding or removing file descriptors.
+*/
+int evio_isactive(void) { return evio_fd[0] >= 0; }
+
+/* *****************************************************************************
+Linux `epoll` implementation
+***************************************************************************** */
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+
+/**
+Creates the `epoll` or `kqueue` object.
+*/
+intptr_t evio_create() {
+  evio_close();
+  for (int i = 0; i < 3; ++i) {
+    evio_fd[i] = epoll_create1(EPOLL_CLOEXEC);
+    if (evio_fd[i] == -1)
+      goto error;
+  }
+  for (int i = 1; i < 3; ++i) {
+    struct epoll_event chevent = {
+        .events = (EPOLLOUT | EPOLLIN), .data.fd = evio_fd[i],
+    };
+    if (epoll_ctl(evio_fd[0], EPOLL_CTL_ADD, evio_fd[i], &chevent) == -1)
+      goto error;
+  }
+  return 0;
+error:
+#if DEBUB
+  perror("ERROR: (evoid) failed to initialize");
+#endif
+  evio_close();
+  return -1;
+}
+
+/**
+Removes a file descriptor from the polling object.
+*/
+void evio_remove(int fd) {
+  if (evio_fd[0] < 0)
+    return;
+  struct epoll_event chevent = {.events = (EPOLLOUT | EPOLLIN), .data.fd = fd};
+  epoll_ctl(evio_fd[1], EPOLL_CTL_DEL, fd, &chevent);
+  epoll_ctl(evio_fd[2], EPOLL_CTL_DEL, fd, &chevent);
+}
+
+static inline int evio_add2(int fd, void *callback_arg, uint32_t events,
+                            int ep_fd) {
+  struct epoll_event chevent;
+  errno = 0;
+  chevent = (struct epoll_event){
+      .events = events, .data.ptr = (void *)callback_arg,
+  };
+  int ret = epoll_ctl(ep_fd, EPOLL_CTL_MOD, fd, &chevent);
+  if (ret == -1 && errno == ENOENT) {
+    errno = 0;
+    chevent = (struct epoll_event){
+        .events = events, .data.ptr = (void *)callback_arg,
+    };
+    ret = epoll_ctl(ep_fd, EPOLL_CTL_ADD, fd, &chevent);
+  }
+  return ret;
+}
+
+/**
+Adds a file descriptor to the polling object.
+*/
+int evio_add(int fd, void *callback_arg) {
+  if (evio_add2(fd, callback_arg,
+                (EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
+                evio_fd[1]) == -1)
+    return -1;
+  if (evio_add2(fd, callback_arg,
+                (EPOLLOUT | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
+                evio_fd[2]) == -1)
+    return -1;
+  return 0;
+}
+
+/**
+Adds a file descriptor to the polling object (ONE SHOT), to be polled for
+incoming data (`evio_on_data` wil be called).
+*/
+int evio_add_read(int fd, void *callback_arg) {
+  return evio_add2(fd, callback_arg,
+                   (EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
+                   evio_fd[1]);
+}
+
+/**
+Adds a file descriptor to the polling object (ONE SHOT), to be polled for
+outgoing buffer readiness data (`evio_on_ready` wil be called).
+*/
+int evio_add_write(int fd, void *callback_arg) {
+  return evio_add2(fd, callback_arg,
+                   (EPOLLOUT | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
+                   evio_fd[2]);
+}
+
+/**
+Creates a timer file descriptor, system dependent.
+*/
+int evio_open_timer(void) {
+#ifndef TFD_NONBLOCK
+  int fd = timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
+  if (fd != -1) { /* make sure it's a non-blocking timer. */
+#if defined(O_NONBLOCK)
+    /* Fixme: O_NONBLOCK is defined but broken on SunOS 4.1.x and AIX 3.2.5. */
+    int flags;
+    if (-1 == (flags = fcntl(fd, F_GETFL, 0)))
+      flags = 0;
+    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
+      goto error;
+#else
+    /* no O_NONBLOCK, use the old way of doing it */
+    static int flags = 1;
+    if (ioctl(fd, FIOBIO, &flags) == -1)
+      goto error;
+#endif
+  }
+  return fd;
+error:
+  close(fd);
+  return -1;
+#else
+  return timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+#endif
+}
+
+/**
+Adds a timer file descriptor, so that callbacks will be called for it's events.
+*/
+int evio_set_timer(int fd, void *callback_arg, unsigned long milliseconds) {
+
+  if (evio_fd[0] < 0)
+    return -1;
+  /* clear out existing timer marker, if exists. */
+  char data[8]; // void * is 8 byte long
+  if (read(fd, &data, 8) < 0)
+    data[0] = 0;
+  /* set file's time value */
+  struct itimerspec new_t_data;
+  new_t_data.it_value.tv_sec = new_t_data.it_interval.tv_sec =
+      milliseconds / 1000;
+  new_t_data.it_value.tv_nsec = new_t_data.it_interval.tv_nsec =
+      (milliseconds % 1000) * 1000000;
+  if (timerfd_settime(fd, 0, &new_t_data, NULL) == -1)
+    return -1;
+  /* add to epoll */
+  return evio_add2(fd, callback_arg, (EPOLLIN | EPOLLONESHOT), evio_fd[1]);
+}
+
+/**
+Reviews any pending events (up to EVIO_MAX_EVENTS) and calls any callbacks.
+ */
+int evio_review(const int timeout_millisec) {
+  if (evio_fd[0] < 0)
+    return -1;
+  struct epoll_event internal[2];
+  struct epoll_event events[EVIO_MAX_EVENTS];
+  int total = 0;
+  /* wait for events and handle them */
+  int internal_count = epoll_wait(evio_fd[0], internal, 2, timeout_millisec);
+  if (internal_count == -1)
+    return -1;
+  if (internal_count == 0)
+    return 0;
+  for (int j = 0; j < internal_count; ++j) {
+    int active_count =
+        epoll_wait(internal[j].data.fd, events, EVIO_MAX_EVENTS, 0);
+    if (active_count > 0) {
+      for (int i = 0; i < active_count; i++) {
+        if (events[i].events & (~(EPOLLIN | EPOLLOUT))) {
+          // errors are hendled as disconnections (on_close)
+          evio_on_error(events[i].data.ptr);
+        } else {
+          // no error, then it's an active event(s)
+          if (events[i].events & EPOLLOUT) {
+            evio_on_ready(events[i].data.ptr);
+          }
+          if (events[i].events & EPOLLIN)
+            evio_on_data(events[i].data.ptr);
+        }
+      } // end for loop
+      total += active_count;
+    }
+  }
+
+  return total;
+}
+
+#include <poll.h>
+
+/** Waits up to `timeout_millisec` for events. No events are signaled. */
+int evio_wait(const int timeout_millisec) {
+  if (evio_fd[0] < 0)
+    return -1;
+  struct pollfd pollfd = {
+      .fd = evio_fd[0], .events = POLLIN,
+  };
+  return poll(&pollfd, 1, timeout_millisec);
+}
+
+#endif /* system dependent code */

data/ext/iodine/evio_kqueue.c

@@ -0,0 +1,193 @@
+/*
+Copyright: Boaz Segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "evio.h"
+
+#ifdef EVIO_ENGINE_KQUEUE
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/event.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+/* *****************************************************************************
+Global data and system independant code
+***************************************************************************** */
+
+static int evio_fd = -1;
+static pid_t owner_pid = 0;
+
+/** Closes the `epoll` / `kqueue` object, releasing it's resources. */
+void evio_close() {
+  /* the file descriptor is never inherited by fork */
+  if (evio_fd != -1 && owner_pid == getpid()) {
+    close(evio_fd);
+    evio_fd = -1;
+  }
+}
+
+/**
+returns true if the evio is available for adding or removing file descriptors.
+*/
+int evio_isactive(void) { return evio_fd >= 0; }
+
+/* *****************************************************************************
+BSD `kqueue` implementation
+***************************************************************************** */
+
+/**
+Creates the `epoll` or `kqueue` object.
+*/
+intptr_t evio_create() {
+  evio_close();
+  owner_pid = getpid();
+  return evio_fd = kqueue();
+}
+
+/**
+Removes a file descriptor from the polling object.
+*/
+void evio_remove(int fd) {
+  if (evio_fd < 0)
+    return;
+  struct kevent chevent[3];
+  EV_SET(chevent, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+  EV_SET(chevent + 1, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
+  EV_SET(chevent + 2, fd, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
+  kevent(evio_fd, chevent, 3, NULL, 0, NULL);
+}
+
+/**
+Adds a file descriptor to the polling object.
+*/
+int evio_add(int fd, void *callback_arg) {
+  struct kevent chevent[2];
+  EV_SET(chevent, fd, EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR | EV_ONESHOT,
+         0, 0, callback_arg);
+  EV_SET(chevent + 1, fd, EVFILT_WRITE,
+         EV_ADD | EV_ENABLE | EV_CLEAR | EV_ONESHOT, 0, 0, callback_arg);
+  return kevent(evio_fd, chevent, 2, NULL, 0, NULL);
+}
+
+/**
+Adds a file descriptor to the polling object (ONE SHOT), to be polled for
+incoming data (`evio_on_data` wil be called).
+*/
+int evio_add_read(int fd, void *callback_arg) {
+  struct kevent chevent[1];
+  EV_SET(chevent, fd, EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR | EV_ONESHOT,
+         0, 0, callback_arg);
+  return kevent(evio_fd, chevent, 1, NULL, 0, NULL);
+}
+
+/**
+Adds a file descriptor to the polling object (ONE SHOT), to be polled for
+outgoing buffer readiness data (`evio_on_ready` wil be called).
+*/
+int evio_add_write(int fd, void *callback_arg) {
+  struct kevent chevent[1];
+  EV_SET(chevent, fd, EVFILT_WRITE, EV_ADD | EV_ENABLE | EV_CLEAR | EV_ONESHOT,
+         0, 0, callback_arg);
+  return kevent(evio_fd, chevent, 1, NULL, 0, NULL);
+}
+
+/**
+Creates a timer file descriptor, system dependent.
+*/
+int evio_open_timer() {
+#ifdef P_tmpdir
+  if (P_tmpdir[sizeof(P_tmpdir) - 1] == '/') {
+    char name_template[] = P_tmpdir "evio_facil_timer_XXXXXX";
+    return mkstemp(name_template);
+  }
+  char name_template[] = P_tmpdir "/evio_facil_timer_XXXXXX";
+  return mkstemp(name_template);
+#else
+  char name_template[] = "/tmp/evio_facil_timer_XXXXXX";
+  return mkstemp(name_template);
+#endif
+}
+
+/**
+Adds a timer file descriptor, so that callbacks will be called for it's events.
+*/
+int evio_set_timer(int fd, void *callback_arg, unsigned long milliseconds) {
+  struct kevent chevent;
+  EV_SET(&chevent, fd, EVFILT_TIMER, EV_ADD | EV_ENABLE | EV_ONESHOT, 0,
+         milliseconds, callback_arg);
+  return kevent(evio_fd, &chevent, 1, NULL, 0, NULL);
+}
+
+/**
+Reviews any pending events (up to EVIO_MAX_EVENTS) and calls any callbacks.
+ */
+int evio_review(const int timeout_millisec) {
+  if (evio_fd < 0)
+    return -1;
+  struct kevent events[EVIO_MAX_EVENTS];
+
+  const struct timespec timeout = {.tv_sec = (timeout_millisec / 1024),
+                                   .tv_nsec =
+                                       ((timeout_millisec % 1024) * 1000000)};
+  /* wait for events and handle them */
+  int active_count =
+      kevent(evio_fd, NULL, 0, events, EVIO_MAX_EVENTS, &timeout);
+
+  if (active_count > 0) {
+    for (int i = 0; i < active_count; i++) {
+      // test for event(s) type
+      if (events[i].filter == EVFILT_READ || events[i].filter == EVFILT_TIMER) {
+        evio_on_data(events[i].udata);
+      }
+      // connection errors should be reported after `read` in case there's data
+      // left in the buffer.
+      if (events[i].flags & (EV_EOF | EV_ERROR)) {
+        // errors are hendled as disconnections (on_close)
+        // fprintf(stderr, "%p: %s\n", events[i].udata,
+        //         (events[i].flags & EV_EOF)
+        //             ? "EV_EOF"
+        //             : (events[i].flags & EV_ERROR) ? "EV_ERROR" : "WTF?");
+        evio_on_error(events[i].udata);
+      } else if (events[i].filter == EVFILT_WRITE) {
+        // we can only write if there's no error in the socket
+        evio_on_ready(events[i].udata);
+      }
+    }
+  } else if (active_count < 0) {
+    if (errno == EINTR)
+      return 0;
+    return -1;
+  }
+  return active_count;
+}
+
+#include <poll.h>
+
+/** Waits up to `timeout_millisec` for events. No events are signaled. */
+int evio_wait(const int timeout_millisec) {
+  if (evio_fd < 0)
+    return -1;
+  struct pollfd pollfd = {
+      .fd = evio_fd, .events = POLLIN,
+  };
+  return poll(&pollfd, 1, timeout_millisec);
+}
+
+#endif /* system dependent code */