[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[or-cvs] Make libevent work on win32.

To: or-cvs@xxxxxxxxxxxxx
Subject: [or-cvs] Make libevent work on win32.
From: nickm@xxxxxxxx (Nick Mathewson)
Date: Mon, 21 Feb 2005 23:22:37 -0500 (EST)
Delivered-to: archiver@seul.org
Delivered-to: or-cvs-outgoing@seul.org
Delivered-to: or-cvs@seul.org
Delivery-date: Mon, 21 Feb 2005 23:23:09 -0500
Reply-to: or-dev@xxxxxxxxxxxxx
Sender: owner-or-cvs@xxxxxxxxxxxxx
Update of /home/or/cvsroot/libevent/WIN32-Code
In directory moria.mit.edu:/tmp/cvs-serv20971/WIN32-Code

Modified Files:
	win32.c 
Log Message:
Make libevent work on win32.

Index: win32.c
===================================================================
RCS file: /home/or/cvsroot/libevent/WIN32-Code/win32.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- win32.c	22 Feb 2005 03:43:50 -0000	1.1
+++ win32.c	22 Feb 2005 04:22:34 -0000	1.2
@@ -27,15 +27,19 @@
  */
 #include "config.h"
 
+#include <winsock2.h>
+
 #include <windows.h>
 #include <sys/types.h>
 #include <sys/queue.h>
+#include <sys/tree.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <err.h>
+#include <assert.h>
 
 #ifdef USE_LOG
 #include "log.h"
@@ -45,28 +49,43 @@
 #endif
 
 #include "event.h"
+#include "event-internal.h"
 
 extern struct event_list timequeue;
-extern struct event_list eventqueue;
 extern struct event_list addqueue;
 extern struct event_list signalqueue;
 
-#define NEVENT		64
+struct win_fd_set {
+	u_int fd_count;
+	SOCKET fd_array[1];
+};
 
 int evsigcaught[NSIG];
 volatile sig_atomic_t signal_caught = 0;
 /* MSDN says this is required to handle SIGFPE */
-volatile double SIGFPE_REQ = 0.0f; 
+volatile double SIGFPE_REQ = 0.0f;
 
 int signal_handler(int sig);
 void signal_process(void);
 int signal_recalc(void);
 
+struct win32op {
+	int fd_setsz;
+	struct win_fd_set *readset_in;
+	struct win_fd_set *writeset_in;
+	struct win_fd_set *readset_out;
+	struct win_fd_set *writeset_out;
+	struct win_fd_set *exset_out;
+	int n_events;
+	int n_events_alloc;
+	struct event **events;
+};
+
 void *win32_init	(void);
 int win32_insert	(void *, struct event *);
 int win32_del	(void *, struct event *);
-int win32_recalc	(void *, int);
-int win32_dispatch	(void *, struct timeval *);
+int win32_recalc	(struct event_base *base, void *, int);
+int win32_dispatch	(struct event_base *base, void *, struct timeval *);
 
 struct eventop win32ops = {
 	"win32",
@@ -77,68 +96,256 @@
 	win32_dispatch
 };
 
+#define FD_SET_ALLOC_SIZE(n) ((sizeof(struct win_fd_set) + ((n)-1)*sizeof(SOCKET)))
+
+static int realloc_fd_sets(struct win32op *op, size_t new_size)
+{
+	size_t size;
+
+	assert(new_size >= op->readset_in->fd_count && new_size >= op->writeset_in->fd_count);
+	assert(new_size >= 1);
+
+	size = FD_SET_ALLOC_SIZE(new_size);
+	if (!(op->readset_in = realloc(op->readset_in, size)))
+		return (-1);
+	if (!(op->writeset_in = realloc(op->writeset_in, size)))
+		return (-1);
+	if (!(op->readset_out = realloc(op->readset_out, size)))
+		return (-1);
+	if (!(op->exset_out = realloc(op->exset_out, size)))
+		return (-1);
+	if (!(op->writeset_out = realloc(op->writeset_out, size)))
+		return (-1);
+	op->fd_setsz = new_size;
+	return (0);
+}
+
 static int timeval_to_ms(struct timeval *tv)
 {
 	return ((tv->tv_sec * 1000) + (tv->tv_usec / 1000));
 }
 
+static int do_fd_set(struct win32op *op, SOCKET s, int read)
+{
+	unsigned int i;
+	struct win_fd_set *set = read ? op->readset_in : op->writeset_in;
+	for (i=0;i<set->fd_count;++i) {
+		if (set->fd_array[i]==s)
+			return (0);
+	}
+	if (set->fd_count == op->fd_setsz) {
+		if (realloc_fd_sets(op, op->fd_setsz*2))
+			return (-1);
+	}
+	set->fd_array[set->fd_count] = s;
+	return (set->fd_count++);
+}
+
+static int do_fd_clear(struct win32op *op, SOCKET s, int read)
+{
+	unsigned int i;
+	struct win_fd_set *set = read ? op->readset_in : op->writeset_in;
+	for (i=0;i<set->fd_count;++i) {
+		if (set->fd_array[i]==s) {
+			if (--set->fd_count != i) {
+				set->fd_array[i] = set->fd_array[set->fd_count];
+			}
+			return (0);
+		}
+	}
+	return (0);
+}
+
+#define NEVENT 64
 void *
 win32_init(void)
 {
-	return (&win32ops);
+	struct win32op *winop;
+	size_t size;
+	if (!(winop = calloc(1, sizeof(struct win32op))))
+		return NULL;
+	winop->fd_setsz = NEVENT;
+	size = FD_SET_ALLOC_SIZE(NEVENT);
+	winop->readset_in = malloc(size); // XXXX check
+	winop->writeset_in = malloc(size); // XXXX check;
+	winop->readset_out = malloc(size);
+	winop->writeset_out = malloc(size);
+	winop->exset_out = malloc(size);
+	winop->n_events = 0;
+	winop->n_events_alloc = NEVENT;
+	winop->events = malloc(NEVENT*sizeof(struct event*));
+	winop->readset_in->fd_count = winop->writeset_in->fd_count = 0;
+	winop->readset_out->fd_count = winop->writeset_out->fd_count
+		= winop->exset_out->fd_count = 0;
+
+	return (winop);
 }
 
 int
-win32_recalc(void *arg, int max)
+win32_recalc(struct event_base *base, void *arg, int max)
 {
 	return (signal_recalc());
 }
 
 int
-win32_insert(struct win32op *wop, struct event *ev)
+win32_insert(struct win32op *win32op, struct event *ev)
 {
+	int i;
+
 	if (ev->ev_events & EV_SIGNAL) {
 		if (ev->ev_events & (EV_READ|EV_WRITE))
 			errx(1, "%s: EV_SIGNAL incompatible use",
-			    __func__);
+			     __func__);
 		if((int)signal(EVENT_SIGNAL(ev), signal_handler) == -1)
 			return (-1);
 
 		return (0);
 	}
+	if (!(ev->ev_events & (EV_READ|EV_WRITE)))
+		return (0);
+
+
+	for (i=0;i<win32op->n_events;++i) {
+		if(win32op->events[i] == ev) {
+			/* printf("Found event for %d\n", ev->ev_fd); */
+			return (0);
+		}
+	}
+	/* printf("Add %d for %d (%p)\n", ev->ev_fd, ev->ev_events, ev); */
+	if (ev->ev_events & EV_READ) {
+		do_fd_set(win32op, ev->ev_fd, 1);
+	}
+	if (ev->ev_events & EV_WRITE) {
+		do_fd_set(win32op, ev->ev_fd, 0);
+	}
+
+	if (win32op->n_events_alloc == win32op->n_events) {
+		win32op->n_events_alloc *= 2;
+		win32op->events = realloc(win32op->events, sizeof(struct event)*win32op->n_events_alloc);
+	}
+	win32op->events[win32op->n_events++] = ev;
 
 	return (0);
 }
 
 int
