Bump copyright year
[pazpar2-moved-to-github.git] / src / eventl.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2010 Index Data
3
4 Pazpar2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 /*
21  * Based on  ParaZ - a simple tool for harvesting performance data for
22  * parallel operations using Z39.50.
23  * Copyright (C) 2006-2010 Index Data ApS
24  * See LICENSE file for details.
25  */
26
27 /*
28  * Based on revision YAZ' server/eventl.c 1.29.
29  */
30
31 #if HAVE_CONFIG_H
32 #include <config.h>
33 #endif
34
35 #include <stdio.h>
36 #include <assert.h>
37
38 #ifdef WIN32
39 #include <winsock.h>
40 #else
41 #include <unistd.h>
42 #endif
43 #if HAVE_SYS_TIME_H
44 #include <sys/time.h>
45 #endif
46
47 #include <stdlib.h>
48 #include <errno.h>
49 #include <string.h>
50
51 #include <yaz/yconfig.h>
52 #include <yaz/log.h>
53 #include <yaz/comstack.h>
54 #include <yaz/xmalloc.h>
55 #include "eventl.h"
56 #include <yaz/statserv.h>
57
58 IOCHAN iochan_create(int fd, IOC_CALLBACK cb, int flags)
59 {
60     IOCHAN new_iochan;
61
62     if (!(new_iochan = (IOCHAN)xmalloc(sizeof(*new_iochan))))
63         return 0;
64     new_iochan->destroyed = 0;
65     new_iochan->fd = fd;
66     new_iochan->flags = flags;
67     new_iochan->fun = cb;
68     new_iochan->socketfun = NULL;
69     new_iochan->maskfun = NULL;
70     new_iochan->force_event = 0;
71     new_iochan->last_event = new_iochan->max_idle = 0;
72     new_iochan->next = NULL;
73     return new_iochan;
74 }
75
76 int event_loop(IOCHAN *iochans)
77 {
78     do /* loop as long as there are active associations to process */
79     {
80         IOCHAN p, nextp;
81         fd_set in, out, except;
82         int res, max;
83         static struct timeval nullto = {0, 0}, to;
84         struct timeval *timeout;
85
86         FD_ZERO(&in);
87         FD_ZERO(&out);
88         FD_ZERO(&except);
89         timeout = &to; /* hang on select */
90         to.tv_sec = 15;
91         to.tv_usec = 0;
92         max = 0;
93         for (p = *iochans; p; p = p->next)
94         {
95             if (p->maskfun)
96                 p->flags = (*p->maskfun)(p);
97             if (p->socketfun)
98                 p->fd = (*p->socketfun)(p);
99             if (p->fd < 0)
100                 continue;
101             if (p->force_event)
102                 timeout = &nullto;        /* polling select */
103             if (p->flags & EVENT_INPUT)
104                 FD_SET(p->fd, &in);
105             if (p->flags & EVENT_OUTPUT)
106                 FD_SET(p->fd, &out);
107             if (p->flags & EVENT_EXCEPT)
108                 FD_SET(p->fd, &except);
109             if (p->fd > max)
110                 max = p->fd;
111             if (p->max_idle && p->max_idle < to.tv_sec)
112                 to.tv_sec = p->max_idle;
113         }
114         res = select(max + 1, &in, &out, &except, timeout);        
115         if (res < 0)
116         {
117             if (errno == EINTR)
118                 continue;
119             else
120             {
121                 yaz_log(YLOG_ERRNO|YLOG_WARN, "select");
122                 return 0;
123             }
124         }
125         for (p = *iochans; p; p = p->next)
126         {
127             int force_event = p->force_event;
128             time_t now = time(0);
129
130             p->force_event = 0;
131             if (!p->destroyed && ((p->max_idle && now - p->last_event >
132                 p->max_idle) || force_event == EVENT_TIMEOUT))
133             {
134                 p->last_event = now;
135                 (*p->fun)(p, EVENT_TIMEOUT);
136             }
137             if (p->fd < 0)
138                 continue;
139             if (!p->destroyed && (FD_ISSET(p->fd, &in) ||
140                 force_event == EVENT_INPUT))
141             {
142                 p->last_event = now;
143                 yaz_log(YLOG_DEBUG, "Eventl input event");
144                 (*p->fun)(p, EVENT_INPUT);
145             }
146             if (!p->destroyed && (FD_ISSET(p->fd, &out) ||
147                 force_event == EVENT_OUTPUT))
148             {
149                 p->last_event = now;
150                 yaz_log(YLOG_DEBUG, "Eventl output event");
151                 (*p->fun)(p, EVENT_OUTPUT);
152             }
153             if (!p->destroyed && (FD_ISSET(p->fd, &except) ||
154                 force_event == EVENT_EXCEPT))
155             {
156                 p->last_event = now;
157                 (*p->fun)(p, EVENT_EXCEPT);
158             }
159         }
160         for (p = *iochans; p; p = nextp)
161         {
162             nextp = p->next;
163
164             if (p->destroyed)
165             {
166                 IOCHAN tmp = p, pr;
167
168                 /* Now reset the pointers */
169                 if (p == *iochans)
170                     *iochans = p->next;
171                 else
172                 {
173                     for (pr = *iochans; pr; pr = pr->next)
174                         if (pr->next == p)
175                             break;
176                     assert(pr); /* grave error if it weren't there */
177                     pr->next = p->next;
178                 }
179                 if (nextp == p)
180                     nextp = p->next;
181                 xfree(tmp);
182             }
183         }
184     }
185     while (*iochans);
186     return 0;
187 }
188
189 /*
190  * Local variables:
191  * c-basic-offset: 4
192  * c-file-style: "Stroustrup"
193  * indent-tabs-mode: nil
194  * End:
195  * vim: shiftwidth=4 tabstop=8 expandtab
196  */
197