Annotation of embedaddon/libevent/WIN32-Code/win32.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright 2000-2002 Niels Provos <provos@citi.umich.edu>
! 3: * Copyright 2003 Michael A. Davis <mike@datanerds.net>
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. The name of the author may not be used to endorse or promote products
! 15: * derived from this software without specific prior written permission.
! 16: *
! 17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 18: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 19: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 20: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 21: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 22: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 23: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 24: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 25: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 26: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 27: */
! 28: #ifdef _MSC_VER
! 29: #include "./config.h"
! 30: #else
! 31: /* Avoid the windows/msvc thing. */
! 32: #include "../config.h"
! 33: #endif
! 34:
! 35: #include <winsock2.h>
! 36: #include <windows.h>
! 37: #include <sys/types.h>
! 38: #include <sys/queue.h>
! 39: #include <signal.h>
! 40: #include <stdio.h>
! 41: #include <stdlib.h>
! 42: #include <string.h>
! 43: #include <errno.h>
! 44: #include <assert.h>
! 45:
! 46: #define RB_AUGMENT(x) (void)(x)
! 47: #include "./tree.h"
! 48: #include "log.h"
! 49: #include "event.h"
! 50: #include "event-internal.h"
! 51:
! 52: #define XFREE(ptr) do { if (ptr) free(ptr); } while(0)
! 53:
! 54: extern struct event_list timequeue;
! 55: extern struct event_list addqueue;
! 56: #if 0
! 57: extern struct event_list signalqueue;
! 58: #endif
! 59:
! 60: struct win_fd_set {
! 61: u_int fd_count;
! 62: SOCKET fd_array[1];
! 63: };
! 64:
! 65: int evsigcaught[NSIG];
! 66: volatile sig_atomic_t signal_caught = 0;
! 67: /* MSDN says this is required to handle SIGFPE */
! 68: volatile double SIGFPE_REQ = 0.0f;
! 69:
! 70: #if 0
! 71: static void signal_handler(int sig);
! 72:
! 73: void signal_process(void);
! 74: int signal_recalc(void);
! 75: #endif
! 76:
! 77: struct event_entry {
! 78: RB_ENTRY(event_entry) node;
! 79: SOCKET sock;
! 80: int read_pos;
! 81: int write_pos;
! 82: struct event *read_event;
! 83: struct event *write_event;
! 84: };
! 85:
! 86: static int
! 87: compare(struct event_entry *a, struct event_entry *b)
! 88: {
! 89: if (a->sock < b->sock)
! 90: return -1;
! 91: else if (a->sock > b->sock)
! 92: return 1;
! 93: else
! 94: return 0;
! 95: }
! 96:
! 97: struct win32op {
! 98: int fd_setsz;
! 99: struct win_fd_set *readset_in;
! 100: struct win_fd_set *writeset_in;
! 101: struct win_fd_set *readset_out;
! 102: struct win_fd_set *writeset_out;
! 103: struct win_fd_set *exset_out;
! 104: RB_HEAD(event_map, event_entry) event_root;
! 105:
! 106: unsigned signals_are_broken : 1;
! 107: };
! 108:
! 109: RB_PROTOTYPE(event_map, event_entry, node, compare);
! 110: RB_GENERATE(event_map, event_entry, node, compare);
! 111:
! 112: void *win32_init (struct event_base *);
! 113: int win32_insert (void *, struct event *);
! 114: int win32_del (void *, struct event *);
! 115: int win32_dispatch (struct event_base *base, void *, struct timeval *);
! 116: void win32_dealloc (struct event_base *, void *);
! 117:
! 118: struct eventop win32ops = {
! 119: "win32",
! 120: win32_init,
! 121: win32_insert,
! 122: win32_del,
! 123: win32_dispatch,
! 124: win32_dealloc,
! 125: 0
! 126: };
! 127:
! 128: #define FD_SET_ALLOC_SIZE(n) ((sizeof(struct win_fd_set) + ((n)-1)*sizeof(SOCKET)))
! 129:
! 130: static int
! 131: realloc_fd_sets(struct win32op *op, size_t new_size)
! 132: {
! 133: size_t size;
! 134:
! 135: assert(new_size >= op->readset_in->fd_count &&
! 136: new_size >= op->writeset_in->fd_count);
! 137: assert(new_size >= 1);
! 138:
! 139: size = FD_SET_ALLOC_SIZE(new_size);
! 140: if (!(op->readset_in = realloc(op->readset_in, size)))
! 141: return (-1);
! 142: if (!(op->writeset_in = realloc(op->writeset_in, size)))
! 143: return (-1);
! 144: if (!(op->readset_out = realloc(op->readset_out, size)))
! 145: return (-1);
! 146: if (!(op->exset_out = realloc(op->exset_out, size)))
! 147: return (-1);
! 148: if (!(op->writeset_out = realloc(op->writeset_out, size)))
! 149: return (-1);
! 150: op->fd_setsz = new_size;
! 151: return (0);
! 152: }
! 153:
! 154: static int
! 155: timeval_to_ms(struct timeval *tv)
! 156: {
! 157: return ((tv->tv_sec * 1000) + (tv->tv_usec / 1000));
! 158: }
! 159:
! 160: static struct event_entry*
! 161: get_event_entry(struct win32op *op, SOCKET s, int create)
! 162: {
! 163: struct event_entry key, *val;
! 164: key.sock = s;
! 165: val = RB_FIND(event_map, &op->event_root, &key);
! 166: if (val || !create)
! 167: return val;
! 168: if (!(val = calloc(1, sizeof(struct event_entry)))) {
! 169: event_warn("%s: calloc", __func__);
! 170: return NULL;
! 171: }
! 172: val->sock = s;
! 173: val->read_pos = val->write_pos = -1;
! 174: RB_INSERT(event_map, &op->event_root, val);
! 175: return val;
! 176: }
! 177:
! 178: static int
! 179: do_fd_set(struct win32op *op, struct event_entry *ent, int read)
! 180: {
! 181: SOCKET s = ent->sock;
! 182: struct win_fd_set *set = read ? op->readset_in : op->writeset_in;
! 183: if (read) {
! 184: if (ent->read_pos >= 0)
! 185: return (0);
! 186: } else {
! 187: if (ent->write_pos >= 0)
! 188: return (0);
! 189: }
! 190: if (set->fd_count == op->fd_setsz) {
! 191: if (realloc_fd_sets(op, op->fd_setsz*2))
! 192: return (-1);
! 193: /* set pointer will have changed and needs reiniting! */
! 194: set = read ? op->readset_in : op->writeset_in;
! 195: }
! 196: set->fd_array[set->fd_count] = s;
! 197: if (read)
! 198: ent->read_pos = set->fd_count;
! 199: else
! 200: ent->write_pos = set->fd_count;
! 201: return (set->fd_count++);
! 202: }
! 203:
! 204: static int
! 205: do_fd_clear(struct win32op *op, struct event_entry *ent, int read)
! 206: {
! 207: int i;
! 208: struct win_fd_set *set = read ? op->readset_in : op->writeset_in;
! 209: if (read) {
! 210: i = ent->read_pos;
! 211: ent->read_pos = -1;
! 212: } else {
! 213: i = ent->write_pos;
! 214: ent->write_pos = -1;
! 215: }
! 216: if (i < 0)
! 217: return (0);
! 218: if (--set->fd_count != i) {
! 219: struct event_entry *ent2;
! 220: SOCKET s2;
! 221: s2 = set->fd_array[i] = set->fd_array[set->fd_count];
! 222: ent2 = get_event_entry(op, s2, 0);
! 223: if (!ent) /* This indicates a bug. */
! 224: return (0);
! 225: if (read)
! 226: ent2->read_pos = i;
! 227: else
! 228: ent2->write_pos = i;
! 229: }
! 230: return (0);
! 231: }
! 232:
! 233: #define NEVENT 64
! 234: void *
! 235: win32_init(struct event_base *_base)
! 236: {
! 237: struct win32op *winop;
! 238: size_t size;
! 239: if (!(winop = calloc(1, sizeof(struct win32op))))
! 240: return NULL;
! 241: winop->fd_setsz = NEVENT;
! 242: size = FD_SET_ALLOC_SIZE(NEVENT);
! 243: if (!(winop->readset_in = malloc(size)))
! 244: goto err;
! 245: if (!(winop->writeset_in = malloc(size)))
! 246: goto err;
! 247: if (!(winop->readset_out = malloc(size)))
! 248: goto err;
! 249: if (!(winop->writeset_out = malloc(size)))
! 250: goto err;
! 251: if (!(winop->exset_out = malloc(size)))
! 252: goto err;
! 253: RB_INIT(&winop->event_root);
! 254: winop->readset_in->fd_count = winop->writeset_in->fd_count = 0;
! 255: winop->readset_out->fd_count = winop->writeset_out->fd_count
! 256: = winop->exset_out->fd_count = 0;
! 257:
! 258: if (evsignal_init(_base) < 0)
! 259: winop->signals_are_broken = 1;
! 260:
! 261: return (winop);
! 262: err:
! 263: XFREE(winop->readset_in);
! 264: XFREE(winop->writeset_in);
! 265: XFREE(winop->readset_out);
! 266: XFREE(winop->writeset_out);
! 267: XFREE(winop->exset_out);
! 268: XFREE(winop);
! 269: return (NULL);
! 270: }
! 271:
! 272: int
! 273: win32_insert(void *op, struct event *ev)
! 274: {
! 275: struct win32op *win32op = op;
! 276: struct event_entry *ent;
! 277:
! 278: if (ev->ev_events & EV_SIGNAL) {
! 279: if (win32op->signals_are_broken)
! 280: return (-1);
! 281: return (evsignal_add(ev));
! 282: }
! 283: if (!(ev->ev_events & (EV_READ|EV_WRITE)))
! 284: return (0);
! 285: ent = get_event_entry(win32op, ev->ev_fd, 1);
! 286: if (!ent)
! 287: return (-1); /* out of memory */
! 288:
! 289: event_debug(("%s: adding event for %d", __func__, (int)ev->ev_fd));
! 290: if (ev->ev_events & EV_READ) {
! 291: if (do_fd_set(win32op, ent, 1)<0)
! 292: return (-1);
! 293: ent->read_event = ev;
! 294: }
! 295: if (ev->ev_events & EV_WRITE) {
! 296: if (do_fd_set(win32op, ent, 0)<0)
! 297: return (-1);
! 298: ent->write_event = ev;
! 299: }
! 300: return (0);
! 301: }
! 302:
! 303: int
! 304: win32_del(void *op, struct event *ev)
! 305: {
! 306: struct win32op *win32op = op;
! 307: struct event_entry *ent;
! 308:
! 309: if (ev->ev_events & EV_SIGNAL)
! 310: return (evsignal_del(ev));
! 311:
! 312: if (!(ent = get_event_entry(win32op, ev->ev_fd, 0)))
! 313: return (-1);
! 314: event_debug(("%s: Removing event for %d", __func__, ev->ev_fd));
! 315: if (ev == ent->read_event) {
! 316: do_fd_clear(win32op, ent, 1);
! 317: ent->read_event = NULL;
! 318: }
! 319: if (ev == ent->write_event) {
! 320: do_fd_clear(win32op, ent, 0);
! 321: ent->write_event = NULL;
! 322: }
! 323: if (!ent->read_event && !ent->write_event) {
! 324: RB_REMOVE(event_map, &win32op->event_root, ent);
! 325: free(ent);
! 326: }
! 327:
! 328: return 0;
! 329: }
! 330:
! 331: static void
! 332: fd_set_copy(struct win_fd_set *out, const struct win_fd_set *in)
! 333: {
! 334: out->fd_count = in->fd_count;
! 335: memcpy(out->fd_array, in->fd_array, in->fd_count * (sizeof(SOCKET)));
! 336: }
! 337:
! 338: /*
! 339: static void dump_fd_set(struct win_fd_set *s)
! 340: {
! 341: unsigned int i;
! 342: printf("[ ");
! 343: for(i=0;i<s->fd_count;++i)
! 344: printf("%d ",(int)s->fd_array[i]);
! 345: printf("]\n");
! 346: }
! 347: */
! 348:
! 349: int
! 350: win32_dispatch(struct event_base *base, void *op,
! 351: struct timeval *tv)
! 352: {
! 353: struct win32op *win32op = op;
! 354: int res = 0;
! 355: unsigned j, i;
! 356: int fd_count;
! 357: SOCKET s;
! 358: struct event_entry *ent;
! 359:
! 360: fd_set_copy(win32op->readset_out, win32op->readset_in);
! 361: fd_set_copy(win32op->exset_out, win32op->readset_in);
! 362: fd_set_copy(win32op->writeset_out, win32op->writeset_in);
! 363:
! 364: fd_count =
! 365: (win32op->readset_out->fd_count > win32op->writeset_out->fd_count) ?
! 366: win32op->readset_out->fd_count : win32op->writeset_out->fd_count;
! 367:
! 368: if (!fd_count) {
! 369: /* Windows doesn't like you to call select() with no sockets */
! 370: Sleep(timeval_to_ms(tv));
! 371: evsignal_process(base);
! 372: return (0);
! 373: }
! 374:
! 375: res = select(fd_count,
! 376: (struct fd_set*)win32op->readset_out,
! 377: (struct fd_set*)win32op->writeset_out,
! 378: (struct fd_set*)win32op->exset_out, tv);
! 379:
! 380: event_debug(("%s: select returned %d", __func__, res));
! 381:
! 382: if(res <= 0) {
! 383: evsignal_process(base);
! 384: return res;
! 385: } else if (base->sig.evsignal_caught) {
! 386: evsignal_process(base);
! 387: }
! 388:
! 389: if (win32op->readset_out->fd_count) {
! 390: i = rand() % win32op->readset_out->fd_count;
! 391: for (j=0; j<win32op->readset_out->fd_count; ++j) {
! 392: if (++i >= win32op->readset_out->fd_count)
! 393: i = 0;
! 394: s = win32op->readset_out->fd_array[i];
! 395: if ((ent = get_event_entry(win32op, s, 0)) && ent->read_event)
! 396: event_active(ent->read_event, EV_READ, 1);
! 397: }
! 398: }
! 399: if (win32op->exset_out->fd_count) {
! 400: i = rand() % win32op->exset_out->fd_count;
! 401: for (j=0; j<win32op->exset_out->fd_count; ++j) {
! 402: if (++i >= win32op->exset_out->fd_count)
! 403: i = 0;
! 404: s = win32op->exset_out->fd_array[i];
! 405: if ((ent = get_event_entry(win32op, s, 0)) && ent->read_event)
! 406: event_active(ent->read_event, EV_READ, 1);
! 407: }
! 408: }
! 409: if (win32op->writeset_out->fd_count) {
! 410: i = rand() % win32op->writeset_out->fd_count;
! 411: for (j=0; j<win32op->writeset_out->fd_count; ++j) {
! 412: if (++i >= win32op->exset_out->fd_count)
! 413: i = 0;
! 414: s = win32op->writeset_out->fd_array[i];
! 415: if ((ent = get_event_entry(win32op, s, 0)) && ent->write_event)
! 416: event_active(ent->write_event, EV_WRITE, 1);
! 417:
! 418: }
! 419: }
! 420:
! 421: return (0);
! 422: }
! 423:
! 424: void
! 425: win32_dealloc(struct event_base *_base, void *arg)
! 426: {
! 427: struct win32op *win32op = arg;
! 428:
! 429: evsignal_dealloc(_base);
! 430: if (win32op->readset_in)
! 431: free(win32op->readset_in);
! 432: if (win32op->writeset_in)
! 433: free(win32op->writeset_in);
! 434: if (win32op->readset_out)
! 435: free(win32op->readset_out);
! 436: if (win32op->writeset_out)
! 437: free(win32op->writeset_out);
! 438: if (win32op->exset_out)
! 439: free(win32op->exset_out);
! 440: /* XXXXX free the tree. */
! 441:
! 442: memset(win32op, 0, sizeof(win32op));
! 443: free(win32op);
! 444: }
! 445:
! 446: #if 0
! 447: static void
! 448: signal_handler(int sig)
! 449: {
! 450: evsigcaught[sig]++;
! 451: signal_caught = 1;
! 452: }
! 453:
! 454: int
! 455: signal_recalc(void)
! 456: {
! 457: struct event *ev;
! 458:
! 459: /* Reinstall our signal handler. */
! 460: TAILQ_FOREACH(ev, &signalqueue, ev_signal_next) {
! 461: if((int)signal(EVENT_SIGNAL(ev), signal_handler) == -1)
! 462: return (-1);
! 463: }
! 464: return (0);
! 465: }
! 466:
! 467: void
! 468: signal_process(void)
! 469: {
! 470: struct event *ev;
! 471: short ncalls;
! 472:
! 473: TAILQ_FOREACH(ev, &signalqueue, ev_signal_next) {
! 474: ncalls = evsigcaught[EVENT_SIGNAL(ev)];
! 475: if (ncalls) {
! 476: if (!(ev->ev_events & EV_PERSIST))
! 477: event_del(ev);
! 478: event_active(ev, EV_SIGNAL, ncalls);
! 479: }
! 480: }
! 481:
! 482: memset(evsigcaught, 0, sizeof(evsigcaught));
! 483: signal_caught = 0;
! 484: }
! 485: #endif
! 486:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to win32.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent / WIN32-Code