lib/silcutil/win32/silcwin32schedule.c

   1 /*
   2
   3   silcwin32schedule.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /* $Id$ */
  21
  22 #include "silcincludes.h"
  23
  24 /* Our "select()" for WIN32. This mimics the behaviour of select() system
  25    call. It does not call the Winsock's select() though. Its functions
  26    are derived from GLib's g_poll() and from some old Xemacs's sys_select().
  27
  28    This makes following assumptions, which I don't know whether they
  29    are correct or not:
  30
  31    o writefds are ignored, if set this will return immediately.
  32    o exceptfds are ignored totally
  33    o If all arguments except timeout are NULL then this will register
  34      a timeout with SetTimer and will wait just for Windows messages
  35      with WaitMessage.
  36    o MsgWaitForMultipleObjects is used to wait all kind of events, this
  37      includes SOCKETs and Windows messages.
  38    o All Windows messages are dispatched from this function.
  39    o The Operating System has Winsock 2.
  40
  41    References:
  42
  43    o http://msdn.microsoft.com/library/default.asp?
  44      url=/library/en-us/winui/hh/winui/messques_77zk.asp
  45    o http://msdn.microsoft.com/library/default.asp?
  46      url=/library/en-us/winsock/hh/winsock/apistart_9g1e.asp
  47    o http://msdn.microsoft.com/library/default.asp?
  48      url=/library/en-us/dnmgmt/html/msdn_getpeek.asp
  49    o http://developer.novell.com/support/winsock/doc/toc.htm
  50
  51 */
  52
  53 int silc_select(int n, fd_set *readfds, fd_set *writefds,
  54                 fd_set *exceptfds, struct timeval *timeout)
  55 {
  56   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  57   DWORD ready, curtime, timeo;
  58   int nhandles = 0, i;
  59   MSG msg;
  60
  61   /* Check fd sets (ignoring the exceptfds) */
  62   if (readfds) {
  63     for (i = 0; i < n - 1; i++)
  64       if (FD_ISSET(i, readfds))
  65         handles[nhandles++] = (HANDLE)i;
  66
  67     FD_ZERO(readfds);
  68   }
  69
  70   /* If writefds is set then return immediately */
  71   if (writefds) {
  72     for (i = 0; i < n - 1; i++)
  73       if (FD_ISSET(i, writefds))
  74         return 1;
  75   }
  76
  77   timeo = (timeout ? (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000) :
  78            INFINITE);
  79
  80   /* If we have nothing to wait and timeout is set then register a timeout
  81      and wait just for windows messages. */
  82   if (nhandles == 0 && timeout) {
  83     UINT timer = SetTimer(NULL, 0, timeo, NULL);
  84     curtime = GetTickCount();
  85     while (timer) {
  86       WaitMessage();
  87
  88       while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  89         if (msg.message == WM_TIMER) {
  90           KillTimer(NULL, timer);
  91           return 0;
  92         }
  93         TranslateMessage(&msg);
  94         DispatchMessage(&msg);
  95       }
  96
  97       KillTimer(NULL, timer);
  98       if (timeo != INFINITE) {
  99         timeo -= GetTickCount() - curtime;
 100         if (timeo < 0)
 101           timeo = 0;
 102       }
 103       timer = SetTimer(NULL, 0, timeo, NULL);
 104     }
 105   }
 106
 107  retry:
 108   curtime = GetTickCount();
 109   ready = MsgWaitForMultipleObjects(nhandles, handles, FALSE, timeo,
 110                                     QS_ALLINPUT);
 111
 112   if (ready == WAIT_FAILED) {
 113     /* Wait failed with error */
 114     SILC_LOG_WARNING(("WaitForMultipleObjects() failed"));
 115     return -1;
 116
 117   } else if (ready >= WAIT_ABANDONED_0 &&
 118              ready < WAIT_ABANDONED_0 + nhandles) {
 119     /* Signal abandoned */
 120     SILC_LOG_WARNING(("WaitForMultipleObjects() failed (ABANDONED)"));
 121     return -1;
 122   } else if (ready == WAIT_TIMEOUT) {
 123     /* Timeout */
 124     return 0;
 125   } else if (ready == WAIT_OBJECT_0 + nhandles) {
 126     /* Windows messages. The MSDN online says that if the application
 127        creates a window then its main loop (and we're assuming that
 128        it is our SILC Scheduler) must handle the Windows messages, so do
 129        it here as the MSDN suggests. */
 130     while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
 131       TranslateMessage(&msg);
 132       DispatchMessage(&msg);
 133     }
 134
 135     /* If timeout is set then we must update the timeout since we won't
 136        return and we will give the wait another try. */
 137     if (timeo != INFINITE) {
 138       timeo -= GetTickCount() - curtime;
 139       if (timeo < 0)
 140         timeo = 0;
 141     }
 142
 143     /* Give the wait another try */
 144    goto retry;
 145   } else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles &&
 146              readfds) {
 147     /* Some other event, like SOCKET or something. */
 148
 149     /* Go through all fds even though only one was set. This is to avoid
 150        starvation of high numbered fds. */
 151     ready -= WAIT_OBJECT_0;
 152     i = 0;
 153     do {
 154       /* Set the handle to fd set */
 155       FD_SET((int)handles[ready], readfds);
 156       i++;
 157
 158       /* Check the status of the next handle and set it's fd to the fd
 159          set if data is available. */
 160       while (++ready < n)
 161         if (WaitForSingleObject(handles[ready], 0) == WAIT_OBJECT_0)
 162           break;
 163     } while (ready < n);
 164
 165     return i;
 166   }
 167
 168   return -1;
 169 }
 170
 171 #ifdef SILC_THREADS
 172
 173 /* Internal wakeup context. */
 174 typedef struct {
 175   HANDLE wakeup_sema;
 176   SilcTask wakeup_task;
 177 } *SilcWin32Wakeup;
 178
 179 SILC_TASK_CALLBACK(silc_schedule_wakeup_cb)
 180 {
 181   /* Nothing */
 182 }
 183
 184 #endif /* SILC_THREADS */
 185
 186 /* Initializes the wakeup of the scheduler. In multi-threaded environment
 187    the scheduler needs to be wakenup when tasks are added or removed from
 188    the task queues. This will initialize the wakeup for the scheduler.
 189    Any tasks that needs to be registered must be registered to the `queue'.
 190    It is guaranteed that the scheduler will automatically free any
 191    registered tasks in this queue. This is system specific routine. */
 192
 193 void *silc_schedule_wakeup_init(void *queue)
 194 {
 195 #ifdef SILC_THREADS
 196   SilcWin32Wakeup wakeup;
 197
 198   wakeup = silc_calloc(1, sizeof(*wakeup));
 199
 200   wakeup->wakeup_sema = CreateSemaphore(NULL, 0, 100, NULL);
 201   if (!wakeup->wakeup_sema) {
 202     silc_free(wakeup);
 203     return NULL;
 204   }
 205
 206   wakeup->wakeup_task = silc_task_register(queue, (int)wakeup->wakeup_sema,
 207                                            silc_schedule_wakeup_cb, wakeup,
 208                                            0, 0, SILC_TASK_FD,
 209                                            SILC_TASK_PRI_NORMAL);
 210   if (!wakeup->wakeup_task) {
 211     CloseHandle(wakeup->wakeup_sema);
 212     silc_free(wakeup);
 213     return NULL;
 214   }
 215
 216   return (void *)wakeup;
 217 #else
 218   return NULL;
 219 #endif
 220 }
 221
 222 /* Uninitializes the system specific wakeup. */
 223
 224 void silc_schedule_wakeup_uninit(void *context)
 225 {
 226 #ifdef SILC_THREADS
 227   SilcWin32Wakeup wakeup = (SilcWin32Wakeup)context;
 228
 229   if (!wakeup)
 230     return;
 231
 232   CloseHandle(wakeup->wakeup_sema);
 233   silc_free(wakeup);
 234 #endif
 235 }
 236
 237 /* Wakes up the scheduler */
 238
 239 void silc_schedule_wakeup_internal(void *context)
 240 {
 241 #ifdef SILC_THREADS
 242   SilcWin32Wakeup wakeup = (SilcWin32Wakeup)context;
 243
 244   if (!wakeup)
 245     return;
 246
 247   ReleaseSemaphore(wakeup->wakeup_sema, 1, NULL);
 248 #endif
 249 }