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.2  1999-01-28 13:08:48  adam
   8  * Yaz_PDU_Assoc better encapsulated. Memory leak fix in
   9  * yaz-socket-manager.cc.
  10  *
  11  * Revision 1.1.1.1  1999/01/28 09:41:07  adam
  12  * First implementation of YAZ++.
  13  *
  14  */
  15 #include <assert.h>
  16 #ifdef WINDOWS
  17 #include <winsock.h>
  18 #else
  19 #include <sys/time.h>
  20 #include <sys/types.h>
  21 #include <unistd.h>
  22 #endif
  23 #include <errno.h>
  24
  25 #include <log.h>
  26 #include <yaz-socket-manager.h>
  27
  28
  29 Yaz_SocketManager::YazSocketEntry **Yaz_SocketManager::lookupObserver(
  30     IYazSocketObserver *observer)
  31 {
  32     YazSocketEntry **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 Yaz_SocketManager::addObserver(int fd, IYazSocketObserver *observer)
  41 {
  42     YazSocketEntry *se;
  43
  44     se = *lookupObserver(observer);
  45     if (!se)
  46     {
  47         se = new YazSocketEntry;
  48         se->next= m_observers;
  49         m_observers = se;
  50         se->observer = observer;
  51     }
  52     se->fd = fd;
  53     se->mask = 0;
  54 }
  55
  56 void Yaz_SocketManager::deleteObserver(IYazSocketObserver *observer)
  57 {
  58     YazSocketEntry **se = lookupObserver(observer);
  59     if (*se)
  60     {
  61         removeEvent (observer);
  62         YazSocketEntry *se_tmp = *se;
  63         *se = (*se)->next;
  64         delete se_tmp;
  65     }
  66 }
  67
  68 void Yaz_SocketManager::deleteObservers()
  69 {
  70     YazSocketEntry *se = m_observers;
  71
  72     while (se)
  73     {
  74         YazSocketEntry *se_next = se->next;
  75         delete se;
  76         se = se_next;
  77     }
  78     m_observers = 0;
  79 }
  80
  81 void Yaz_SocketManager::maskObserver(IYazSocketObserver *observer, int mask)
  82 {
  83     YazSocketEntry *se;
  84
  85     se = *lookupObserver(observer);
  86     if (se)
  87         se->mask = mask;
  88 }
  89
  90 void Yaz_SocketManager::timeoutObserver(IYazSocketObserver *observer,
  91                                         unsigned timeout)
  92 {
  93     YazSocketEntry *se;
  94
  95     se = *lookupObserver(observer);
  96     if (se)
  97         se->timeout = timeout;
  98 }
  99
 100 int Yaz_SocketManager::processEvent()
 101 {
 102     YazSocketEvent *event = getEvent();
 103     if (event)
 104     {
 105         event->observer->socketNotify(event->event);
 106         delete event;
 107         return 1;
 108     }
 109
 110     fd_set in, out, except;
 111     int res;
 112     int max = 0;
 113     int no = 0;
 114     struct timeval to;
 115     struct timeval *timeout = &to;
 116
 117     FD_ZERO(&in);
 118     FD_ZERO(&out);
 119     FD_ZERO(&except);
 120
 121     timeout = &to; /* hang on select */
 122     to.tv_sec = 60;
 123     to.tv_usec = 0;
 124
 125     for (YazSocketEntry *p = m_observers; p; p = p->next)
 126     {
 127         int fd = p->fd;
 128         logf (LOG_LOG, "fd = %d mask=%d", fd, p->mask);
 129         if (p->mask)
 130             no++;
 131         if (p->mask & YAZ_SOCKET_OBSERVE_READ)
 132             FD_SET(fd, &in);
 133         if (p->mask & YAZ_SOCKET_OBSERVE_WRITE)
 134             FD_SET(fd, &out);
 135         if (p->mask & YAZ_SOCKET_OBSERVE_EXCEPT)
 136             FD_SET(fd, &except);
 137         if (fd > max)
 138             max = fd;
 139     }
 140     if (!no)
 141         return 0;
 142     while ((res = select(max + 1, &in, &out, &except, timeout)) < 0)
 143         if (errno != EINTR)
 144             return -1;
 145
 146     for (YazSocketEntry * p = m_observers; p; p = p->next)
 147     {
 148         int fd = p->fd;
 149         int mask = 0;
 150         if (FD_ISSET(fd, &in))
 151             mask |= YAZ_SOCKET_OBSERVE_READ;
 152
 153         if (FD_ISSET(fd, &out))
 154             mask |= YAZ_SOCKET_OBSERVE_WRITE;
 155
 156         if (FD_ISSET(fd, &except))
 157             mask |= YAZ_SOCKET_OBSERVE_EXCEPT;
 158
 159         if (mask)
 160         {
 161             YazSocketEvent *event = new YazSocketEvent;
 162             event->observer = p->observer;
 163             event->event = mask;
 164             putEvent (event);
 165         }
 166     }
 167     if ((event = getEvent()))
 168     {
 169         event->observer->socketNotify(event->event);
 170         delete event;
 171         return 1;
 172     }
 173     return 0;
 174 }
 175
 176 void Yaz_SocketManager::putEvent(YazSocketEvent *event)
 177 {
 178     // put in back of queue
 179     if (m_queue_back)
 180     {
 181         m_queue_back->prev = event;
 182         assert (m_queue_front);
 183     }
 184     else
 185     {
 186         assert (!m_queue_front);
 187         m_queue_front = event;
 188     }
 189     event->next = m_queue_back;
 190     event->prev = 0;
 191     m_queue_back = event;
 192 }
 193
 194 Yaz_SocketManager::YazSocketEvent *Yaz_SocketManager::getEvent()
 195 {
 196     // get from front of queue
 197     YazSocketEvent *event = m_queue_front;
 198     if (!event)
 199         return 0;
 200     assert (m_queue_back);
 201     m_queue_front = event->prev;
 202     if (m_queue_front)
 203     {
 204         assert (m_queue_back);
 205         m_queue_front->next = 0;
 206     }
 207     else
 208         m_queue_back = 0;
 209     return event;
 210 }
 211
 212 void Yaz_SocketManager::removeEvent(IYazSocketObserver *observer)
 213 {
 214     YazSocketEvent *ev = m_queue_back;
 215     while (ev)
 216     {
 217         YazSocketEvent *ev_next = ev->next;
 218         if (observer == ev->observer)
 219         {
 220             if (ev->prev)
 221                 ev->prev->next = ev->next;
 222             else
 223                 m_queue_back = ev->next;
 224             if (ev->next)
 225                 ev->next->prev = ev->prev;
 226             else
 227                 m_queue_front = ev->prev;
 228             delete ev;
 229         }
 230         ev = ev_next;
 231     }
 232 }
 233
 234 Yaz_SocketManager::Yaz_SocketManager()
 235 {
 236     m_observers = 0;
 237     m_queue_front = 0;
 238     m_queue_back = 0;
 239 }
 240
 241 Yaz_SocketManager::~Yaz_SocketManager()
 242 {
 243     deleteObservers();
 244 }