contrib/hostapd/eloop_win.c

   1 /*
   2  * Event loop based on Windows events and WaitForMultipleObjects
   3  * Copyright (c) 2002-2006, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16 #include <winsock2.h>
  17
  18 #include "common.h"
  19 #include "eloop.h"
  20
  21
  22 struct eloop_sock {
  23         int sock;
  24         void *eloop_data;
  25         void *user_data;
  26         eloop_sock_handler handler;
  27         WSAEVENT event;
  28 };
  29
  30 struct eloop_event {
  31         void *eloop_data;
  32         void *user_data;
  33         eloop_event_handler handler;
  34         HANDLE event;
  35 };
  36
  37 struct eloop_timeout {
  38         struct os_time time;
  39         void *eloop_data;
  40         void *user_data;
  41         eloop_timeout_handler handler;
  42         struct eloop_timeout *next;
  43 };
  44
  45 struct eloop_signal {
  46         int sig;
  47         void *user_data;
  48         eloop_signal_handler handler;
  49         int signaled;
  50 };
  51
  52 struct eloop_data {
  53         void *user_data;
  54
  55         int max_sock;
  56         size_t reader_count;
  57         struct eloop_sock *readers;
  58
  59         size_t event_count;
  60         struct eloop_event *events;
  61
  62         struct eloop_timeout *timeout;
  63
  64         int signal_count;
  65         struct eloop_signal *signals;
  66         int signaled;
  67         int pending_terminate;
  68
  69         int terminate;
  70         int reader_table_changed;
  71
  72         struct eloop_signal term_signal;
  73         HANDLE term_event;
  74
  75         HANDLE *handles;
  76         size_t num_handles;
  77 };
  78
  79 static struct eloop_data eloop;
  80
  81
  82 int eloop_init(void *user_data)
  83 {
  84         os_memset(&eloop, 0, sizeof(eloop));
  85         eloop.user_data = user_data;
  86         eloop.num_handles = 1;
  87         eloop.handles = os_malloc(eloop.num_handles *
  88                                   sizeof(eloop.handles[0]));
  89         if (eloop.handles == NULL)
  90                 return -1;
  91
  92         eloop.term_event = CreateEvent(NULL, FALSE, FALSE, NULL);
  93         if (eloop.term_event == NULL) {
  94                 printf("CreateEvent() failed: %d\n",
  95                        (int) GetLastError());
  96                 os_free(eloop.handles);
  97                 return -1;
  98         }
  99
 100         return 0;
 101 }
 102
 103
 104 static int eloop_prepare_handles(void)
 105 {
 106         HANDLE *n;
 107
 108         if (eloop.num_handles > eloop.reader_count + eloop.event_count + 8)
 109                 return 0;
 110         n = os_realloc(eloop.handles,
 111                        eloop.num_handles * 2 * sizeof(eloop.handles[0]));
 112         if (n == NULL)
 113                 return -1;
 114         eloop.handles = n;
 115         eloop.num_handles *= 2;
 116         return 0;
 117 }
 118
 119
 120 int eloop_register_read_sock(int sock, eloop_sock_handler handler,
 121                              void *eloop_data, void *user_data)
 122 {
 123         WSAEVENT event;
 124         struct eloop_sock *tmp;
 125
 126         if (eloop_prepare_handles())
 127                 return -1;
 128
 129         event = WSACreateEvent();
 130         if (event == WSA_INVALID_EVENT) {
 131                 printf("WSACreateEvent() failed: %d\n", WSAGetLastError());
 132                 return -1;
 133         }
 134
 135         if (WSAEventSelect(sock, event, FD_READ)) {
 136                 printf("WSAEventSelect() failed: %d\n", WSAGetLastError());
 137                 WSACloseEvent(event);
 138                 return -1;
 139         }
 140         tmp = os_realloc(eloop.readers,
 141                          (eloop.reader_count + 1) * sizeof(struct eloop_sock));
 142         if (tmp == NULL) {
 143                 WSAEventSelect(sock, event, 0);
 144                 WSACloseEvent(event);
 145                 return -1;
 146         }
 147
 148         tmp[eloop.reader_count].sock = sock;
 149         tmp[eloop.reader_count].eloop_data = eloop_data;
 150         tmp[eloop.reader_count].user_data = user_data;
 151         tmp[eloop.reader_count].handler = handler;
 152         tmp[eloop.reader_count].event = event;
 153         eloop.reader_count++;
 154         eloop.readers = tmp;
 155         if (sock > eloop.max_sock)
 156                 eloop.max_sock = sock;
 157         eloop.reader_table_changed = 1;
 158
 159         return 0;
 160 }
 161
 162
 163 void eloop_unregister_read_sock(int sock)
 164 {
 165         size_t i;
 166
 167         if (eloop.readers == NULL || eloop.reader_count == 0)
 168                 return;
 169
 170         for (i = 0; i < eloop.reader_count; i++) {
 171                 if (eloop.readers[i].sock == sock)
 172                         break;
 173         }
 174         if (i == eloop.reader_count)
 175                 return;
 176
 177         WSAEventSelect(eloop.readers[i].sock, eloop.readers[i].event, 0);
 178         WSACloseEvent(eloop.readers[i].event);
 179
 180         if (i != eloop.reader_count - 1) {
 181                 os_memmove(&eloop.readers[i], &eloop.readers[i + 1],
 182                            (eloop.reader_count - i - 1) *
 183                            sizeof(struct eloop_sock));
 184         }
 185         eloop.reader_count--;
 186         eloop.reader_table_changed = 1;
 187 }
 188
 189
 190 int eloop_register_event(void *event, size_t event_size,
 191                          eloop_event_handler handler,
 192                          void *eloop_data, void *user_data)
 193 {
 194         struct eloop_event *tmp;
 195         HANDLE h = event;
 196
 197         if (event_size != sizeof(HANDLE) || h == INVALID_HANDLE_VALUE)
 198                 return -1;
 199
 200         if (eloop_prepare_handles())
 201                 return -1;
 202
 203         tmp = os_realloc(eloop.events,
 204                          (eloop.event_count + 1) * sizeof(struct eloop_event));
 205         if (tmp == NULL)
 206                 return -1;
 207
 208         tmp[eloop.event_count].eloop_data = eloop_data;
 209         tmp[eloop.event_count].user_data = user_data;
 210         tmp[eloop.event_count].handler = handler;
 211         tmp[eloop.event_count].event = h;
 212         eloop.event_count++;
 213         eloop.events = tmp;
 214
 215         return 0;
 216 }
 217
 218
 219 void eloop_unregister_event(void *event, size_t event_size)
 220 {
 221         size_t i;
 222         HANDLE h = event;
 223
 224         if (eloop.events == NULL || eloop.event_count == 0 ||
 225             event_size != sizeof(HANDLE))
 226                 return;
 227
 228         for (i = 0; i < eloop.event_count; i++) {
 229                 if (eloop.events[i].event == h)
 230                         break;
 231         }
 232         if (i == eloop.event_count)
 233                 return;
 234
 235         if (i != eloop.event_count - 1) {
 236                 os_memmove(&eloop.events[i], &eloop.events[i + 1],
 237                            (eloop.event_count - i - 1) *
 238                            sizeof(struct eloop_event));
 239         }
 240         eloop.event_count--;
 241 }
 242
 243
 244 int eloop_register_timeout(unsigned int secs, unsigned int usecs,
 245                            eloop_timeout_handler handler,
 246                            void *eloop_data, void *user_data)
 247 {
 248         struct eloop_timeout *timeout, *tmp, *prev;
 249
 250         timeout = os_malloc(sizeof(*timeout));
 251         if (timeout == NULL)
 252                 return -1;
 253         os_get_time(&timeout->time);
 254         timeout->time.sec += secs;
 255         timeout->time.usec += usecs;
 256         while (timeout->time.usec >= 1000000) {
 257                 timeout->time.sec++;
 258                 timeout->time.usec -= 1000000;
 259         }
 260         timeout->eloop_data = eloop_data;
 261         timeout->user_data = user_data;
 262         timeout->handler = handler;
 263         timeout->next = NULL;
 264
 265         if (eloop.timeout == NULL) {
 266                 eloop.timeout = timeout;
 267                 return 0;
 268         }
 269
 270         prev = NULL;
 271         tmp = eloop.timeout;
 272         while (tmp != NULL) {
 273                 if (os_time_before(&timeout->time, &tmp->time))
 274                         break;
 275                 prev = tmp;
 276                 tmp = tmp->next;
 277         }
 278
 279         if (prev == NULL) {
 280                 timeout->next = eloop.timeout;
 281                 eloop.timeout = timeout;
 282         } else {
 283                 timeout->next = prev->next;
 284                 prev->next = timeout;
 285         }
 286
 287         return 0;
 288 }
 289
 290
 291 int eloop_cancel_timeout(eloop_timeout_handler handler,
 292                          void *eloop_data, void *user_data)
 293 {
 294         struct eloop_timeout *timeout, *prev, *next;
 295         int removed = 0;
 296
 297         prev = NULL;
 298         timeout = eloop.timeout;
 299         while (timeout != NULL) {
 300                 next = timeout->next;
 301
 302                 if (timeout->handler == handler &&
 303                     (timeout->eloop_data == eloop_data ||
 304                      eloop_data == ELOOP_ALL_CTX) &&
 305                     (timeout->user_data == user_data ||
 306                      user_data == ELOOP_ALL_CTX)) {
 307                         if (prev == NULL)
 308                                 eloop.timeout = next;
 309                         else
 310                                 prev->next = next;
 311                         os_free(timeout);
 312                         removed++;
 313                 } else
 314                         prev = timeout;
 315
 316                 timeout = next;
 317         }
 318
 319         return removed;
 320 }
 321
 322
 323 /* TODO: replace with suitable signal handler */
 324 #if 0
 325 static void eloop_handle_signal(int sig)
 326 {
 327         int i;
 328
 329         eloop.signaled++;
 330         for (i = 0; i < eloop.signal_count; i++) {
 331                 if (eloop.signals[i].sig == sig) {
 332                         eloop.signals[i].signaled++;
 333                         break;
 334                 }
 335         }
 336 }
 337 #endif
 338
 339
 340 static void eloop_process_pending_signals(void)
 341 {
 342         int i;
 343
 344         if (eloop.signaled == 0)
 345                 return;
 346         eloop.signaled = 0;
 347
 348         if (eloop.pending_terminate) {
 349                 eloop.pending_terminate = 0;
 350         }
 351
 352         for (i = 0; i < eloop.signal_count; i++) {
 353                 if (eloop.signals[i].signaled) {
 354                         eloop.signals[i].signaled = 0;
 355                         eloop.signals[i].handler(eloop.signals[i].sig,
 356                                                  eloop.user_data,
 357                                                  eloop.signals[i].user_data);
 358                 }
 359         }
 360
 361         if (eloop.term_signal.signaled) {
 362                 eloop.term_signal.signaled = 0;
 363                 eloop.term_signal.handler(eloop.term_signal.sig,
 364                                           eloop.user_data,
 365                                           eloop.term_signal.user_data);
 366         }
 367 }
 368
 369
 370 int eloop_register_signal(int sig, eloop_signal_handler handler,
 371                           void *user_data)
 372 {
 373         struct eloop_signal *tmp;
 374
 375         tmp = os_realloc(eloop.signals,
 376                          (eloop.signal_count + 1) *
 377                          sizeof(struct eloop_signal));
 378         if (tmp == NULL)
 379                 return -1;
 380
 381         tmp[eloop.signal_count].sig = sig;
 382         tmp[eloop.signal_count].user_data = user_data;
 383         tmp[eloop.signal_count].handler = handler;
 384         tmp[eloop.signal_count].signaled = 0;
 385         eloop.signal_count++;
 386         eloop.signals = tmp;
 387
 388         /* TODO: register signal handler */
 389
 390         return 0;
 391 }
 392
 393
 394 #ifndef _WIN32_WCE
 395 static BOOL eloop_handle_console_ctrl(DWORD type)
 396 {
 397         switch (type) {
 398         case CTRL_C_EVENT:
 399         case CTRL_BREAK_EVENT:
 400                 eloop.signaled++;
 401                 eloop.term_signal.signaled++;
 402                 SetEvent(eloop.term_event);
 403                 return TRUE;
 404         default:
 405                 return FALSE;
 406         }
 407 }
 408 #endif /* _WIN32_WCE */
 409
 410
 411 int eloop_register_signal_terminate(eloop_signal_handler handler,
 412                                     void *user_data)
 413 {
 414 #ifndef _WIN32_WCE
 415         if (SetConsoleCtrlHandler((PHANDLER_ROUTINE) eloop_handle_console_ctrl,
 416                                   TRUE) == 0) {
 417                 printf("SetConsoleCtrlHandler() failed: %d\n",
 418                        (int) GetLastError());
 419                 return -1;
 420         }
 421 #endif /* _WIN32_WCE */
 422
 423         eloop.term_signal.handler = handler;
 424         eloop.term_signal.user_data = user_data;
 425
 426         return 0;
 427 }
 428
 429
 430 int eloop_register_signal_reconfig(eloop_signal_handler handler,
 431                                    void *user_data)
 432 {
 433         /* TODO */
 434         return 0;
 435 }
 436
 437
 438 void eloop_run(void)
 439 {
 440         struct os_time tv, now;
 441         DWORD count, ret, timeout, err;
 442         size_t i;
 443
 444         while (!eloop.terminate &&
 445                (eloop.timeout || eloop.reader_count > 0 ||
 446                 eloop.event_count > 0)) {
 447                 if (eloop.timeout) {
 448                         os_get_time(&now);
 449                         if (os_time_before(&now, &eloop.timeout->time))
 450                                 os_time_sub(&eloop.timeout->time, &now, &tv);
 451                         else
 452                                 tv.sec = tv.usec = 0;
 453                 }
 454
 455                 count = 0;
 456                 for (i = 0; i < eloop.event_count; i++)
 457                         eloop.handles[count++] = eloop.events[i].event;
 458
 459                 for (i = 0; i < eloop.reader_count; i++)
 460                         eloop.handles[count++] = eloop.readers[i].event;
 461
 462                 if (eloop.term_event)
 463                         eloop.handles[count++] = eloop.term_event;
 464
 465                 if (eloop.timeout)
 466                         timeout = tv.sec * 1000 + tv.usec / 1000;
 467                 else
 468                         timeout = INFINITE;
 469
 470                 if (count > MAXIMUM_WAIT_OBJECTS) {
 471                         printf("WaitForMultipleObjects: Too many events: "
 472                                "%d > %d (ignoring extra events)\n",
 473                                (int) count, MAXIMUM_WAIT_OBJECTS);
 474                         count = MAXIMUM_WAIT_OBJECTS;
 475                 }
 476 #ifdef _WIN32_WCE
 477                 ret = WaitForMultipleObjects(count, eloop.handles, FALSE,
 478                                              timeout);
 479 #else /* _WIN32_WCE */
 480                 ret = WaitForMultipleObjectsEx(count, eloop.handles, FALSE,
 481                                                timeout, TRUE);
 482 #endif /* _WIN32_WCE */
 483                 err = GetLastError();
 484
 485                 eloop_process_pending_signals();
 486
 487                 /* check if some registered timeouts have occurred */
 488                 if (eloop.timeout) {
 489                         struct eloop_timeout *tmp;
 490
 491                         os_get_time(&now);
 492                         if (!os_time_before(&now, &eloop.timeout->time)) {
 493                                 tmp = eloop.timeout;
 494                                 eloop.timeout = eloop.timeout->next;
 495                                 tmp->handler(tmp->eloop_data,
 496                                              tmp->user_data);
 497                                 os_free(tmp);
 498                         }
 499
 500                 }
 501
 502                 if (ret == WAIT_FAILED) {
 503                         printf("WaitForMultipleObjects(count=%d) failed: %d\n",
 504                                (int) count, (int) err);
 505                         os_sleep(1, 0);
 506                         continue;
 507                 }
 508
 509 #ifndef _WIN32_WCE
 510                 if (ret == WAIT_IO_COMPLETION)
 511                         continue;
 512 #endif /* _WIN32_WCE */
 513
 514                 if (ret == WAIT_TIMEOUT)
 515                         continue;
 516
 517                 while (ret >= WAIT_OBJECT_0 &&
 518                        ret < WAIT_OBJECT_0 + eloop.event_count) {
 519                         eloop.events[ret].handler(
 520                                 eloop.events[ret].eloop_data,
 521                                 eloop.events[ret].user_data);
 522                         ret = WaitForMultipleObjects(eloop.event_count,
 523                                                      eloop.handles, FALSE, 0);
 524                 }
 525
 526                 eloop.reader_table_changed = 0;
 527                 for (i = 0; i < eloop.reader_count; i++) {
 528                         WSANETWORKEVENTS events;
 529                         if (WSAEnumNetworkEvents(eloop.readers[i].sock,
 530                                                  eloop.readers[i].event,
 531                                                  &events) == 0 &&
 532                             (events.lNetworkEvents & FD_READ)) {
 533                                 eloop.readers[i].handler(
 534                                         eloop.readers[i].sock,
 535                                         eloop.readers[i].eloop_data,
 536                                         eloop.readers[i].user_data);
 537                                 if (eloop.reader_table_changed)
 538                                         break;
 539                         }
 540                 }
 541         }
 542 }
 543
 544
 545 void eloop_terminate(void)
 546 {
 547         eloop.terminate = 1;
 548         SetEvent(eloop.term_event);
 549 }
 550
 551
 552 void eloop_destroy(void)
 553 {
 554         struct eloop_timeout *timeout, *prev;
 555
 556         timeout = eloop.timeout;
 557         while (timeout != NULL) {
 558                 prev = timeout;
 559                 timeout = timeout->next;
 560                 os_free(prev);
 561         }
 562         os_free(eloop.readers);
 563         os_free(eloop.signals);
 564         if (eloop.term_event)
 565                 CloseHandle(eloop.term_event);
 566         os_free(eloop.handles);
 567         eloop.handles = NULL;
 568         os_free(eloop.events);
 569         eloop.events = NULL;
 570 }
 571
 572
 573 int eloop_terminated(void)
 574 {
 575         return eloop.terminate;
 576 }
 577
 578
 579 void eloop_wait_for_read_sock(int sock)
 580 {
 581         WSAEVENT event;
 582
 583         event = WSACreateEvent();
 584         if (event == WSA_INVALID_EVENT) {
 585                 printf("WSACreateEvent() failed: %d\n", WSAGetLastError());
 586                 return;
 587         }
 588
 589         if (WSAEventSelect(sock, event, FD_READ)) {
 590                 printf("WSAEventSelect() failed: %d\n", WSAGetLastError());
 591                 WSACloseEvent(event);
 592                 return ;
 593         }
 594
 595         WaitForSingleObject(event, INFINITE);
 596         WSAEventSelect(sock, event, 0);
 597         WSACloseEvent(event);
 598 }
 599
 600
 601 void * eloop_get_user_data(void)
 602 {
 603         return eloop.user_data;
 604 }