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 #include "silcschedule_i.h"
  24
  25 /* Our "select()" for WIN32. This mimics the behaviour of select() system
  26    call. It does not call the Winsock's select() though. Its functions
  27    are derived from GLib's g_poll() and from some old Xemacs's sys_select().
  28
  29    This makes following assumptions, which I don't know whether they
  30    are correct or not:
  31
  32    o SILC_TASK_WRITE is ignored, if set this will return immediately.
  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(SilcScheduleFd fds, SilcUInt32 fds_count, struct timeval *timeout)
  54 {
  55   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  56   DWORD ready, curtime, timeo;
  57   int nhandles = 0, i;
  58   MSG msg;
  59
  60   if (fds_count > MAXIMUM_WAIT_OBJECTS)
  61     fds_count = MAXIMUM_WAIT_OBJECTS;
  62
  63   for (i = 0; i < fds_count; i++) {
  64     if (!fds[i].events)
  65       continue;
  66
  67     if (fds[i].events & SILC_TASK_READ)
  68       handles[nhandles++] = (HANDLE)fds[i].fd;
  69
  70     /* If writing then just set the bit and return */
  71     if (fds[i].events & SILC_TASK_WRITE) {
  72       fds[i].revents = SILC_TASK_WRITE;
  73       return 1;
  74     }
  75
  76     fds[i].revents = 0;
  77   }
  78
  79   timeo = (timeout ? (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000) :
  80            INFINITE);
  81
  82   /* If we have nothing to wait and timeout is set then register a timeout
  83      and wait just for windows messages. */
  84   if (nhandles == 0 && timeout) {
  85     UINT timer = SetTimer(NULL, 0, timeo, NULL);
  86     curtime = GetTickCount();
  87     while (timer) {
  88       WaitMessage();
  89
  90       while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  91         if (msg.message == WM_TIMER) {
  92           KillTimer(NULL, timer);
  93           return 0;
  94         }
  95         TranslateMessage(&msg);
  96         DispatchMessage(&msg);
  97       }
  98
  99       KillTimer(NULL, timer);
 100       if (timeo != INFINITE) {
 101         timeo -= GetTickCount() - curtime;
 102         if (timeo < 0)
 103           timeo = 0;
 104       }
 105       timer = SetTimer(NULL, 0, timeo, NULL);
 106     }
 107   }
 108
 109  retry:
 110   curtime = GetTickCount();
 111   ready = MsgWaitForMultipleObjects(nhandles, handles, FALSE, timeo,
 112                                     QS_ALLINPUT);
 113
 114   if (ready == WAIT_FAILED) {
 115     /* Wait failed with error */
 116     SILC_LOG_WARNING(("WaitForMultipleObjects() failed"));
 117     return -1;
 118   } else if (ready >= WAIT_ABANDONED_0 &&
 119              ready < WAIT_ABANDONED_0 + nhandles) {
 120     /* Signal abandoned */
 121     SILC_LOG_WARNING(("WaitForMultipleObjects() failed (ABANDONED)"));
 122     return -1;
 123   } else if (ready == WAIT_TIMEOUT) {
 124     /* Timeout */
 125     return 0;
 126   } else if (ready == WAIT_OBJECT_0 + nhandles) {
 127     /* Windows messages. The MSDN online says that if the application
 128        creates a window then its main loop (and we're assuming that
 129        it is our SILC Scheduler) must handle the Windows messages, so do
 130        it here as the MSDN suggests. */
 131     while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
 132       TranslateMessage(&msg);
 133       DispatchMessage(&msg);
 134     }
 135
 136     /* If timeout is set then we must update the timeout since we won't
 137        return and we will give the wait another try. */
 138     if (timeo != INFINITE) {
 139       timeo -= GetTickCount() - curtime;
 140       if (timeo < 0)
 141         timeo = 0;
 142     }
 143
 144     /* Give the wait another try */
 145    goto retry;
 146   } else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles) {
 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     do {
 153       for (i = 0; i < fds_count; i++) {
 154         if (!fds[i].events)
 155           continue;
 156
 157         if (fds[i].fd == (int)handles[ready]) {
 158           fds[i].revents |= SILC_TASK_READ;
 159           break;
 160         }
 161       }
 162
 163       /* Check the status of the next handle and set its fd to the fd
 164          set if data is available. */
 165       while (++ready < fds_count)
 166         if (WaitForSingleObject(handles[ready], 0) == WAIT_OBJECT_0)
 167           break;
 168     } while (ready < fds_count);
 169
 170     return i + 1;
 171   }
 172
 173   return -1;
 174 }
 175
 176 #ifdef SILC_THREADS
 177
 178 /* Internal wakeup context. */
 179 typedef struct {
 180   HANDLE wakeup_sema;
 181   SilcTask wakeup_task;
 182 } *SilcWin32Wakeup;
 183
 184 SILC_TASK_CALLBACK(silc_schedule_wakeup_cb)
 185 {
 186   /* Nothing */
 187 }
 188
 189 #endif /* SILC_THREADS */
 190
 191 /* Initializes the platform specific scheduler.  This for example initializes
 192    the wakeup mechanism of the scheduler.  In multi-threaded environment
 193    the scheduler needs to be wakenup when tasks are added or removed from
 194    the task queues.  Returns context to the platform specific scheduler. */
 195
 196 void *silc_schedule_internal_init(SilcSchedule schedule, void *app_context)
 197 {
 198 #ifdef SILC_THREADS
 199   SilcWin32Wakeup wakeup;
 200
 201   wakeup = silc_calloc(1, sizeof(*wakeup));
 202
 203   wakeup->wakeup_sema = CreateSemaphore(NULL, 0, 100, NULL);
 204   if (!wakeup->wakeup_sema) {
 205     silc_free(wakeup);
 206     return NULL;
 207   }
 208
 209   wakeup->wakeup_task =
 210     silc_schedule_task_add(schedule, (int)wakeup->wakeup_sema,
 211                            silc_schedule_wakeup_cb, wakeup,
 212                            0, 0, SILC_TASK_FD,
 213                            SILC_TASK_PRI_NORMAL);
 214   if (!wakeup->wakeup_task) {
 215     CloseHandle(wakeup->wakeup_sema);
 216     silc_free(wakeup);
 217     return NULL;
 218   }
 219
 220   return (void *)wakeup;
 221 #else
 222   return NULL;
 223 #endif
 224 }
 225
 226 /* Uninitializes the platform specific scheduler context. */
 227
 228 void silc_schedule_internal_uninit(void *context)
 229 {
 230 #ifdef SILC_THREADS
 231   SilcWin32Wakeup wakeup = (SilcWin32Wakeup)context;
 232
 233   if (!wakeup)
 234     return;
 235
 236   CloseHandle(wakeup->wakeup_sema);
 237   silc_free(wakeup);
 238 #endif
 239 }
 240
 241 /* Wakes up the scheduler */
 242
 243 void silc_schedule_internal_wakeup(void *context)
 244 {
 245 #ifdef SILC_THREADS
 246   SilcWin32Wakeup wakeup = (SilcWin32Wakeup)context;
 247
 248   if (!wakeup)
 249     return;
 250
 251   ReleaseSemaphore(wakeup->wakeup_sema, 1, NULL);
 252 #endif
 253 }
 254
 255 /* Register signal */
 256
 257 void silc_schedule_internal_signal_register(void *context,
 258                                             SilcUInt32 signal,
 259                                             SilcTaskCallback callback,
 260                                             void *callback_context)
 261 {
 262
 263 }
 264
 265 /* Unregister signal */
 266
 267 void silc_schedule_internal_signal_unregister(void *context,
 268                                               SilcUInt32 signal,
 269                                               SilcTaskCallback callback,
 270                                               void *callback_context)
 271 {
 272
 273 }
 274
 275 /* Mark signal to be called later. */
 276
 277 void silc_schedule_internal_signal_call(void *context, SilcUInt32 signal)
 278 {
 279
 280 }
 281
 282 /* Call all signals */
 283
 284 void silc_schedule_internal_signals_call(void *context,
 285                                          SilcSchedule schedule)
 286 {
 287
 288 }
 289
 290 /* Block registered signals in scheduler. */
 291
 292 void silc_schedule_internal_signals_block(void *context)
 293 {
 294
 295 }
 296
 297 /* Unblock registered signals in schedule. */
 298
 299 void silc_schedule_internal_signals_unblock(void *context)
 300 {
 301
 302 }