-win32_dispatch(void *arg, struct timeval *tv)
+win32_del(struct win32op *win32op, struct event *ev)
+{
+	int i, found;
+
+	if (ev->ev_events & EV_SIGNAL)
+		return ((int)signal(EVENT_SIGNAL(ev), SIG_IGN));
+
+	/* printf("Remove %d for %d (%p)\n...", ev->ev_fd, ev->ev_events, ev); */
+
+	found = -1;
+	for (i=0;i<win32op->n_events;++i) {
+		if(win32op->events[i] == ev) {
+			found = i;
+			break;
+		}
+	}
+	if (found < 0)
+		return (-1);
+	if (ev->ev_events & EV_READ)
+		do_fd_clear(win32op, ev->ev_fd, 1);
+	if (ev->ev_events & EV_WRITE)
+		do_fd_clear(win32op, ev->ev_fd, 0);
+
+	if (i != --win32op->n_events) {
+		win32op->events[i] = win32op->events[win32op->n_events];
+	}
+
+	return 0;
+}
+
+static void fd_set_copy(struct win_fd_set *out, const struct win_fd_set *in)
+{
+	out->fd_count = in->fd_count;
+	memcpy(out->fd_array, in->fd_array, in->fd_count * (sizeof(SOCKET)));
+}
+
+/*
+static void dump_fd_set(struct win_fd_set *s)
+{
+	unsigned int i;
+	printf("[ ");
+	for(i=0;i<s->fd_count;++i)
+		printf("%d ",(int)s->fd_array[i]);
+	printf("]\n");
+}
+*/
+
+int
+win32_dispatch(struct event_base *base, struct win32op *win32op, struct timeval *tv)
 {
 	int res = 0;
-	struct win32op *wop = arg;
-	struct event *ev;
-	int evres;
+	int i;
+	int fd_count;
 
-	TAILQ_FOREACH(ev, &eventqueue, ev_next) {
-		res = WaitForSingleObject(ev->ev_fd, timeval_to_ms(tv));
+	/* printf("Waiting...\n"); */
 
-		if(res == WAIT_TIMEOUT || res == WAIT_FAILED) {
-			signal_process();
-			return (0);
-		} else if (signal_caught)
-			signal_process();
+	fd_set_copy(win32op->readset_out, win32op->readset_in);
+	fd_set_copy(win32op->exset_out, win32op->readset_in);
+	fd_set_copy(win32op->writeset_out, win32op->writeset_in);
+	/* 
+	dump_fd_set(win32op->writeset_in);
+	printf("On readlist:");
+	dump_fd_set(win32op->readset_out);
+	printf("On writelist:");
+	dump_fd_set(win32op->writeset_out);
+	printf("On exlist:");
+	dump_fd_set(win32op->exset_out);
+	*/
 
-		evres = 0;
-		if(ev->ev_events & EV_READ)
-			evres |= EV_READ;
+	fd_count = (win32op->readset_out->fd_count > win32op->writeset_out->fd_count) ?
+		win32op->readset_out->fd_count : win32op->writeset_out->fd_count;
 
-		if(ev->ev_events & EV_WRITE)
-			evres |= EV_WRITE;
-		if(evres) {
-			if(!(ev->ev_events & EV_PERSIST))
-				event_del(ev);
-			event_active(ev, evres, 1);
+	res = select(fd_count,
+		     (struct fd_set*)win32op->readset_out,
+		     (struct fd_set*)win32op->writeset_out,
+		     (struct fd_set*)win32op->exset_out, tv);
+
+	/* printf("Wait said %d\n",res); */
+
+	if(res <= 0) {
+		signal_process();
+		return res;
+	}
+
+	/*
+	printf("On readlist:");
+	dump_fd_set(win32op->readset_out);
+	printf("On writelist:");
+	dump_fd_set(win32op->writeset_out);
+	printf("On exlist:");
+	dump_fd_set(win32op->exset_out);
+	*/
+
+	for (i=0;i<win32op->n_events;++i) {
+		struct event *ev;
+		int got = 0;
+		ev = win32op->events[i];
+		if ((ev->ev_events & EV_READ)) {
+			if (FD_ISSET(ev->ev_fd, win32op->readset_out) ||
+			    FD_ISSET(ev->ev_fd, win32op->exset_out)) {
+				got |= EV_READ;
+			}
 		}
+		if ((ev->ev_events & EV_WRITE)) {
+			if (FD_ISSET(ev->ev_fd, win32op->writeset_out)) {
+				got |= EV_WRITE;
+			}
+		}
+		if (!got)
+			continue;
+		/* printf("I will call something now.\n"); */
+		if (!(ev->ev_events & EV_PERSIST)) {
+			event_del(ev);
+		}
+		event_active(ev,got,1);
 	}
+	/* printf("Done with loop.\n"); */
 
 	if (signal_recalc() == -1)
 		return (-1);
@@ -146,11 +353,6 @@
 	return (0);
 }
 
-int
-win32_del(struct win32op *arg, struct event *ev)
-{
-	return ((int)signal(EVENT_SIGNAL(ev), SIG_IGN));
-}
 
 static int signal_handler(int sig)
 {
Prev by Author: [or-cvs] Make libevent work on win32.
Next by Author: [or-cvs] Initial IRIX compatibility fixes: check for inttypes.h; che...
Previous by thread: [or-cvs] Make libevent work on win32.
Next by thread: [or-cvs] Initial IRIX compatibility fixes: check for inttypes.h; che...
Index(es):
- Author
- Thread