Add polling

4 files changed, 129 insertions, 131 deletions

diff --git a/Makefile.am b/Makefile.am
index 65fb1a2..deed62c 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -7,6 +7,7 @@ libnul_la_SOURCES =	\
 	watch.c		\
 	dbus.c		\
 	array.c		\
+	epoll.c		\
 	libnul.h
 
 clean-local:
diff --git a/epoll.c b/epoll.c
index a464cc7..dd285b3 100644
--- a/epoll.c
+++ b/epoll.c
@@ -1,5 +1,5 @@
-#include "epoll.h"
 #include <sys/poll.h>
+#include "libnul.h"
 
 typedef struct FdInfo FdInfo;
 
@@ -10,151 +10,151 @@ struct FdInfo
      * almost nothing for that many clients, Still, cache use
      * would improve.
      */
-    gboolean		valid;
-    gboolean		disabled;
-    EPollEventType	mask;
-    gpointer		data;
+    gboolean			valid;
+    gboolean			disabled;
+    nul_poll_event_type_t	mask;
+    gpointer			data;
 };
 
-struct EPoll
+struct nul_poll_t
 {
     int		n_fds;
     gsize	n_fd_infos;
     FdInfo *	fd_info;
 };
 
-EPoll *
-epoll_new (void)
+nul_poll_t *
+nul_poll_new (void)
 {
-    EPoll *epoll = g_new0 (EPoll, 1);
+    nul_poll_t *nul_poll = g_new0 (nul_poll_t, 1);
     
-    epoll->n_fds = 0;
-    epoll->n_fd_infos = 1;
-    epoll->fd_info = g_new0 (FdInfo, 1);
+    nul_poll->n_fds = 0;
+    nul_poll->n_fd_infos = 1;
+    nul_poll->fd_info = g_new0 (FdInfo, 1);
     
-    return epoll;
+    return nul_poll;
 }
 
 void
-epoll_add_fd (EPoll   *epoll,
-	      int      fd,
-	      EPollEventType      mask,
-	      gpointer data)
+nul_poll_add_fd (nul_poll_t            *nul_poll,
+		 int                    fd,
+		 nul_poll_event_type_t  mask,
+		 gpointer               data)
 {
-    g_return_if_fail (!epoll_has_fd (epoll, fd));
-
-    while (fd >= epoll->n_fd_infos)
-	epoll->n_fd_infos *= 2;
+    g_return_if_fail (!nul_poll_has_fd (nul_poll, fd));
+    
+    while (fd >= nul_poll->n_fd_infos)
+	nul_poll->n_fd_infos *= 2;
     
-    epoll->fd_info = g_renew (FdInfo, epoll->fd_info, epoll->n_fd_infos);
+    nul_poll->fd_info = g_renew (FdInfo, nul_poll->fd_info, nul_poll->n_fd_infos);
     
-    epoll->n_fds++;
+    nul_poll->n_fds++;
     
-    epoll->fd_info[fd].valid = TRUE;
-    epoll->fd_info[fd].mask = mask;
-    epoll->fd_info[fd].data = data;
+    nul_poll->fd_info[fd].valid = TRUE;
+    nul_poll->fd_info[fd].mask = mask;
+    nul_poll->fd_info[fd].data = data;
 }
 
 gboolean
-epoll_has_fd (EPoll *epoll,
-	      int fd)
+nul_poll_has_fd (nul_poll_t *nul_poll,
+		 int         fd)
 {
-    g_return_val_if_fail (epoll != NULL, FALSE);
+    g_return_val_if_fail (nul_poll != NULL, FALSE);
     
-    return (fd < epoll->n_fd_infos && epoll->fd_info[fd].valid);
+    return (fd < nul_poll->n_fd_infos && nul_poll->fd_info[fd].valid);
 }
 
 gint
-epoll_get_n_fds (EPoll *epoll)
+nul_poll_get_n_fds (nul_poll_t *nul_poll)
 {
-    return epoll->n_fds;
+    return nul_poll->n_fds;
 }
 
 void
-epoll_remove_fd (EPoll  *epoll,
-		 int     fd)
+nul_poll_remove_fd (nul_poll_t *nul_poll,
+		    int         fd)
 {
-    g_return_if_fail (epoll_has_fd (epoll, fd));
+    g_return_if_fail (nul_poll_has_fd (nul_poll, fd));
     
-    epoll->fd_info[fd].valid = FALSE;
+    nul_poll->fd_info[fd].valid = FALSE;
 }
 
 gpointer
-epoll_get_fd_data (EPoll *epoll,
-		   int    fd)
+nul_poll_get_fd_data (nul_poll_t *nul_poll,
+		      int         fd)
 {
-    g_return_val_if_fail (epoll != NULL, NULL);
-    g_return_val_if_fail (epoll_has_fd (epoll, fd), NULL);
-
-    return epoll->fd_info[fd].data;
+    g_return_val_if_fail (nul_poll != NULL, NULL);
+    g_return_val_if_fail (nul_poll_has_fd (nul_poll, fd), NULL);
+    
+    return nul_poll->fd_info[fd].data;
 }
 
