src/common/selectdispatcher.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/selectdispatcher.cpp
   3 // Purpose:     implements dispatcher for select() call
   4 // Author:      Lukasz Michalski and Vadim Zeitlin
   5 // Created:     December 2006
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2006 Lukasz Michalski
   8 // License:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #if wxUSE_SELECT_DISPATCHER
  23
  24 #include "wx/private/selectdispatcher.h"
  25 #include "wx/unix/private.h"
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/hash.h"
  29     #include "wx/log.h"
  30     #include "wx/intl.h"
  31 #endif
  32
  33 #if defined(HAVE_SYS_SELECT_H) || defined(__WATCOMC__)
  34     #include <sys/time.h>
  35     #include <sys/select.h>
  36 #endif
  37
  38 #include <errno.h>
  39
  40 #define wxSelectDispatcher_Trace wxT("selectdispatcher")
  41
  42 // ============================================================================
  43 // implementation
  44 // ============================================================================
  45
  46 // ----------------------------------------------------------------------------
  47 // wxSelectSets
  48 // ----------------------------------------------------------------------------
  49
  50 int wxSelectSets::ms_flags[wxSelectSets::Max] =
  51 {
  52     wxFDIO_INPUT,
  53     wxFDIO_OUTPUT,
  54     wxFDIO_EXCEPTION,
  55 };
  56
  57 const char *wxSelectSets::ms_names[wxSelectSets::Max] =
  58 {
  59     "input",
  60     "output",
  61     "exceptional",
  62 };
  63
  64 wxSelectSets::Callback wxSelectSets::ms_handlers[wxSelectSets::Max] =
  65 {
  66     &wxFDIOHandler::OnReadWaiting,
  67     &wxFDIOHandler::OnWriteWaiting,
  68     &wxFDIOHandler::OnExceptionWaiting,
  69 };
  70
  71 wxSelectSets::wxSelectSets()
  72 {
  73     for ( int n = 0; n < Max; n++ )
  74     {
  75         wxFD_ZERO(&m_fds[n]);
  76     }
  77 }
  78
  79 bool wxSelectSets::HasFD(int fd) const
  80 {
  81     for ( int n = 0; n < Max; n++ )
  82     {
  83         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
  84             return true;
  85     }
  86
  87     return false;
  88 }
  89
  90 bool wxSelectSets::SetFD(int fd, int flags)
  91 {
  92     wxCHECK_MSG( fd >= 0, false, _T("invalid descriptor") );
  93
  94     for ( int n = 0; n < Max; n++ )
  95     {
  96         if ( flags & ms_flags[n] )
  97         {
  98             wxFD_SET(fd, &m_fds[n]);
  99         }
 100         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
 101         {
 102             wxFD_CLR(fd, &m_fds[n]);
 103         }
 104     }
 105
 106     return true;
 107 }
 108
 109 int wxSelectSets::Select(int nfds, struct timeval *tv)
 110 {
 111     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 112 }
 113
 114 void wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
 115 {
 116     for ( int n = 0; n < Max; n++ )
 117     {
 118         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
 119         {
 120             wxLogTrace(wxSelectDispatcher_Trace,
 121                        _T("Got %s event on fd %d"), ms_names[n], fd);
 122             (handler.*ms_handlers[n])();
 123             // callback can modify sets and destroy handler
 124             // this forces that one event can be processed at one time
 125             return;
 126         }
 127     }
 128 }
 129
 130 // ----------------------------------------------------------------------------
 131 // wxSelectDispatcher
 132 // ----------------------------------------------------------------------------
 133
 134 bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
 135 {
 136     if ( !wxMappedFDIODispatcher::RegisterFD(fd, handler, flags) )
 137         return false;
 138
 139     if ( !m_sets.SetFD(fd, flags) )
 140        return false;
 141
 142     if ( fd > m_maxFD )
 143       m_maxFD = fd;
 144
 145     wxLogTrace(wxSelectDispatcher_Trace,
 146                 _T("Registered fd %d: input:%d, output:%d, exceptional:%d"), fd, (flags & wxFDIO_INPUT) == wxFDIO_INPUT, (flags & wxFDIO_OUTPUT), (flags & wxFDIO_EXCEPTION) == wxFDIO_EXCEPTION);
 147     return true;
 148 }
 149
 150 bool wxSelectDispatcher::ModifyFD(int fd, wxFDIOHandler *handler, int flags)
 151 {
 152     if ( !wxMappedFDIODispatcher::ModifyFD(fd, handler, flags) )
 153         return false;
 154
 155     wxASSERT_MSG( fd <= m_maxFD, _T("logic error: registered fd > m_maxFD?") );
 156
 157     wxLogTrace(wxSelectDispatcher_Trace,
 158                 _T("Modified fd %d: input:%d, output:%d, exceptional:%d"), fd, (flags & wxFDIO_INPUT) == wxFDIO_INPUT, (flags & wxFDIO_OUTPUT) == wxFDIO_OUTPUT, (flags & wxFDIO_EXCEPTION) == wxFDIO_EXCEPTION);
 159     return m_sets.SetFD(fd, flags);
 160 }
 161
 162 bool wxSelectDispatcher::UnregisterFD(int fd)
 163 {
 164     m_sets.ClearFD(fd);
 165
 166     if ( !wxMappedFDIODispatcher::UnregisterFD(fd) )
 167         return false;
 168
 169     // remove the handler if we don't need it any more
 170     if ( !m_sets.HasFD(fd) )
 171     {
 172         if ( fd == m_maxFD )
 173         {
 174             // need to find new max fd
 175             m_maxFD = -1;
 176             for ( wxFDIOHandlerMap::const_iterator it = m_handlers.begin();
 177                   it != m_handlers.end();
 178                   ++it )
 179             {
 180                 if ( it->first > m_maxFD )
 181                 {
 182                     m_maxFD = it->first;
 183                 }
 184             }
 185         }
 186     }
 187
 188     wxLogTrace(wxSelectDispatcher_Trace,
 189                 _T("Removed fd %d, current max: %d"), fd, m_maxFD);
 190     return true;
 191 }
 192
 193 bool wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
 194 {
 195     bool gotEvent = false;
 196     for ( int fd = 0; fd <= m_maxFD; fd++ )
 197     {
 198         if ( !sets.HasFD(fd) )
 199             continue;
 200
 201         wxFDIOHandler * const handler = FindHandler(fd);
 202         if ( !handler )
 203         {
 204             wxFAIL_MSG( _T("NULL handler in wxSelectDispatcher?") );
 205             continue;
 206         }
 207
 208         gotEvent = true;
 209
 210         sets.Handle(fd, *handler);
 211     }
 212
 213     return gotEvent;
 214 }
 215
 216 bool wxSelectDispatcher::Dispatch(int timeout)
 217 {
 218     struct timeval tv,
 219                   *ptv;
 220     if ( timeout != TIMEOUT_INFINITE )
 221     {
 222         ptv = &tv;
 223         tv.tv_sec = 0;
 224         tv.tv_usec = timeout*1000;
 225     }
 226     else // no timeout
 227     {
 228         ptv = NULL;
 229     }
 230
 231     wxSelectSets sets = m_sets;
 232
 233     const int ret = sets.Select(m_maxFD + 1, ptv);
 234     switch ( ret )
 235     {
 236         case -1:
 237             if ( errno != EINTR )
 238             {
 239                 wxLogSysError(_("Failed to monitor I/O channels"));
 240             }
 241             break;
 242
 243         case 0:
 244             // timeout expired without anything happening
 245             break;
 246
 247         default:
 248             if ( ProcessSets(sets) )
 249                 return true;
 250     }
 251
 252     // nothing happened
 253     return false;
 254 }
 255
 256 #endif // wxUSE_SELECT_DISPATCHER