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 // Copyright:   (c) 2006 Lukasz Michalski
   7 // Licence:     wxWindows licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // ============================================================================
  11 // declarations
  12 // ============================================================================
  13
  14 // ----------------------------------------------------------------------------
  15 // headers
  16 // ----------------------------------------------------------------------------
  17
  18 // for compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22     #pragma hdrstop
  23 #endif
  24
  25 #if wxUSE_SELECT_DISPATCHER
  26
  27 #include "wx/private/selectdispatcher.h"
  28 #include "wx/unix/private.h"
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/hash.h"
  32     #include "wx/log.h"
  33     #include "wx/intl.h"
  34 #endif
  35
  36 #include <errno.h>
  37
  38 #define wxSelectDispatcher_Trace wxT("selectdispatcher")
  39
  40 // ============================================================================
  41 // implementation
  42 // ============================================================================
  43
  44 // ----------------------------------------------------------------------------
  45 // wxSelectSets
  46 // ----------------------------------------------------------------------------
  47
  48 int wxSelectSets::ms_flags[wxSelectSets::Max] =
  49 {
  50     wxFDIO_INPUT,
  51     wxFDIO_OUTPUT,
  52     wxFDIO_EXCEPTION,
  53 };
  54
  55 const char *wxSelectSets::ms_names[wxSelectSets::Max] =
  56 {
  57     "input",
  58     "output",
  59     "exceptional",
  60 };
  61
  62 wxSelectSets::Callback wxSelectSets::ms_handlers[wxSelectSets::Max] =
  63 {
  64     &wxFDIOHandler::OnReadWaiting,
  65     &wxFDIOHandler::OnWriteWaiting,
  66     &wxFDIOHandler::OnExceptionWaiting,
  67 };
  68
  69 wxSelectSets::wxSelectSets()
  70 {
  71     for ( int n = 0; n < Max; n++ )
  72     {
  73         wxFD_ZERO(&m_fds[n]);
  74     }
  75 }
  76
  77 bool wxSelectSets::HasFD(int fd) const
  78 {
  79     for ( int n = 0; n < Max; n++ )
  80     {
  81         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
  82             return true;
  83     }
  84
  85     return false;
  86 }
  87
  88 bool wxSelectSets::SetFD(int fd, int flags)
  89 {
  90     wxCHECK_MSG( fd >= 0, false, wxT("invalid descriptor") );
  91
  92     for ( int n = 0; n < Max; n++ )
  93     {
  94         if ( flags & ms_flags[n] )
  95         {
  96             wxFD_SET(fd, &m_fds[n]);
  97         }
  98         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
  99         {
 100             wxFD_CLR(fd, &m_fds[n]);
 101         }
 102     }
 103
 104     return true;
 105 }
 106
 107 int wxSelectSets::Select(int nfds, struct timeval *tv)
 108 {
 109     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 110 }
 111
 112 bool wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
 113 {
 114     for ( int n = 0; n < Max; n++ )
 115     {
 116         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
 117         {
 118             wxLogTrace(wxSelectDispatcher_Trace,
 119                        wxT("Got %s event on fd %d"), ms_names[n], fd);
 120             (handler.*ms_handlers[n])();
 121             // callback can modify sets and destroy handler
 122             // this forces that one event can be processed at one time
 123             return true;
 124         }
 125     }
 126
 127     return false;
 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                 wxT("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, wxT("logic error: registered fd > m_maxFD?") );
 156
 157     wxLogTrace(wxSelectDispatcher_Trace,
 158                 wxT("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                 wxT("Removed fd %d, current max: %d"), fd, m_maxFD);
 190     return true;
 191 }
 192
 193 int wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
 194 {
 195     int numEvents = 0;
 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( wxT("NULL handler in wxSelectDispatcher?") );
 205             continue;
 206         }
 207
 208         if ( sets.Handle(fd, *handler) )
 209             numEvents++;
 210     }
 211
 212     return numEvents;
 213 }
 214
 215 int wxSelectDispatcher::DoSelect(wxSelectSets& sets, int timeout) const
 216 {
 217     struct timeval tv,
 218                   *ptv;
 219     if ( timeout != TIMEOUT_INFINITE )
 220     {
 221         ptv = &tv;
 222         tv.tv_sec = timeout / 1000;
 223         tv.tv_usec = (timeout % 1000)*1000;
 224     }
 225     else // no timeout
 226     {
 227         ptv = NULL;
 228     }
 229
 230     int ret = sets.Select(m_maxFD + 1, ptv);
 231
 232     // TODO: we need to restart select() in this case but for now just return
 233     //       as if timeout expired
 234     if ( ret == -1 && errno == EINTR )
 235         ret = 0;
 236
 237     return ret;
 238 }
 239
 240 bool wxSelectDispatcher::HasPending() const
 241 {
 242     wxSelectSets sets(m_sets);
 243     return DoSelect(sets, 0) > 0;
 244 }
 245
 246 int wxSelectDispatcher::Dispatch(int timeout)
 247 {
 248     wxSelectSets sets(m_sets);
 249     switch ( DoSelect(sets, timeout) )
 250     {
 251         case -1:
 252             wxLogSysError(_("Failed to monitor I/O channels"));
 253             return -1;
 254
 255         case 0:
 256             // timeout expired without anything happening
 257             return 0;
 258
 259         default:
 260             return ProcessSets(sets);
 261     }
 262 }
 263
 264 #endif // wxUSE_SELECT_DISPATCHER