-/* epoll_wait() is a one-shot polling mechanism, so this function
+/* nul_poll_wait() is a one-shot polling mechanism, so this function
  * must be called to reenable fd's after they have been returned
- * by epoll_wait().
+ * by nul_poll_wait().
  */
 void
-epoll_reenable_fd (EPoll *epoll,
-		   int    fd)
+nul_poll_reenable_fd (nul_poll_t *nul_poll,
+		      int         fd)
 {
-    g_return_if_fail (epoll_has_fd (epoll, fd));
+    g_return_if_fail (nul_poll_has_fd (nul_poll, fd));
     
-    epoll->fd_info[fd].disabled = FALSE;
+    nul_poll->fd_info[fd].disabled = FALSE;
 }
 
-EPollEvent *
-epoll_wait (EPoll      *epoll,
-	    int	       *n_events,
-	    int         timeout)
+nul_poll_event_t *
+nul_poll_wait (nul_poll_t *nul_poll,
+	       int        *n_events,
+	       int         timeout)
 {
     struct pollfd *fds;
     int i, j;
     int n_poll_fds;
     int n_ready;
-    EPollEvent *events;
-
-    fds = g_new (struct pollfd, epoll->n_fds);
-
+    nul_poll_event_t *events;
+    
+    fds = g_new (struct pollfd, nul_poll->n_fds);
+    
     j = 0;
-    for (i = 0; i < epoll->n_fd_infos; ++i)
+    for (i = 0; i < nul_poll->n_fd_infos; ++i)
     {
-	if (epoll->fd_info[i].valid		&&
-	    !epoll->fd_info[i].disabled		&&
-	    epoll->fd_info[i].mask != 0)
+	if (nul_poll->fd_info[i].valid		&&
+	    !nul_poll->fd_info[i].disabled		&&
+	    nul_poll->fd_info[i].mask != 0)
 	{
 	    fds[j].events = 0;
-    
-	    if (epoll->fd_info[i].mask & EPOLL_READ)
+	    
+	    if (nul_poll->fd_info[i].mask & NUL_POLL_READ)
 		fds[j].events |= POLLIN;
-
-	    if (epoll->fd_info[i].mask & EPOLL_WRITE)
+	    
+	    if (nul_poll->fd_info[i].mask & NUL_POLL_WRITE)
 		fds[j].events |= POLLOUT;
 	    
-	    if (epoll->fd_info[i].mask & EPOLL_HANGUP)
+	    if (nul_poll->fd_info[i].mask & NUL_POLL_HANGUP)
 		fds[j].events |= POLLHUP;
 	    
-	    if (epoll->fd_info[i].mask & EPOLL_PRIORITY)
+	    if (nul_poll->fd_info[i].mask & NUL_POLL_PRIORITY)
 		fds[j].events |= POLLPRI;
 	    
-	    if (epoll->fd_info[i].mask & EPOLL_ERROR)
+	    if (nul_poll->fd_info[i].mask & NUL_POLL_ERROR)
 		fds[j].events |= POLLERR;
 	    
 	    fds[j].fd = i;
-
+	    
 	    j++;
 	}
     }
-
+    
     n_poll_fds = j;
-
+    
     events = NULL;
     
     n_ready = poll (fds, n_poll_fds, timeout);
-
+    
     if (n_ready)
     {
-	events = g_new0 (EPollEvent, n_ready);
-
+	events = g_new0 (nul_poll_event_t, n_ready);
+	
 	j = 0;
 	for (i = 0; i < n_poll_fds; ++i)
 	{
@@ -163,28 +163,28 @@ epoll_wait (EPoll      *epoll,
 		events[j].events = 0;
 		
 		if (fds[i].revents & POLLIN)
-		    events[j].events |= EPOLL_READ;
+		    events[j].events |= NUL_POLL_READ;
 		
 		if (fds[i].revents & POLLOUT)
-		    events[j].events |= EPOLL_WRITE;
+		    events[j].events |= NUL_POLL_WRITE;
 		
 		if (fds[i].revents & POLLHUP)
-		    events[j].events |= EPOLL_HANGUP;
+		    events[j].events |= NUL_POLL_HANGUP;
 		
 		if (fds[i].revents & POLLERR)
-		    events[j].events |= EPOLL_ERROR;
+		    events[j].events |= NUL_POLL_ERROR;
 		
 		if (fds[i].revents & POLLPRI)
-		    events[j].events |= EPOLL_PRIORITY;
+		    events[j].events |= NUL_POLL_PRIORITY;
 		
 		events[j].fd = fds[i].fd;
-		epoll->fd_info[fds[i].fd].disabled = TRUE;
+		nul_poll->fd_info[fds[i].fd].disabled = TRUE;
 	    }
 	}
     }
-
+    
     g_free (fds);
-
+    
     if (n_events)
 	*n_events = n_ready;
     
diff --git a/epoll.h b/epoll.h
deleted file mode 100644
index e16f7ea..0000000
--- a/epoll.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef _EPOLL_H_
-#define _EPOLL_H_
-
-#include <glib.h>
-
-typedef struct EPoll EPoll;
-
-typedef enum
-{
-    EPOLL_READ		= 1 << 0,
-    EPOLL_WRITE		= 1 << 1,
-    EPOLL_HANGUP	= 1 << 2,
-    EPOLL_ERROR		= 1 << 3,
-    EPOLL_PRIORITY	= 1 << 4,
-} EPollEventType;
-
-typedef struct
-{
-    EPollEventType	events;
-    int			fd;
-} EPollEvent;
-
-EPoll        *epoll_new (void);
-void          epoll_add_fd (EPoll     *epoll,
-			    int	fd,
-			    EPollEventType mask,
-			    gpointer	data);
-void          epoll_remove_fd (EPoll  *epoll,
-			       int     fd);
-gpointer      epoll_get_fd_data (EPoll *epoll,
-				 int    fd);
-gboolean      epoll_has_fd (EPoll *epoll,
-			    int fd);
-void          epoll_reenable_fd (EPoll *epoll,
-				 int    fd);
-gint          epoll_get_n_fds (EPoll *epoll);
-EPollEvent *  epoll_wait   (EPoll      *epoll,
-			    int	     *n_events,
-			    int         timeout);
-
-#endif
diff --git a/libnul.h b/libnul.h
index 611559c..6331348 100644
--- a/libnul.h
+++ b/libnul.h
@@ -30,20 +30,22 @@
  */
 
 #if defined(__GNUC__)  && __GNUC__ >= 4
-#  define NUL_STRUCT_OFFSET(struct_type, member) \
-      ((gssize) __builtin_offsetof (struct_type, member))
+#  define NUL_STRUCT_OFFSET(struct_type, member)			\
+    ((gssize) __builtin_offsetof (struct_type, member))
 #else
-#  define NUL_STRUCT_OFFSET(struct_type, member)	\
-      ((gssize) ((guint8*) &((struct_type*) 0)->member))
+#  define NUL_STRUCT_OFFSET(struct_type, member)			\
+    ((gssize) ((guint8*) &((struct_type*) 0)->member))
 #endif
 
 #if    __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-#define G_GNUC_WARN_UNUSED_RESULT 		\
-  __attribute__((warn_unused_result))
+#define NUL_GNUC_WARN_UNUSED_RESULT					\
+    __attribute__((warn_unused_result))
 #else
 #define G_GNUC_WARN_UNUSED_RESULT
 #endif /* __GNUC__ */
 
+#define NUL_UR G_GNUC_WARN_UNUSED_RESULT
+
 typedef void * nul_ptr_t;
 typedef void * const nul_const_ptr_t;
 
@@ -52,7 +54,7 @@ typedef void * const nul_const_ptr_t;
  */
 nul_ptr_t *nul_ptr_array_new    (void);
 nul_ptr_t *nul_ptr_array_append (nul_ptr_t *arr,
-				 nul_ptr_t data) G_GNUC_WARN_UNUSED_RESULT;
+				 nul_ptr_t data) NUL_UR;
 gsize      nul_ptr_array_len    (nul_const_ptr_t *arr);
 void       nul_ptr_array_free   (nul_ptr_t *arr);
 
