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         return 0;
  86     case WM_QUIT:
  87         quit_services = wParam;
  88         return 0;
  89     }
  90     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  91 }
  92
  93 static int
  94 ioset_win32_init(void)
  95 {
  96     WSADATA wsadata;
  97     WNDCLASSEX wcx;
  98     HINSTANCE hinst;
  99     int res;
 100
 101     // Start Windows Sockets.
 102     res = WSAStartup(MAKEWORD(2, 0), &wsadata);
 103     if (res)
 104     {
 105         log_module(MAIN_LOG, LOG_FATAL, "Unable to start Windows Sockets (%d)", res);
 106     }
 107
 108     // Get Windows HINSTANCE.
 109     hinst = GetModuleHandle(NULL);
 110
 111     // Describe and register a window class.
 112     memset(&wcx, 0, sizeof(wcx));
 113     wcx.cbSize = sizeof(wcx);
 114     wcx.lpfnWndProc = ioset_win32_wndproc;
 115     wcx.hInstance = hinst;
 116     wcx.lpszClassName = "srvxMainWindow";
 117     if (!RegisterClassEx(&wcx))
 118     {
 119         log_module(MAIN_LOG, LOG_FATAL, "Unable to register window class (%lu)", GetLastError());
 120     }
 121
 122     ioset_window = CreateWindow("srvxMainWindow", PACKAGE_STRING, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hinst, NULL);
 123     if (!ioset_window)
 124     {
 125         log_module(MAIN_LOG, LOG_FATAL, "Unable to create window (%lu)", GetLastError());
 126     }
 127
 128     return 0;
 129 }
 130
 131 static long
 132 ioset_win32_events(const struct io_fd *fd)
 133 {
 134     switch (fd->state)
 135     {
 136     case IO_CLOSED:
 137         return 0;
 138     case IO_LISTENING:
 139         return FD_ACCEPT;
 140     case IO_CONNECTING:
 141         return FD_CONNECT;
 142     case IO_CONNECTED:
 143         return FD_READ | FD_CLOSE | (fd_wants_writes(fd) ? FD_WRITE : 0);
 144     }
 145 }
 146
 147 static void
 148 ioset_win32_update(struct io_fd *fd)
 149 {
 150     int rc;
 151     long events;
 152
 153     events = ioset_win32_events(fd);
 154     rc = WSAAsyncSelect(fd->fd, ioset_window, IDT_SOCKET, events);
 155     if (rc)
 156     {
 157         log_module(MAIN_LOG, LOG_ERROR, "Unable to add events %#lx for fd %#x (%d)", events, fd->fd, WSAGetLastError());
 158     }
 159 }
 160
 161 static void
 162 ioset_win32_add(struct io_fd *fd)
 163 {
 164     unsigned int pos;
 165     unsigned int ii;
 166
 167     // Make sure fds[] can hold a new entry.
 168     if (fds_used + 1 >= fds_size)
 169     {
 170         struct io_fd **new_fds;
 171         unsigned int new_size;
 172
 173         new_size = (fds_size < 8) ? 8 : fds_size * 2;
 174         new_fds = calloc(new_size * 2, sizeof(new_fds[0]));
 175         if (!new_fds)
 176         {
 177             log_module(MAIN_LOG, LOG_FATAL, "Unable to allocate %u-entry socket array.", new_size);
 178         }
 179         for (ii = 0; ii < fds_used; ++ii)
 180             new_fds[ii] = fds[ii];
 181         free(fds);
 182         fds = new_fds;
 183         fds_size = new_size;
 184     }
 185
 186     // Insert fd into the appropriate spot in fds[].
 187     pos = io_fd_pos(fd->fd);
 188     for (ii = pos; ii < fds_used; ++ii)
 189         fds[ii + 1] = fds[ii];
 190     fds[pos] = fd;
 191     ++fds_used;
 192
 193     // Ask the OS for future notifications.
 194     ioset_win32_update(fd);
 195 }
 196
 197 static void
 198 ioset_win32_remove(struct io_fd *fd, int os_closed)
 199 {
 200     unsigned int pos;
 201     int rc;
 202
 203     // Unregister from the OS.
 204     if (!os_closed)
 205     {
 206         unsigned long ulong;
 207
 208         rc = WSAAsyncSelect(fd->fd, ioset_window, IDT_SOCKET, 0);
 209         if (rc)
 210         {
 211             log_module(MAIN_LOG, LOG_ERROR, "Unable to remove events for fd %#x (%d)", fd->fd, WSAGetLastError());
 212         }
 213
 214         ulong = 0;
 215         ioctlsocket(fd->fd, FIONBIO, &ulong);
 216     }
 217
 218     // Remove from the fds[] array.
 219     pos = io_fd_pos(fd->fd);
 220     for (--fds_used; pos < fds_used; ++pos)
 221         fds[pos] = fds[pos + 1];
 222 }
 223
 224 static void
 225 ioset_win32_cleanup(void)
 226 {
 227     DestroyWindow(ioset_window);
 228     ioset_window = NULL;
 229     WSACleanup();
 230 }
 231
 232 static int
 233 ioset_win32_loop(struct timeval *timeout)
 234 {
 235     MSG msg;
 236     BOOL not_really_bool;
 237     int msec;
 238
 239     // Make sure we are woken up after the appropriate time.
 240     msec = (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000);
 241     SetTimer(ioset_window, IDT_TIMER1, msec, NULL);
 242     // Do a blocking read of the message queue.
 243     not_really_bool = GetMessage(&msg, NULL, 0, 0);
 244     KillTimer(ioset_window, IDT_TIMER1);
 245     if (not_really_bool < 0)
 246     {
 247         return 1;
 248     }
 249     else if (not_really_bool == 0)
 250     {
 251         quit_services = 1;
 252         return 0;
 253     }
 254     else
 255     {
 256         TranslateMessage(&msg);
 257         DispatchMessage(&msg);
 258     }
 259     return 0;
 260 }
 261
 262 struct io_engine io_engine_win32 = {
 263     .name = "win32",
 264     .init = ioset_win32_init,
 265     .add = ioset_win32_add,
 266     .remove = ioset_win32_remove,
 267     .update = ioset_win32_update,
 268     .loop = ioset_win32_loop,
 269     .cleanup = ioset_win32_cleanup,
 270 };