src/yaz-socket-manager.cpp

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