Update for changed yaz_poll parameters
[yazpp-moved-to-github.git] / src / yaz-socket-manager.cpp
1 /*
2  * Copyright (c) 1998-2005, Index Data.
3  * See the file LICENSE for details.
4  * 
5  * $Id: yaz-socket-manager.cpp,v 1.38 2007-11-09 22:10:10 adam Exp $
6  */
7
8 #if HAVE_SYS_TIME_H
9 #include <sys/time.h>
10 #endif
11 #if HAVE_SYS_TYPES_H
12 #include <sys/types.h>
13 #endif
14 #if HAVE_UNISTD_H
15 #include <unistd.h>
16 #endif
17
18 #include <errno.h>
19 #include <string.h>
20 #include <assert.h>
21
22 #include <yaz/log.h>
23
24 #include <yazpp/socket-manager.h>
25 #include <yaz/poll.h>
26
27 using namespace yazpp_1;
28
29 SocketManager::SocketEntry **SocketManager::lookupObserver(
30     ISocketObserver *observer)
31 {
32     SocketEntry **se;
33     
34     for (se = &m_observers; *se; se = &(*se)->next)
35         if ((*se)->observer == observer)
36             break;
37     return se;
38 }
39
40 void SocketManager::addObserver(int fd, ISocketObserver *observer)
41 {
42     SocketEntry *se;
43
44     se = *lookupObserver(observer);
45     if (!se)
46     {
47         se = new SocketEntry;
48         se->next= m_observers;
49         m_observers = se;
50         se->observer = observer;
51     }
52     se->fd = fd;
53     se->mask = 0;
54     se->last_activity = 0;
55     se->timeout = -1;
56 }
57
58 void SocketManager::deleteObserver(ISocketObserver *observer)
59 {
60     SocketEntry **se = lookupObserver(observer);
61     if (*se)
62     {
63         removeEvent (observer);
64         SocketEntry *se_tmp = *se;
65         *se = (*se)->next;
66         delete se_tmp;
67     }
68 }
69
70 void SocketManager::deleteObservers()
71 {
72     SocketEntry *se = m_observers;
73     
74     while (se)
75     {
76         SocketEntry *se_next = se->next;
77         delete se;
78         se = se_next;
79     }
80     m_observers = 0;
81 }
82
83 void SocketManager::maskObserver(ISocketObserver *observer, int mask)
84 {
85     SocketEntry *se;
86
87     yaz_log(m_log, "obs=%p read=%d write=%d except=%d", observer,
88                     mask & SOCKET_OBSERVE_READ,
89                     mask & SOCKET_OBSERVE_WRITE,
90                     mask & SOCKET_OBSERVE_EXCEPT);
91
92     se = *lookupObserver(observer);
93     if (se)
94         se->mask = mask;
95 }
96
97 void SocketManager::timeoutObserver(ISocketObserver *observer,
98                                         int timeout)
99 {
100     SocketEntry *se;
101
102     se = *lookupObserver(observer);
103     if (se)
104         se->timeout = timeout;
105 }
106
107 int SocketManager::processEvent()
108 {
109     SocketEntry *p;
110     SocketEvent *event = getEvent();
111     int timeout = -1;
112     yaz_log (m_log, "SocketManager::processEvent manager=%p", this);
113     if (event)
114     {
115         event->observer->socketNotify(event->event);
116         delete event;
117         return 1;
118     }
119
120     int res;
121     time_t now = time(0);
122     int i;
123     int no_fds = 0;
124     for (p = m_observers; p; p = p->next)
125         no_fds++;
126
127     if (!no_fds)
128         return 0;
129     struct yaz_poll_fd *fds = new yaz_poll_fd [no_fds];
130     for (i = 0, p = m_observers; p; p = p->next, i++)
131     {
132         fds[i].fd = p->fd;
133         int input_mask = 0;
134         if (p->mask & SOCKET_OBSERVE_READ)
135             input_mask += yaz_poll_read;
136         if (p->mask & SOCKET_OBSERVE_WRITE)
137             input_mask += yaz_poll_write;
138         if (p->mask & SOCKET_OBSERVE_EXCEPT)
139             input_mask += yaz_poll_except;
140         if (p->timeout > 0 ||
141             (p->timeout == 0 && (p->mask & SOCKET_OBSERVE_WRITE) == 0))
142         {
143             int timeout_this;
144             timeout_this = p->timeout;
145             if (p->last_activity)
146                 timeout_this -= now - p->last_activity;
147             else
148                 p->last_activity = now;
149             if (timeout_this < 0 || timeout_this > 2147483646)
150                 timeout_this = 0;
151             if (timeout == -1 || timeout_this < timeout)
152                 timeout = timeout_this;
153             p->timeout_this = timeout_this;
154             yaz_log (m_log, "SocketManager::select timeout_this=%d", 
155                      p->timeout_this);
156         }
157         else
158             p->timeout_this = -1;
159         fds[i].input_mask = (enum yaz_poll_mask) input_mask;
160     }
161
162     int pass = 0;
163     while ((res = yaz_poll(fds, no_fds, timeout, 0)) < 0)
164     {
165         if (errno != EINTR)
166         {
167             yaz_log(YLOG_ERRNO|YLOG_WARN, "yaz_poll");
168             yaz_log(YLOG_WARN, "errno=%d timeout=%d", errno, timeout);
169             if (++pass > 10)
170                 return -1;
171         }
172     }
173     
174     yaz_log(m_log, "select returned res=%d", res);
175     now = time(0);
176     for (i = 0, p = m_observers; p; p = p->next, i++)
177     {
178         enum yaz_poll_mask output_mask = fds[i].output_mask;
179
180         int mask = 0;
181         if (output_mask & yaz_poll_read)
182             mask |= SOCKET_OBSERVE_READ;
183
184         if (output_mask & yaz_poll_write)
185             mask |= SOCKET_OBSERVE_WRITE;
186
187         if (output_mask & yaz_poll_except)
188             mask |= SOCKET_OBSERVE_EXCEPT;
189         
190         if (mask)
191         {
192             SocketEvent *event = new SocketEvent;
193             p->last_activity = now;
194             event->observer = p->observer;
195             event->event = mask;
196             putEvent (event);
197
198             yaz_log (m_log, "putEvent I/O mask=%d", mask);
199         }
200         else if (res == 0 && p->timeout_this == timeout)
201         {
202             SocketEvent *event = new SocketEvent;
203             assert (p->last_activity);
204             yaz_log (m_log, "putEvent timeout fd=%d, now = %ld last_activity=%ld timeout=%d",
205                      p->fd, now, p->last_activity, p->timeout);
206             p->last_activity = now;
207             event->observer = p->observer;
208             event->event = SOCKET_OBSERVE_TIMEOUT;
209             putEvent (event);
210         }
211     }
212     delete [] fds;
213     if ((event = getEvent()))
214     {
215         event->observer->socketNotify(event->event);
216         delete event;
217         return 1;
218     }
219     yaz_log(YLOG_WARN, "unhandled event in processEvent res=%d", res);
220     return 1;
221 }
222
223
224 //    n p    n p  ......   n p    n p
225 //   front                        back
226
227 void SocketManager::putEvent(SocketEvent *event)
228 {
229     // put in back of queue
230     if (m_queue_back)
231     {
232         m_queue_back->prev = event;
233         assert (m_queue_front);
234     }
235     else
236     {
237         assert (!m_queue_front);
238         m_queue_front = event;
239     }
240     event->next = m_queue_back;
241     event->prev = 0;
242     m_queue_back = event;
243 }
244
245 SocketManager::SocketEvent *SocketManager::getEvent()
246 {
247     // get from front of queue
248     SocketEvent *event = m_queue_front;
249     if (!event)
250         return 0;
251     assert (m_queue_back);
252     m_queue_front = event->prev;
253     if (m_queue_front)
254     {
255         assert (m_queue_back);
256         m_queue_front->next = 0;
257     }
258     else
259         m_queue_back = 0;
260     return event;
261 }
262
263 void SocketManager::removeEvent(ISocketObserver *observer)
264 {
265     SocketEvent *ev = m_queue_back;
266     while (ev)
267     {
268         SocketEvent *ev_next = ev->next;
269         if (observer == ev->observer)
270         {
271             if (ev->prev)
272                 ev->prev->next = ev->next;
273             else
274                 m_queue_back = ev->next;
275             if (ev->next)
276                 ev->next->prev = ev->prev;
277             else
278                 m_queue_front = ev->prev;
279             delete ev;
280         }
281         ev = ev_next;
282     }
283 }
284
285 SocketManager::SocketManager()
286 {
287     m_observers = 0;
288     m_queue_front = 0;
289     m_queue_back = 0;
290     m_log = YLOG_DEBUG;
291 }
292
293 SocketManager::~SocketManager()
294 {
295     deleteObservers();
296 }
297 /*
298  * Local variables:
299  * c-basic-offset: 4
300  * indent-tabs-mode: nil
301  * End:
302  * vim: shiftwidth=4 tabstop=8 expandtab
303  */
304