src/ioset-win32.c

   1 /* Win32 ioset backend for srvx
   2  * Copyright 2006 srvx Development Team
   3  *
   4  * This file is part of srvx.
   5  *
   6  * srvx is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with srvx; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
  19  */
  20
  21 #include "ioset-impl.h"
  22 #include "common.h"
  23 #include "log.h"
  24
  25 /* This is massively kludgy.  Unfortunately, the only performant I/O
  26  * multiplexer with halfway decent semantics under Windows is
  27  * WSAAsyncSelect() -- which requires a window that can receive
  28  * messages.
  29  *
  30  * So ioset_win32_init() creates a hidden window and sets it up for
  31  * asynchronous socket notifications.
  32  */
  33
  34 #define IDT_TIMER1 1000
  35 #define IDT_SOCKET 1001
  36
  37 static HWND ioset_window;
  38 static struct io_fd **fds;
  39 static unsigned int fds_used;
  40 static unsigned int fds_size;
  41
  42 static unsigned int
  43 io_fd_pos(int fd)
  44 {
  45     int lower = 0;
  46     int upper = fds_used - 1;
  47
  48     while (lower <= upper)
  49     {
  50         int mid = (upper + lower) / 2;
  51         if (fd < fds[mid]->fd)
  52             upper = mid - 1;
  53         else if (fd > fds[mid]->fd)
  54             lower = mid + 1;
  55         else
  56             break;
  57     }
  58     return lower;
  59 }
  60
  61 static struct io_fd *
  62 io_fd_from_socket(int fd)
  63 {
  64     unsigned int ii;
  65     ii = io_fd_pos(fd);
  66     return ((ii < fds_used) && (fds[ii]->fd == fd)) ? fds[ii] : NULL;
  67 }
  68
  69 static LRESULT CALLBACK
  70 ioset_win32_wndproc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  71 {
  72     struct io_fd *fd;
  73     int events;
  74     int err;
  75
  76     if (hWnd == ioset_window) switch (uMsg)
  77     {
  78     case IDT_TIMER1:
  79         return 0;
  80     case IDT_SOCKET:
  81         fd = io_fd_from_socket(wParam);
  82         events = WSAGETSELECTEVENT(lParam);
  83         err = WSAGETSELECTERROR(lParam);
  84         ioset_events(fd, (events & (FD_READ | FD_ACCEPT | FD_CLOSE)) != 0, (events & (FD_WRITE | FD_CONNECT)) != 0);
  85     }
  86     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  87 }
  88
  89 static int
  90 ioset_win32_init(void)
  91 {
  92     WSADATA wsadata;
  93     WNDCLASSEX wcx;
  94     HINSTANCE hinst;
  95     int res;
  96
  97     // Start Windows Sockets.
  98     res = WSAStartup(MAKEWORD(2, 0), &wsadata);
  99     if (res)
 100     {
 101         log_module(MAIN_LOG, LOG_FATAL, "Unable to start Windows Sockets (%d)", res);
 102     }
 103
 104     // Get Windows HINSTANCE.
 105     hinst = GetModuleHandle(NULL);
 106
 107     // Describe and register a window class.
 108     memset(&wcx, 0, sizeof(wcx));
 109     wcx.cbSize = sizeof(wcx);
 110     wcx.lpfnWndProc = ioset_win32_wndproc;
 111     wcx.hInstance = hinst;
 112     wcx.lpszClassName = "srvxMainWindow";
 113     if (!RegisterClassEx(&wcx))
 114     {
 115         log_module(MAIN_LOG, LOG_FATAL, "Unable to register window class (%lu)", GetLastError());
 116     }
 117
 118     ioset_window = CreateWindow("srvxMainWindow", PACKAGE_STRING, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hinst, NULL);
 119     if (!ioset_window)
 120     {
 121         log_module(MAIN_LOG, LOG_FATAL, "Unable to create window (%lu)", GetLastError());
 122     }
 123
 124     return 0;
 125 }
 126
 127 static long
 128 ioset_win32_events(const struct io_fd *fd)
 129 {
 130     switch (fd->state)
 131     {
 132     case IO_CLOSED:
 133         return 0;
 134     case IO_LISTENING:
 135         return FD_ACCEPT;
 136     case IO_CONNECTING:
 137         return FD_CONNECT;
 138     case IO_CONNECTED:
 139         return FD_READ | FD_CLOSE | (fd_wants_writes(fd) ? FD_WRITE : 0);
 140     }
 141 }
 142
 143 static void
 144 ioset_win32_update(struct io_fd *fd)
 145 {
 146     int rc;
 147     long events;
 148
 149     events = ioset_win32_events(fd);
 150     rc = WSAAsyncSelect(fd->fd, ioset_window, IDT_SOCKET, events);
 151     if (rc)
 152     {
 153         log_module(MAIN_LOG, LOG_ERROR, "Unable to add events %#lx for fd %#x (%d)", events, fd->fd, WSAGetLastError());
 154     }
 155 }
 156
 157 static void
 158 ioset_win32_add(struct io_fd *fd)
 159 {
 160     unsigned int pos;
 161     unsigned int ii;
 162
 163     // Make sure fds[] can hold a new entry.
 164     if (fds_used + 1 >= fds_size)
 165     {
 166         struct io_fd **new_fds;
 167         unsigned int new_size;
 168
 169         new_size = (fds_size < 8) ? 8 : fds_size * 2;
 170         new_fds = calloc(new_size * 2, sizeof(new_fds[0]));
 171         if (!new_fds)
 172         {
 173             log_module(MAIN_LOG, LOG_FATAL, "Unable to allocate %u-entry socket array.", new_size);
 174         }
 175         for (ii = 0; ii < fds_used; ++ii)
 176             new_fds[ii] = fds[ii];
 177         free(fds);
 178         fds = new_fds;
 179         fds_size = new_size;
 180     }
 181
 182     // Insert fd into the appropriate spot in fds[].
 183     pos = io_fd_pos(fd->fd);
 184     for (ii = pos; ii < fds_used; ++ii)
 185         fds[ii + 1] = fds[ii];
 186     fds[pos] = fd;
 187     ++fds_used;
 188
 189     // Ask the OS for future notifications.
 190     ioset_win32_update(fd);
 191 }
 192
 193 static void
 194 ioset_win32_remove(struct io_fd *fd, int os_closed)
 195 {
 196     unsigned int pos;
 197     int rc;
 198
 199     // Unregister from the OS.
 200     if (!os_closed)
 201     {
 202         unsigned long ulong;
 203
 204         rc = WSAAsyncSelect(fd->fd, ioset_window, IDT_SOCKET, 0);
 205         if (rc)
 206         {
 207             log_module(MAIN_LOG, LOG_ERROR, "Unable to remove events for fd %#x (%d)", fd->fd, WSAGetLastError());
 208         }
 209
 210         ulong = 0;
 211         ioctlsocket(fd->fd, FIONBIO, &ulong);
 212     }
 213
 214     // Remove from the fds[] array.
 215     pos = io_fd_pos(fd->fd);
 216     for (--fds_used; pos < fds_used; ++pos)
 217         fds[pos] = fds[pos + 1];
 218 }
 219
 220 static void
 221 ioset_win32_cleanup(void)
 222 {
 223     DestroyWindow(ioset_window);
 224     ioset_window = NULL;
 225     WSACleanup();
 226 }
 227
 228 static int
 229 ioset_win32_loop(struct timeval *timeout)
 230 {
 231     MSG msg;
 232     BOOL not_really_bool;
 233     int msec;
 234
 235     // Make sure we are woken up after the appropriate time.
 236     msec = (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000);
 237     SetTimer(ioset_window, IDT_TIMER1, msec, NULL);
 238     // Do a blocking read of the message queue.
 239     not_really_bool = GetMessage(&msg, NULL, 0, 0);
 240     KillTimer(ioset_window, IDT_TIMER1);
 241     if (not_really_bool < 0)
 242     {
 243         return 1;
 244     }
 245     else if (not_really_bool == 0)
 246     {
 247         quit_services = 1;
 248         return 0;
 249     }
 250     else
 251     {
 252         TranslateMessage(&msg);
 253         DispatchMessage(&msg);
 254     }
 255     return 0;
 256 }
 257
 258 struct io_engine io_engine_win32 = {
 259     .name = "win32",
 260     .init = ioset_win32_init,
 261     .add = ioset_win32_add,
 262     .remove = ioset_win32_remove,
 263     .update = ioset_win32_update,
 264     .loop = ioset_win32_loop,
 265     .cleanup = ioset_win32_cleanup,
 266 };