Fixed bug #2068: pkg-config trouble.

[yaz-moved-to-github.git] / src / eventl.c

diff --git a/src/eventl.c b/src/eventl.c
index 2392cc8..f2963a1 100644 (file)
--- a/src/eventl.c
+++ b/src/eventl.c
@@ -1,8 +1,8 @@
 /*
- * Copyright (C) 1995-2005, Index Data ApS
+ * Copyright (C) 1995-2007, Index Data ApS
  * See the file LICENSE for details.
  *
- * $Id: eventl.c,v 1.9 2005-06-25 15:46:04 adam Exp $
+ * $Id: eventl.c,v 1.17 2007-11-30 11:44:47 adam Exp $
  */
 
 /**
@@ -10,7 +10,7 @@
  * \brief Implements event loop handling for GFS.
  *
  * This source implements the main event loop for the Generic Frontend
- * Server. It uses select(2).
+ * Server.
  */
 
 #include <assert.h>
@@ -25,17 +25,9 @@
 #if HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
-#ifdef WIN32
-#include <winsock.h>
-#endif
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#if HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
 
-#include <yaz/yconfig.h>
+#include <yaz/poll.h>
+
 #include <yaz/log.h>
 #include <yaz/comstack.h>
 #include <yaz/xmalloc.h>
@@ -43,15 +35,6 @@
 #include "session.h"
 #include <yaz/statserv.h>
 
-#if YAZ_GNU_THREADS
-#include <pth.h>
-#define YAZ_EV_SELECT pth_select
-#endif
-
-#ifndef YAZ_EV_SELECT
-#define YAZ_EV_SELECT select
-#endif
-
 static int log_level=0;
 static int log_level_initialized=0;
 
@@ -78,14 +61,32 @@ IOCHAN iochan_create(int fd, IOC_CALLBACK cb, int flags, int chan_id)
     return new_iochan;
 }
 
-int event_loop(IOCHAN *iochans)
+
+int iochan_is_alive(IOCHAN chan)
+{
+    struct yaz_poll_fd fds;
+    int res;
+
+    fds.fd = chan->fd;
+    fds.input_mask = yaz_poll_read;
+    res = yaz_poll(&fds, 1, 0, 0);
+    if (res == 0)
+        return 1;
+    if (!ir_read(chan, EVENT_INPUT))
+        return 0;
+    return 1;
+}
+
+int iochan_event_loop(IOCHAN *iochans)
 {
     do /* loop as long as there are active associations to process */
     {
         IOCHAN p, nextp;
-        fd_set in, out, except;
-        int res, max;
-        static struct timeval to;
+        int i;
+        int tv_sec = 3600;
+        int no_fds = 0;
+        struct yaz_poll_fd *fds = 0;
+        int res;
         time_t now = time(0);
 
         if (statserv_must_terminate())
@@ -93,27 +94,23 @@ int event_loop(IOCHAN *iochans)
             for (p = *iochans; p; p = p->next)
                 p->force_event = EVENT_TIMEOUT;
         }
-        FD_ZERO(&in);
-        FD_ZERO(&out);
-        FD_ZERO(&except);
-        to.tv_sec = 3600;
-        to.tv_usec = 0;
-        max = 0;
         for (p = *iochans; p; p = p->next)
+            no_fds++;
+        fds = (struct yaz_poll_fd *) xmalloc(no_fds * sizeof(*fds));
+        for (i = 0, p = *iochans; p; p = p->next, i++)
         {
             time_t w, ftime;
+            enum yaz_poll_mask input_mask = yaz_poll_none;
             yaz_log(log_level, "fd=%d flags=%d force_event=%d",
                     p->fd, p->flags, p->force_event);
             if (p->force_event)
-                to.tv_sec = 0;          /* polling select */
+                tv_sec = 0;          /* polling select */
             if (p->flags & EVENT_INPUT)
-                FD_SET(p->fd, &in);
+                yaz_poll_add(input_mask, yaz_poll_read);
             if (p->flags & EVENT_OUTPUT)
-                FD_SET(p->fd, &out);
+                yaz_poll_add(input_mask, yaz_poll_write);
             if (p->flags & EVENT_EXCEPT)
-                FD_SET(p->fd, &except);
-            if (p->fd > max)
-                max = p->fd;
+                yaz_poll_add(input_mask, yaz_poll_except);
             if (p->max_idle && p->last_event)
             {
                 ftime = p->last_event + p->max_idle;
@@ -121,13 +118,13 @@ int event_loop(IOCHAN *iochans)
                     w = p->max_idle;
                 else
                     w = ftime - now;
-                if (w < to.tv_sec)
-                    to.tv_sec = w;
+                if (w < tv_sec)
+                    tv_sec = w;
             }
+            fds[i].fd = p->fd;
+            fds[i].input_mask = input_mask;
         }
-        yaz_log(log_level, "select start %ld", (long) to.tv_sec);
-        res = YAZ_EV_SELECT(max + 1, &in, &out, &except, &to);
-        yaz_log(log_level, "select end");
+        res = yaz_poll(fds, no_fds, tv_sec, 0);
         if (res < 0)
         {
             if (yaz_errno() == EINTR)
@@ -137,6 +134,7 @@ int event_loop(IOCHAN *iochans)
                     for (p = *iochans; p; p = p->next)
                         p->force_event = EVENT_TIMEOUT;
                 }
+                xfree(fds);
                 continue;
             }
             else
@@ -153,24 +151,25 @@ int event_loop(IOCHAN *iochans)
             }
         }
         now = time(0);
-        for (p = *iochans; p; p = p->next)
+        for (i = 0, p = *iochans; p; p = p->next, i++)
         {
             int force_event = p->force_event;
+            enum yaz_poll_mask output_mask = fds[i].output_mask;
 
             p->force_event = 0;
-            if (!p->destroyed && (FD_ISSET(p->fd, &in) ||
-                force_event == EVENT_INPUT))
+            if (!p->destroyed && ((output_mask & yaz_poll_read) ||
+                                  force_event == EVENT_INPUT))
             {
                 p->last_event = now;
                 (*p->fun)(p, EVENT_INPUT);
             }
-            if (!p->destroyed && (FD_ISSET(p->fd, &out) ||
-                force_event == EVENT_OUTPUT))
+            if (!p->destroyed && ((output_mask & yaz_poll_write) ||
+                                  force_event == EVENT_OUTPUT))
             {
                 p->last_event = now;
                 (*p->fun)(p, EVENT_OUTPUT);
             }
-            if (!p->destroyed && (FD_ISSET(p->fd, &except) ||
+            if (!p->destroyed && ((output_mask & yaz_poll_except) ||
                 force_event == EVENT_EXCEPT))
             {
                 p->last_event = now;
@@ -183,6 +182,7 @@ int event_loop(IOCHAN *iochans)
                 (*p->fun)(p, EVENT_TIMEOUT);
             }
         }
+        xfree(fds);
         for (p = *iochans; p; p = nextp)
         {
             nextp = p->next;