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.17 2001-11-04 22:36:21 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++/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)
 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             return -1;
 173     now = time(0);
 174     for (p = m_observers; p; p = p->next)
 175     {
 176         int fd = p->fd;
 177         int mask = 0;
 178         if (FD_ISSET(fd, &in))
 179             mask |= YAZ_SOCKET_OBSERVE_READ;
 180
 181         if (FD_ISSET(fd, &out))
 182             mask |= YAZ_SOCKET_OBSERVE_WRITE;
 183
 184         if (FD_ISSET(fd, &except))
 185             mask |= YAZ_SOCKET_OBSERVE_EXCEPT;
 186
 187         if (mask)
 188         {
 189             YazSocketEvent *event = new YazSocketEvent;
 190             p->last_activity = now;
 191             event->observer = p->observer;
 192             event->event = mask;
 193             putEvent (event);
 194         }
 195         else if (res == 0 && p->timeout && p->timeout_this == timeout)
 196         {
 197             YazSocketEvent *event = new YazSocketEvent;
 198             assert (p->last_activity);
 199             yaz_log (m_log, "timeout, now = %ld last_activity=%ld timeout=%d",
 200                      now, p->last_activity, p->timeout);
 201             p->last_activity = now;
 202             event->observer = p->observer;
 203             event->event = YAZ_SOCKET_OBSERVE_TIMEOUT;
 204             putEvent (event);
 205         }
 206     }
 207     if ((event = getEvent()))
 208     {
 209         event->observer->socketNotify(event->event);
 210         delete event;
 211         return 1;
 212     }
 213     yaz_log (LOG_WARN, "unhandled event in processEvent");
 214     return 1;
 215 }
 216
 217
 218 //    n p    n p  ......   n p    n p
 219 //   front                        back
 220
 221 void Yaz_SocketManager::putEvent(YazSocketEvent *event)
 222 {
 223     // put in back of queue
 224     if (m_queue_back)
 225     {
 226         m_queue_back->prev = event;
 227         assert (m_queue_front);
 228     }
 229     else
 230     {
 231         assert (!m_queue_front);
 232         m_queue_front = event;
 233     }
 234     event->next = m_queue_back;
 235     event->prev = 0;
 236     m_queue_back = event;
 237 }
 238
 239 Yaz_SocketManager::YazSocketEvent *Yaz_SocketManager::getEvent()
 240 {
 241     // get from front of queue
 242     YazSocketEvent *event = m_queue_front;
 243     if (!event)
 244         return 0;
 245     assert (m_queue_back);
 246     m_queue_front = event->prev;
 247     if (m_queue_front)
 248     {
 249         assert (m_queue_back);
 250         m_queue_front->next = 0;
 251     }
 252     else
 253         m_queue_back = 0;
 254     return event;
 255 }
 256
 257 void Yaz_SocketManager::removeEvent(IYazSocketObserver *observer)
 258 {
 259     YazSocketEvent *ev = m_queue_back;
 260     while (ev)
 261     {
 262         YazSocketEvent *ev_next = ev->next;
 263         if (observer == ev->observer)
 264         {
 265             if (ev->prev)
 266                 ev->prev->next = ev->next;
 267             else
 268                 m_queue_back = ev->next;
 269             if (ev->next)
 270                 ev->next->prev = ev->prev;
 271             else
 272                 m_queue_front = ev->prev;
 273             delete ev;
 274         }
 275         ev = ev_next;
 276     }
 277 }
 278
 279 Yaz_SocketManager::Yaz_SocketManager()
 280 {
 281     m_observers = 0;
 282     m_queue_front = 0;
 283     m_queue_back = 0;
 284     m_log = LOG_DEBUG;
 285 }
 286
 287 Yaz_SocketManager::~Yaz_SocketManager()
 288 {
 289     deleteObservers();
 290 }