src/yaz-socket-manager.cpp

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