@@ -60,8 +62,6 @@ void       nul_ptr_array_free   (nul_ptr_t *arr);
 /*
  * Strings
  */
-#define NUL_UR G_GNUC_WARN_UNUSED_RESULT
-
 typedef char nul_string_t;
 
 nul_string_t *nul_string_new              (void);
@@ -180,6 +180,44 @@ void	       nul_fun_def_free   (nul_fun_def_t  *fun);
 
 
 /*
+ * Polling filedescriptors
+ */
+typedef struct nul_poll_t nul_poll_t;
+
+typedef enum
+{
+    NUL_POLL_READ	= 1 << 0,
+    NUL_POLL_WRITE	= 1 << 1,
+    NUL_POLL_HANGUP	= 1 << 2,
+    NUL_POLL_ERROR	= 1 << 3,
+    NUL_POLL_PRIORITY	= 1 << 4,
+} nul_poll_event_type_t;
+
+typedef struct
+{
+    nul_poll_event_type_t	events;
+    int				fd;
+} nul_poll_event_t;
+
+nul_poll_t        *nul_poll_new         (void);
+void               nul_poll_add_fd      (nul_poll_t            *epoll,
+					 int                    fd,
+					 nul_poll_event_type_t  mask,
+					 gpointer               data);
+void               nul_poll_remove_fd   (nul_poll_t            *epoll,
+					 int                    fd);
+gpointer           nul_poll_get_fd_data (nul_poll_t            *epoll,
+					 int                    fd);
+gboolean           nul_poll_has_fd      (nul_poll_t            *epoll,
+					 int                    fd);
+void               nul_poll_reenable_fd (nul_poll_t            *epoll,
+					 int                    fd);
+gint               nul_poll_get_n_fds   (nul_poll_t            *epoll);
+nul_poll_event_t * nul_poll_wait        (nul_poll_t            *epoll,
+					 int                   *n_events,
+					 int                    timeout);
+
+/*
  * Watching file descriptors
  */
 typedef void (* WatchCallback) (gpointer data);