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