2 * Event loop based on Windows events and WaitForMultipleObjects
3 * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
21 eloop_sock_handler handler;
28 eloop_event_handler handler;
32 struct eloop_timeout {
34 struct os_reltime time;
37 eloop_timeout_handler handler;
43 eloop_signal_handler handler;
50 struct eloop_sock *readers;
53 struct eloop_event *events;
55 struct dl_list timeout;
58 struct eloop_signal *signals;
60 int pending_terminate;
63 int reader_table_changed;
65 struct eloop_signal term_signal;
72 static struct eloop_data eloop;
77 os_memset(&eloop, 0, sizeof(eloop));
78 dl_list_init(&eloop.timeout);
79 eloop.num_handles = 1;
80 eloop.handles = os_malloc(eloop.num_handles *
81 sizeof(eloop.handles[0]));
82 if (eloop.handles == NULL)
85 eloop.term_event = CreateEvent(NULL, FALSE, FALSE, NULL);
86 if (eloop.term_event == NULL) {
87 printf("CreateEvent() failed: %d\n",
88 (int) GetLastError());
89 os_free(eloop.handles);
97 static int eloop_prepare_handles(void)
101 if (eloop.num_handles > eloop.reader_count + eloop.event_count + 8)
103 n = os_realloc_array(eloop.handles, eloop.num_handles * 2,
104 sizeof(eloop.handles[0]));
108 eloop.num_handles *= 2;
113 int eloop_register_read_sock(int sock, eloop_sock_handler handler,
114 void *eloop_data, void *user_data)
117 struct eloop_sock *tmp;
119 if (eloop_prepare_handles())
122 event = WSACreateEvent();
123 if (event == WSA_INVALID_EVENT) {
124 printf("WSACreateEvent() failed: %d\n", WSAGetLastError());
128 if (WSAEventSelect(sock, event, FD_READ)) {
129 printf("WSAEventSelect() failed: %d\n", WSAGetLastError());
130 WSACloseEvent(event);
133 tmp = os_realloc_array(eloop.readers, eloop.reader_count + 1,
134 sizeof(struct eloop_sock));
136 WSAEventSelect(sock, event, 0);
137 WSACloseEvent(event);
141 tmp[eloop.reader_count].sock = sock;
142 tmp[eloop.reader_count].eloop_data = eloop_data;
143 tmp[eloop.reader_count].user_data = user_data;
144 tmp[eloop.reader_count].handler = handler;
145 tmp[eloop.reader_count].event = event;
146 eloop.reader_count++;
148 if (sock > eloop.max_sock)
149 eloop.max_sock = sock;
150 eloop.reader_table_changed = 1;
156 void eloop_unregister_read_sock(int sock)
160 if (eloop.readers == NULL || eloop.reader_count == 0)
163 for (i = 0; i < eloop.reader_count; i++) {
164 if (eloop.readers[i].sock == sock)
167 if (i == eloop.reader_count)
170 WSAEventSelect(eloop.readers[i].sock, eloop.readers[i].event, 0);
171 WSACloseEvent(eloop.readers[i].event);
173 if (i != eloop.reader_count - 1) {
174 os_memmove(&eloop.readers[i], &eloop.readers[i + 1],
175 (eloop.reader_count - i - 1) *
176 sizeof(struct eloop_sock));
178 eloop.reader_count--;
179 eloop.reader_table_changed = 1;
183 int eloop_register_event(void *event, size_t event_size,
184 eloop_event_handler handler,
185 void *eloop_data, void *user_data)
187 struct eloop_event *tmp;
190 if (event_size != sizeof(HANDLE) || h == INVALID_HANDLE_VALUE)
193 if (eloop_prepare_handles())
196 tmp = os_realloc_array(eloop.events, eloop.event_count + 1,
197 sizeof(struct eloop_event));
201 tmp[eloop.event_count].eloop_data = eloop_data;
202 tmp[eloop.event_count].user_data = user_data;
203 tmp[eloop.event_count].handler = handler;
204 tmp[eloop.event_count].event = h;
212 void eloop_unregister_event(void *event, size_t event_size)
217 if (eloop.events == NULL || eloop.event_count == 0 ||
218 event_size != sizeof(HANDLE))
221 for (i = 0; i < eloop.event_count; i++) {
222 if (eloop.events[i].event == h)
225 if (i == eloop.event_count)
228 if (i != eloop.event_count - 1) {
229 os_memmove(&eloop.events[i], &eloop.events[i + 1],
230 (eloop.event_count - i - 1) *
231 sizeof(struct eloop_event));
237 int eloop_register_timeout(unsigned int secs, unsigned int usecs,
238 eloop_timeout_handler handler,
239 void *eloop_data, void *user_data)
241 struct eloop_timeout *timeout, *tmp;
244 timeout = os_zalloc(sizeof(*timeout));
247 if (os_get_reltime(&timeout->time) < 0) {
251 now_sec = timeout->time.sec;
252 timeout->time.sec += secs;
253 if (timeout->time.sec < now_sec) {
255 * Integer overflow - assume long enough timeout to be assumed
256 * to be infinite, i.e., the timeout would never happen.
258 wpa_printf(MSG_DEBUG, "ELOOP: Too long timeout (secs=%u) to "
259 "ever happen - ignore it", secs);
263 timeout->time.usec += usecs;
264 while (timeout->time.usec >= 1000000) {
266 timeout->time.usec -= 1000000;
268 timeout->eloop_data = eloop_data;
269 timeout->user_data = user_data;
270 timeout->handler = handler;
272 /* Maintain timeouts in order of increasing time */
273 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
274 if (os_reltime_before(&timeout->time, &tmp->time)) {
275 dl_list_add(tmp->list.prev, &timeout->list);
279 dl_list_add_tail(&eloop.timeout, &timeout->list);
285 static void eloop_remove_timeout(struct eloop_timeout *timeout)
287 dl_list_del(&timeout->list);
292 int eloop_cancel_timeout(eloop_timeout_handler handler,
293 void *eloop_data, void *user_data)
295 struct eloop_timeout *timeout, *prev;
298 dl_list_for_each_safe(timeout, prev, &eloop.timeout,
299 struct eloop_timeout, list) {
300 if (timeout->handler == handler &&
301 (timeout->eloop_data == eloop_data ||
302 eloop_data == ELOOP_ALL_CTX) &&
303 (timeout->user_data == user_data ||
304 user_data == ELOOP_ALL_CTX)) {
305 eloop_remove_timeout(timeout);
314 int eloop_cancel_timeout_one(eloop_timeout_handler handler,
315 void *eloop_data, void *user_data,
316 struct os_reltime *remaining)
318 struct eloop_timeout *timeout, *prev;
320 struct os_reltime now;
322 os_get_reltime(&now);
323 remaining->sec = remaining->usec = 0;
325 dl_list_for_each_safe(timeout, prev, &eloop.timeout,
326 struct eloop_timeout, list) {
327 if (timeout->handler == handler &&
328 (timeout->eloop_data == eloop_data) &&
329 (timeout->user_data == user_data)) {
331 if (os_reltime_before(&now, &timeout->time))
332 os_reltime_sub(&timeout->time, &now, remaining);
333 eloop_remove_timeout(timeout);
341 int eloop_is_timeout_registered(eloop_timeout_handler handler,
342 void *eloop_data, void *user_data)
344 struct eloop_timeout *tmp;
346 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
347 if (tmp->handler == handler &&
348 tmp->eloop_data == eloop_data &&
349 tmp->user_data == user_data)
357 int eloop_deplete_timeout(unsigned int req_secs, unsigned int req_usecs,
358 eloop_timeout_handler handler, void *eloop_data,
361 struct os_reltime now, requested, remaining;
362 struct eloop_timeout *tmp;
364 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
365 if (tmp->handler == handler &&
366 tmp->eloop_data == eloop_data &&
367 tmp->user_data == user_data) {
368 requested.sec = req_secs;
369 requested.usec = req_usecs;
370 os_get_reltime(&now);
371 os_reltime_sub(&tmp->time, &now, &remaining);
372 if (os_reltime_before(&requested, &remaining)) {
373 eloop_cancel_timeout(handler, eloop_data,
375 eloop_register_timeout(requested.sec,
389 int eloop_replenish_timeout(unsigned int req_secs, unsigned int req_usecs,
390 eloop_timeout_handler handler, void *eloop_data,
393 struct os_reltime now, requested, remaining;
394 struct eloop_timeout *tmp;
396 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
397 if (tmp->handler == handler &&
398 tmp->eloop_data == eloop_data &&
399 tmp->user_data == user_data) {
400 requested.sec = req_secs;
401 requested.usec = req_usecs;
402 os_get_reltime(&now);
403 os_reltime_sub(&tmp->time, &now, &remaining);
404 if (os_reltime_before(&remaining, &requested)) {
405 eloop_cancel_timeout(handler, eloop_data,
407 eloop_register_timeout(requested.sec,
421 /* TODO: replace with suitable signal handler */
423 static void eloop_handle_signal(int sig)
428 for (i = 0; i < eloop.signal_count; i++) {
429 if (eloop.signals[i].sig == sig) {
430 eloop.signals[i].signaled++;
438 static void eloop_process_pending_signals(void)
442 if (eloop.signaled == 0)
446 if (eloop.pending_terminate) {
447 eloop.pending_terminate = 0;
450 for (i = 0; i < eloop.signal_count; i++) {
451 if (eloop.signals[i].signaled) {
452 eloop.signals[i].signaled = 0;
453 eloop.signals[i].handler(eloop.signals[i].sig,
454 eloop.signals[i].user_data);
458 if (eloop.term_signal.signaled) {
459 eloop.term_signal.signaled = 0;
460 eloop.term_signal.handler(eloop.term_signal.sig,
461 eloop.term_signal.user_data);
466 int eloop_register_signal(int sig, eloop_signal_handler handler,
469 struct eloop_signal *tmp;
471 tmp = os_realloc_array(eloop.signals, eloop.signal_count + 1,
472 sizeof(struct eloop_signal));
476 tmp[eloop.signal_count].sig = sig;
477 tmp[eloop.signal_count].user_data = user_data;
478 tmp[eloop.signal_count].handler = handler;
479 tmp[eloop.signal_count].signaled = 0;
480 eloop.signal_count++;
483 /* TODO: register signal handler */
490 static BOOL eloop_handle_console_ctrl(DWORD type)
494 case CTRL_BREAK_EVENT:
496 eloop.term_signal.signaled++;
497 SetEvent(eloop.term_event);
503 #endif /* _WIN32_WCE */
506 int eloop_register_signal_terminate(eloop_signal_handler handler,
510 if (SetConsoleCtrlHandler((PHANDLER_ROUTINE) eloop_handle_console_ctrl,
512 printf("SetConsoleCtrlHandler() failed: %d\n",
513 (int) GetLastError());
516 #endif /* _WIN32_WCE */
518 eloop.term_signal.handler = handler;
519 eloop.term_signal.user_data = user_data;
525 int eloop_register_signal_reconfig(eloop_signal_handler handler,
535 struct os_reltime tv, now;
536 DWORD count, ret, timeout_val, err;
539 while (!eloop.terminate &&
540 (!dl_list_empty(&eloop.timeout) || eloop.reader_count > 0 ||
541 eloop.event_count > 0)) {
542 struct eloop_timeout *timeout;
543 tv.sec = tv.usec = 0;
544 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
547 os_get_reltime(&now);
548 if (os_reltime_before(&now, &timeout->time))
549 os_reltime_sub(&timeout->time, &now, &tv);
553 for (i = 0; i < eloop.event_count; i++)
554 eloop.handles[count++] = eloop.events[i].event;
556 for (i = 0; i < eloop.reader_count; i++)
557 eloop.handles[count++] = eloop.readers[i].event;
559 if (eloop.term_event)
560 eloop.handles[count++] = eloop.term_event;
563 timeout_val = tv.sec * 1000 + tv.usec / 1000;
565 timeout_val = INFINITE;
567 if (count > MAXIMUM_WAIT_OBJECTS) {
568 printf("WaitForMultipleObjects: Too many events: "
569 "%d > %d (ignoring extra events)\n",
570 (int) count, MAXIMUM_WAIT_OBJECTS);
571 count = MAXIMUM_WAIT_OBJECTS;
574 ret = WaitForMultipleObjects(count, eloop.handles, FALSE,
576 #else /* _WIN32_WCE */
577 ret = WaitForMultipleObjectsEx(count, eloop.handles, FALSE,
579 #endif /* _WIN32_WCE */
580 err = GetLastError();
582 eloop_process_pending_signals();
584 /* check if some registered timeouts have occurred */
585 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
588 os_get_reltime(&now);
589 if (!os_reltime_before(&now, &timeout->time)) {
590 void *eloop_data = timeout->eloop_data;
591 void *user_data = timeout->user_data;
592 eloop_timeout_handler handler =
594 eloop_remove_timeout(timeout);
595 handler(eloop_data, user_data);
600 if (ret == WAIT_FAILED) {
601 printf("WaitForMultipleObjects(count=%d) failed: %d\n",
602 (int) count, (int) err);
608 if (ret == WAIT_IO_COMPLETION)
610 #endif /* _WIN32_WCE */
612 if (ret == WAIT_TIMEOUT)
615 while (ret >= WAIT_OBJECT_0 &&
616 ret < WAIT_OBJECT_0 + eloop.event_count) {
617 eloop.events[ret].handler(
618 eloop.events[ret].eloop_data,
619 eloop.events[ret].user_data);
620 ret = WaitForMultipleObjects(eloop.event_count,
621 eloop.handles, FALSE, 0);
624 eloop.reader_table_changed = 0;
625 for (i = 0; i < eloop.reader_count; i++) {
626 WSANETWORKEVENTS events;
627 if (WSAEnumNetworkEvents(eloop.readers[i].sock,
628 eloop.readers[i].event,
630 (events.lNetworkEvents & FD_READ)) {
631 eloop.readers[i].handler(
632 eloop.readers[i].sock,
633 eloop.readers[i].eloop_data,
634 eloop.readers[i].user_data);
635 if (eloop.reader_table_changed)
643 void eloop_terminate(void)
646 SetEvent(eloop.term_event);
650 void eloop_destroy(void)
652 struct eloop_timeout *timeout, *prev;
654 dl_list_for_each_safe(timeout, prev, &eloop.timeout,
655 struct eloop_timeout, list) {
656 eloop_remove_timeout(timeout);
658 os_free(eloop.readers);
659 os_free(eloop.signals);
660 if (eloop.term_event)
661 CloseHandle(eloop.term_event);
662 os_free(eloop.handles);
663 eloop.handles = NULL;
664 os_free(eloop.events);
669 int eloop_terminated(void)
671 return eloop.terminate;
675 void eloop_wait_for_read_sock(int sock)
679 event = WSACreateEvent();
680 if (event == WSA_INVALID_EVENT) {
681 printf("WSACreateEvent() failed: %d\n", WSAGetLastError());
685 if (WSAEventSelect(sock, event, FD_READ)) {
686 printf("WSAEventSelect() failed: %d\n", WSAGetLastError());
687 WSACloseEvent(event);
691 WaitForSingleObject(event, INFINITE);
692 WSAEventSelect(sock, event, 0);
693 WSACloseEvent(event);