contrib/wpa/src/utils/eloop.c

   1 /*
   2  * Event loop based on select() loop
   3  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10 #include <assert.h>
  11
  12 #include "common.h"
  13 #include "trace.h"
  14 #include "list.h"
  15 #include "eloop.h"
  16
  17 #if defined(CONFIG_ELOOP_POLL) && defined(CONFIG_ELOOP_EPOLL)
  18 #error Do not define both of poll and epoll
  19 #endif
  20
  21 #if defined(CONFIG_ELOOP_POLL) && defined(CONFIG_ELOOP_KQUEUE)
  22 #error Do not define both of poll and kqueue
  23 #endif
  24
  25 #if !defined(CONFIG_ELOOP_POLL) && !defined(CONFIG_ELOOP_EPOLL) && \
  26     !defined(CONFIG_ELOOP_KQUEUE)
  27 #define CONFIG_ELOOP_SELECT
  28 #endif
  29
  30 #ifdef CONFIG_ELOOP_POLL
  31 #include <poll.h>
  32 #endif /* CONFIG_ELOOP_POLL */
  33
  34 #ifdef CONFIG_ELOOP_EPOLL
  35 #include <sys/epoll.h>
  36 #endif /* CONFIG_ELOOP_EPOLL */
  37
  38 #ifdef CONFIG_ELOOP_KQUEUE
  39 #include <sys/event.h>
  40 #endif /* CONFIG_ELOOP_KQUEUE */
  41
  42 struct eloop_sock {
  43         int sock;
  44         void *eloop_data;
  45         void *user_data;
  46         eloop_sock_handler handler;
  47         WPA_TRACE_REF(eloop);
  48         WPA_TRACE_REF(user);
  49         WPA_TRACE_INFO
  50 };
  51
  52 struct eloop_timeout {
  53         struct dl_list list;
  54         struct os_reltime time;
  55         void *eloop_data;
  56         void *user_data;
  57         eloop_timeout_handler handler;
  58         WPA_TRACE_REF(eloop);
  59         WPA_TRACE_REF(user);
  60         WPA_TRACE_INFO
  61 };
  62
  63 struct eloop_signal {
  64         int sig;
  65         void *user_data;
  66         eloop_signal_handler handler;
  67         int signaled;
  68 };
  69
  70 struct eloop_sock_table {
  71         int count;
  72         struct eloop_sock *table;
  73         eloop_event_type type;
  74         int changed;
  75 };
  76
  77 struct eloop_data {
  78         int max_sock;
  79
  80         int count; /* sum of all table counts */
  81 #ifdef CONFIG_ELOOP_POLL
  82         int max_pollfd_map; /* number of pollfds_map currently allocated */
  83         int max_poll_fds; /* number of pollfds currently allocated */
  84         struct pollfd *pollfds;
  85         struct pollfd **pollfds_map;
  86 #endif /* CONFIG_ELOOP_POLL */
  87 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE)
  88         int max_fd;
  89         struct eloop_sock *fd_table;
  90 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */
  91 #ifdef CONFIG_ELOOP_EPOLL
  92         int epollfd;
  93         int epoll_max_event_num;
  94         struct epoll_event *epoll_events;
  95 #endif /* CONFIG_ELOOP_EPOLL */
  96 #ifdef CONFIG_ELOOP_KQUEUE
  97         int kqueuefd;
  98         int kqueue_nevents;
  99         struct kevent *kqueue_events;
 100 #endif /* CONFIG_ELOOP_KQUEUE */
 101         struct eloop_sock_table readers;
 102         struct eloop_sock_table writers;
 103         struct eloop_sock_table exceptions;
 104
 105         struct dl_list timeout;
 106
 107         int signal_count;
 108         struct eloop_signal *signals;
 109         int signaled;
 110         int pending_terminate;
 111
 112         int terminate;
 113 };
 114
 115 static struct eloop_data eloop;
 116
 117
 118 #ifdef WPA_TRACE
 119
 120 static void eloop_sigsegv_handler(int sig)
 121 {
 122         wpa_trace_show("eloop SIGSEGV");
 123         abort();
 124 }
 125
 126 static void eloop_trace_sock_add_ref(struct eloop_sock_table *table)
 127 {
 128         int i;
 129         if (table == NULL || table->table == NULL)
 130                 return;
 131         for (i = 0; i < table->count; i++) {
 132                 wpa_trace_add_ref(&table->table[i], eloop,
 133                                   table->table[i].eloop_data);
 134                 wpa_trace_add_ref(&table->table[i], user,
 135                                   table->table[i].user_data);
 136         }
 137 }
 138
 139
 140 static void eloop_trace_sock_remove_ref(struct eloop_sock_table *table)
 141 {
 142         int i;
 143         if (table == NULL || table->table == NULL)
 144                 return;
 145         for (i = 0; i < table->count; i++) {
 146                 wpa_trace_remove_ref(&table->table[i], eloop,
 147                                      table->table[i].eloop_data);
 148                 wpa_trace_remove_ref(&table->table[i], user,
 149                                      table->table[i].user_data);
 150         }
 151 }
 152
 153 #else /* WPA_TRACE */
 154
 155 #define eloop_trace_sock_add_ref(table) do { } while (0)
 156 #define eloop_trace_sock_remove_ref(table) do { } while (0)
 157
 158 #endif /* WPA_TRACE */
 159
 160
 161 int eloop_init(void)
 162 {
 163         os_memset(&eloop, 0, sizeof(eloop));
 164         dl_list_init(&eloop.timeout);
 165 #ifdef CONFIG_ELOOP_EPOLL
 166         eloop.epollfd = epoll_create1(0);
 167         if (eloop.epollfd < 0) {
 168                 wpa_printf(MSG_ERROR, "%s: epoll_create1 failed. %s",
 169                            __func__, strerror(errno));
 170                 return -1;
 171         }
 172 #endif /* CONFIG_ELOOP_EPOLL */
 173 #ifdef CONFIG_ELOOP_KQUEUE
 174         eloop.kqueuefd = kqueue();
 175         if (eloop.kqueuefd < 0) {
 176                 wpa_printf(MSG_ERROR, "%s: kqueue failed: %s",
 177                            __func__, strerror(errno));
 178                 return -1;
 179         }
 180 #endif /* CONFIG_ELOOP_KQUEUE */
 181 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE)
 182         eloop.readers.type = EVENT_TYPE_READ;
 183         eloop.writers.type = EVENT_TYPE_WRITE;
 184         eloop.exceptions.type = EVENT_TYPE_EXCEPTION;
 185 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */
 186 #ifdef WPA_TRACE
 187         signal(SIGSEGV, eloop_sigsegv_handler);
 188 #endif /* WPA_TRACE */
 189         return 0;
 190 }
 191
 192
 193 #ifdef CONFIG_ELOOP_EPOLL
 194 static int eloop_sock_queue(int sock, eloop_event_type type)
 195 {
 196         struct epoll_event ev;
 197
 198         os_memset(&ev, 0, sizeof(ev));
 199         switch (type) {
 200         case EVENT_TYPE_READ:
 201                 ev.events = EPOLLIN;
 202                 break;
 203         case EVENT_TYPE_WRITE:
 204                 ev.events = EPOLLOUT;
 205                 break;
 206         /*
 207          * Exceptions are always checked when using epoll, but I suppose it's
 208          * possible that someone registered a socket *only* for exception
 209          * handling.
 210          */
 211         case EVENT_TYPE_EXCEPTION:
 212                 ev.events = EPOLLERR | EPOLLHUP;
 213                 break;
 214         }
 215         ev.data.fd = sock;
 216         if (epoll_ctl(eloop.epollfd, EPOLL_CTL_ADD, sock, &ev) < 0) {
 217                 wpa_printf(MSG_ERROR, "%s: epoll_ctl(ADD) for fd=%d failed: %s",
 218                            __func__, sock, strerror(errno));
 219                 return -1;
 220         }
 221         return 0;
 222 }
 223 #endif /* CONFIG_ELOOP_EPOLL */
 224
 225
 226 #ifdef CONFIG_ELOOP_KQUEUE
 227
 228 static short event_type_kevent_filter(eloop_event_type type)
 229 {
 230         switch (type) {
 231         case EVENT_TYPE_READ:
 232                 return EVFILT_READ;
 233         case EVENT_TYPE_WRITE:
 234                 return EVFILT_WRITE;
 235         default:
 236                 return 0;
 237         }
 238 }
 239
 240
 241 static int eloop_sock_queue(int sock, eloop_event_type type)
 242 {
 243         struct kevent ke;
 244
 245         EV_SET(&ke, sock, event_type_kevent_filter(type), EV_ADD, 0, 0, 0);
 246         if (kevent(eloop.kqueuefd, &ke, 1, NULL, 0, NULL) == -1) {
 247                 wpa_printf(MSG_ERROR, "%s: kevent(ADD) for fd=%d failed: %s",
 248                            __func__, sock, strerror(errno));
 249                 return -1;
 250         }
 251         return 0;
 252 }
 253
 254 #endif /* CONFIG_ELOOP_KQUEUE */
 255
 256
 257 static int eloop_sock_table_add_sock(struct eloop_sock_table *table,
 258                                      int sock, eloop_sock_handler handler,
 259                                      void *eloop_data, void *user_data)
 260 {
 261 #ifdef CONFIG_ELOOP_EPOLL
 262         struct epoll_event *temp_events;
 263 #endif /* CONFIG_ELOOP_EPOLL */
 264 #ifdef CONFIG_ELOOP_KQUEUE
 265         struct kevent *temp_events;
 266 #endif /* CONFIG_ELOOP_EPOLL */
 267 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE)
 268         struct eloop_sock *temp_table;
 269         int next;
 270 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */
 271         struct eloop_sock *tmp;
 272         int new_max_sock;
 273
 274         if (sock > eloop.max_sock)
 275                 new_max_sock = sock;
 276         else
 277                 new_max_sock = eloop.max_sock;
 278
 279         if (table == NULL)
 280                 return -1;
 281
 282 #ifdef CONFIG_ELOOP_POLL
 283         if (new_max_sock >= eloop.max_pollfd_map) {
 284                 struct pollfd **nmap;
 285                 nmap = os_realloc_array(eloop.pollfds_map, new_max_sock + 50,
 286                                         sizeof(struct pollfd *));
 287                 if (nmap == NULL)
 288                         return -1;
 289
 290                 eloop.max_pollfd_map = new_max_sock + 50;
 291                 eloop.pollfds_map = nmap;
 292         }
 293
 294         if (eloop.count + 1 > eloop.max_poll_fds) {
 295                 struct pollfd *n;
 296                 int nmax = eloop.count + 1 + 50;
 297                 n = os_realloc_array(eloop.pollfds, nmax,
 298                                      sizeof(struct pollfd));
 299                 if (n == NULL)
 300                         return -1;
 301
 302                 eloop.max_poll_fds = nmax;
 303                 eloop.pollfds = n;
 304         }
 305 #endif /* CONFIG_ELOOP_POLL */
 306 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE)
 307         if (new_max_sock >= eloop.max_fd) {
 308                 next = new_max_sock + 16;
 309                 temp_table = os_realloc_array(eloop.fd_table, next,
 310                                               sizeof(struct eloop_sock));
 311                 if (temp_table == NULL)
 312                         return -1;
 313
 314                 eloop.max_fd = next;
 315                 eloop.fd_table = temp_table;
 316         }
 317 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */
 318
 319 #ifdef CONFIG_ELOOP_EPOLL
 320         if (eloop.count + 1 > eloop.epoll_max_event_num) {
 321                 next = eloop.epoll_max_event_num == 0 ? 8 :
 322                         eloop.epoll_max_event_num * 2;
 323                 temp_events = os_realloc_array(eloop.epoll_events, next,
 324                                                sizeof(struct epoll_event));
 325                 if (temp_events == NULL) {
 326                         wpa_printf(MSG_ERROR, "%s: malloc for epoll failed: %s",
 327                                    __func__, strerror(errno));
 328                         return -1;
 329                 }
 330
 331                 eloop.epoll_max_event_num = next;
 332                 eloop.epoll_events = temp_events;
 333         }
 334 #endif /* CONFIG_ELOOP_EPOLL */
 335 #ifdef CONFIG_ELOOP_KQUEUE
 336         if (eloop.count + 1 > eloop.kqueue_nevents) {
 337                 next = eloop.kqueue_nevents == 0 ? 8 : eloop.kqueue_nevents * 2;
 338                 temp_events = os_malloc(next * sizeof(*temp_events));
 339                 if (!temp_events) {
 340                         wpa_printf(MSG_ERROR,
 341                                    "%s: malloc for kqueue failed: %s",
 342                                    __func__, strerror(errno));
 343                         return -1;
 344                 }
 345
 346                 os_free(eloop.kqueue_events);
 347                 eloop.kqueue_events = temp_events;
 348                 eloop.kqueue_nevents = next;
 349         }
 350 #endif /* CONFIG_ELOOP_KQUEUE */
 351
 352         eloop_trace_sock_remove_ref(table);
 353         tmp = os_realloc_array(table->table, table->count + 1,
 354                                sizeof(struct eloop_sock));
 355         if (tmp == NULL) {
 356                 eloop_trace_sock_add_ref(table);
 357                 return -1;
 358         }
 359
 360         tmp[table->count].sock = sock;
 361         tmp[table->count].eloop_data = eloop_data;
 362         tmp[table->count].user_data = user_data;
 363         tmp[table->count].handler = handler;
 364         wpa_trace_record(&tmp[table->count]);
 365         table->count++;
 366         table->table = tmp;
 367         eloop.max_sock = new_max_sock;
 368         eloop.count++;
 369         table->changed = 1;
 370         eloop_trace_sock_add_ref(table);
 371
 372 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE)
 373         if (eloop_sock_queue(sock, table->type) < 0)
 374                 return -1;
 375         os_memcpy(&eloop.fd_table[sock], &table->table[table->count - 1],
 376                   sizeof(struct eloop_sock));
 377 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */
 378         return 0;
 379 }
 380
 381
 382 static void eloop_sock_table_remove_sock(struct eloop_sock_table *table,
 383                                          int sock)
 384 {
 385 #ifdef CONFIG_ELOOP_KQUEUE
 386         struct kevent ke;
 387 #endif /* CONFIG_ELOOP_KQUEUE */
 388         int i;
 389
 390         if (table == NULL || table->table == NULL || table->count == 0)
 391                 return;
 392
 393         for (i = 0; i < table->count; i++) {
 394                 if (table->table[i].sock == sock)
 395                         break;
 396         }
 397         if (i == table->count)
 398                 return;
 399         eloop_trace_sock_remove_ref(table);
 400         if (i != table->count - 1) {
 401                 os_memmove(&table->table[i], &table->table[i + 1],
 402                            (table->count - i - 1) *
 403                            sizeof(struct eloop_sock));
 404         }
 405         table->count--;
 406         eloop.count--;
 407         table->changed = 1;
 408         eloop_trace_sock_add_ref(table);
 409 #ifdef CONFIG_ELOOP_EPOLL
 410         if (epoll_ctl(eloop.epollfd, EPOLL_CTL_DEL, sock, NULL) < 0) {
 411                 wpa_printf(MSG_ERROR, "%s: epoll_ctl(DEL) for fd=%d failed: %s",
 412                            __func__, sock, strerror(errno));
 413                 return;
 414         }
 415         os_memset(&eloop.fd_table[sock], 0, sizeof(struct eloop_sock));
 416 #endif /* CONFIG_ELOOP_EPOLL */
 417 #ifdef CONFIG_ELOOP_KQUEUE
 418         EV_SET(&ke, sock, event_type_kevent_filter(table->type), EV_DELETE, 0,
 419                0, 0);
 420         if (kevent(eloop.kqueuefd, &ke, 1, NULL, 0, NULL) < 0) {
 421                 wpa_printf(MSG_ERROR, "%s: kevent(DEL) for fd=%d failed: %s",
 422                            __func__, sock, strerror(errno));
 423                 return;
 424         }
 425         os_memset(&eloop.fd_table[sock], 0, sizeof(struct eloop_sock));
 426 #endif /* CONFIG_ELOOP_KQUEUE */
 427 }
 428
 429
 430 #ifdef CONFIG_ELOOP_POLL
 431
 432 static struct pollfd * find_pollfd(struct pollfd **pollfds_map, int fd, int mx)
 433 {
 434         if (fd < mx && fd >= 0)
 435                 return pollfds_map[fd];
 436         return NULL;
 437 }
 438
 439
 440 static int eloop_sock_table_set_fds(struct eloop_sock_table *readers,
 441                                     struct eloop_sock_table *writers,
 442                                     struct eloop_sock_table *exceptions,
 443                                     struct pollfd *pollfds,
 444                                     struct pollfd **pollfds_map,
 445                                     int max_pollfd_map)
 446 {
 447         int i;
 448         int nxt = 0;
 449         int fd;
 450         struct pollfd *pfd;
 451
 452         /* Clear pollfd lookup map. It will be re-populated below. */
 453         os_memset(pollfds_map, 0, sizeof(struct pollfd *) * max_pollfd_map);
 454
 455         if (readers && readers->table) {
 456                 for (i = 0; i < readers->count; i++) {
 457                         fd = readers->table[i].sock;
 458                         assert(fd >= 0 && fd < max_pollfd_map);
 459                         pollfds[nxt].fd = fd;
 460                         pollfds[nxt].events = POLLIN;
 461                         pollfds[nxt].revents = 0;
 462                         pollfds_map[fd] = &(pollfds[nxt]);
 463                         nxt++;
 464                 }
 465         }
 466
 467         if (writers && writers->table) {
 468                 for (i = 0; i < writers->count; i++) {
 469                         /*
 470                          * See if we already added this descriptor, update it
 471                          * if so.
 472                          */
 473                         fd = writers->table[i].sock;
 474                         assert(fd >= 0 && fd < max_pollfd_map);
 475                         pfd = pollfds_map[fd];
 476                         if (!pfd) {
 477                                 pfd = &(pollfds[nxt]);
 478                                 pfd->events = 0;
 479                                 pfd->fd = fd;
 480                                 pollfds[i].revents = 0;
 481                                 pollfds_map[fd] = pfd;
 482                                 nxt++;
 483                         }
 484                         pfd->events |= POLLOUT;
 485                 }
 486         }
 487
 488         /*
 489          * Exceptions are always checked when using poll, but I suppose it's
 490          * possible that someone registered a socket *only* for exception
 491          * handling. Set the POLLIN bit in this case.
 492          */
 493         if (exceptions && exceptions->table) {
 494                 for (i = 0; i < exceptions->count; i++) {
 495                         /*
 496                          * See if we already added this descriptor, just use it
 497                          * if so.
 498                          */
 499                         fd = exceptions->table[i].sock;
 500                         assert(fd >= 0 && fd < max_pollfd_map);
 501                         pfd = pollfds_map[fd];
 502                         if (!pfd) {
 503                                 pfd = &(pollfds[nxt]);
 504                                 pfd->events = POLLIN;
 505                                 pfd->fd = fd;
 506                                 pollfds[i].revents = 0;
 507                                 pollfds_map[fd] = pfd;
 508                                 nxt++;
 509                         }
 510                 }
 511         }
 512
 513         return nxt;
 514 }
 515
 516
 517 static int eloop_sock_table_dispatch_table(struct eloop_sock_table *table,
 518                                            struct pollfd **pollfds_map,
 519                                            int max_pollfd_map,
 520                                            short int revents)
 521 {
 522         int i;
 523         struct pollfd *pfd;
 524
 525         if (!table || !table->table)
 526                 return 0;
 527
 528         table->changed = 0;
 529         for (i = 0; i < table->count; i++) {
 530                 pfd = find_pollfd(pollfds_map, table->table[i].sock,
 531                                   max_pollfd_map);
 532                 if (!pfd)
 533                         continue;
 534
 535                 if (!(pfd->revents & revents))
 536                         continue;
 537
 538                 table->table[i].handler(table->table[i].sock,
 539                                         table->table[i].eloop_data,
 540                                         table->table[i].user_data);
 541                 if (table->changed)
 542                         return 1;
 543         }
 544
 545         return 0;
 546 }
 547
 548
 549 static void eloop_sock_table_dispatch(struct eloop_sock_table *readers,
 550                                       struct eloop_sock_table *writers,
 551                                       struct eloop_sock_table *exceptions,
 552                                       struct pollfd **pollfds_map,
 553                                       int max_pollfd_map)
 554 {
 555         if (eloop_sock_table_dispatch_table(readers, pollfds_map,
 556                                             max_pollfd_map, POLLIN | POLLERR |
 557                                             POLLHUP))
 558                 return; /* pollfds may be invalid at this point */
 559
 560         if (eloop_sock_table_dispatch_table(writers, pollfds_map,
 561                                             max_pollfd_map, POLLOUT))
 562                 return; /* pollfds may be invalid at this point */
 563
 564         eloop_sock_table_dispatch_table(exceptions, pollfds_map,
 565                                         max_pollfd_map, POLLERR | POLLHUP);
 566 }
 567
 568 #endif /* CONFIG_ELOOP_POLL */
 569
 570 #ifdef CONFIG_ELOOP_SELECT
 571
 572 static void eloop_sock_table_set_fds(struct eloop_sock_table *table,
 573                                      fd_set *fds)
 574 {
 575         int i;
 576
 577         FD_ZERO(fds);
 578
 579         if (table->table == NULL)
 580                 return;
 581
 582         for (i = 0; i < table->count; i++) {
 583                 assert(table->table[i].sock >= 0);
 584                 FD_SET(table->table[i].sock, fds);
 585         }
 586 }
 587
 588
 589 static void eloop_sock_table_dispatch(struct eloop_sock_table *table,
 590                                       fd_set *fds)
 591 {
 592         int i;
 593
 594         if (table == NULL || table->table == NULL)
 595                 return;
 596
 597         table->changed = 0;
 598         for (i = 0; i < table->count; i++) {
 599                 if (FD_ISSET(table->table[i].sock, fds)) {
 600                         table->table[i].handler(table->table[i].sock,
 601                                                 table->table[i].eloop_data,
 602                                                 table->table[i].user_data);
 603                         if (table->changed)
 604                                 break;
 605                 }
 606         }
 607 }
 608
 609 #endif /* CONFIG_ELOOP_SELECT */
 610
 611
 612 #ifdef CONFIG_ELOOP_EPOLL
 613 static void eloop_sock_table_dispatch(struct epoll_event *events, int nfds)
 614 {
 615         struct eloop_sock *table;
 616         int i;
 617
 618         for (i = 0; i < nfds; i++) {
 619                 table = &eloop.fd_table[events[i].data.fd];
 620                 if (table->handler == NULL)
 621                         continue;
 622                 table->handler(table->sock, table->eloop_data,
 623                                table->user_data);
 624                 if (eloop.readers.changed ||
 625                     eloop.writers.changed ||
 626                     eloop.exceptions.changed)
 627                         break;
 628         }
 629 }
 630 #endif /* CONFIG_ELOOP_EPOLL */
 631
 632
 633 #ifdef CONFIG_ELOOP_KQUEUE
 634
 635 static void eloop_sock_table_dispatch(struct kevent *events, int nfds)
 636 {
 637         struct eloop_sock *table;
 638         int i;
 639
 640         for (i = 0; i < nfds; i++) {
 641                 table = &eloop.fd_table[events[i].ident];
 642                 if (table->handler == NULL)
 643                         continue;
 644                 table->handler(table->sock, table->eloop_data,
 645                                table->user_data);
 646                 if (eloop.readers.changed ||
 647                     eloop.writers.changed ||
 648                     eloop.exceptions.changed)
 649                         break;
 650         }
 651 }
 652
 653
 654 static int eloop_sock_table_requeue(struct eloop_sock_table *table)
 655 {
 656         int i, r;
 657
 658         r = 0;
 659         for (i = 0; i < table->count && table->table; i++) {
 660                 if (eloop_sock_queue(table->table[i].sock, table->type) == -1)
 661                         r = -1;
 662         }
 663         return r;
 664 }
 665
 666 #endif /* CONFIG_ELOOP_KQUEUE */
 667
 668
 669 int eloop_sock_requeue(void)
 670 {
 671         int r = 0;
 672
 673 #ifdef CONFIG_ELOOP_KQUEUE
 674         close(eloop.kqueuefd);
 675         eloop.kqueuefd = kqueue();
 676         if (eloop.kqueuefd < 0) {
 677                 wpa_printf(MSG_ERROR, "%s: kqueue failed: %s",
 678                            __func__, strerror(errno));
 679                 return -1;
 680         }
 681
 682         if (eloop_sock_table_requeue(&eloop.readers) < 0)
 683                 r = -1;
 684         if (eloop_sock_table_requeue(&eloop.writers) < 0)
 685                 r = -1;
 686         if (eloop_sock_table_requeue(&eloop.exceptions) < 0)
 687                 r = -1;
 688 #endif /* CONFIG_ELOOP_KQUEUE */
 689
 690         return r;
 691 }
 692
 693
 694 static void eloop_sock_table_destroy(struct eloop_sock_table *table)
 695 {
 696         if (table) {
 697                 int i;
 698                 for (i = 0; i < table->count && table->table; i++) {
 699                         wpa_printf(MSG_INFO, "ELOOP: remaining socket: "
 700                                    "sock=%d eloop_data=%p user_data=%p "
 701                                    "handler=%p",
 702                                    table->table[i].sock,
 703                                    table->table[i].eloop_data,
 704                                    table->table[i].user_data,
 705                                    table->table[i].handler);
 706                         wpa_trace_dump_funcname("eloop unregistered socket "
 707                                                 "handler",
 708                                                 table->table[i].handler);
 709                         wpa_trace_dump("eloop sock", &table->table[i]);
 710                 }
 711                 os_free(table->table);
 712         }
 713 }
 714
 715
 716 int eloop_register_read_sock(int sock, eloop_sock_handler handler,
 717                              void *eloop_data, void *user_data)
 718 {
 719         return eloop_register_sock(sock, EVENT_TYPE_READ, handler,
 720                                    eloop_data, user_data);
 721 }
 722
 723
 724 void eloop_unregister_read_sock(int sock)
 725 {
 726         eloop_unregister_sock(sock, EVENT_TYPE_READ);
 727 }
 728
 729
 730 static struct eloop_sock_table *eloop_get_sock_table(eloop_event_type type)
 731 {
 732         switch (type) {
 733         case EVENT_TYPE_READ:
 734                 return &eloop.readers;
 735         case EVENT_TYPE_WRITE:
 736                 return &eloop.writers;
 737         case EVENT_TYPE_EXCEPTION:
 738                 return &eloop.exceptions;
 739         }
 740
 741         return NULL;
 742 }
 743
 744
 745 int eloop_register_sock(int sock, eloop_event_type type,
 746                         eloop_sock_handler handler,
 747                         void *eloop_data, void *user_data)
 748 {
 749         struct eloop_sock_table *table;
 750
 751         assert(sock >= 0);
 752         table = eloop_get_sock_table(type);
 753         return eloop_sock_table_add_sock(table, sock, handler,
 754                                          eloop_data, user_data);
 755 }
 756
 757
 758 void eloop_unregister_sock(int sock, eloop_event_type type)
 759 {
 760         struct eloop_sock_table *table;
 761
 762         table = eloop_get_sock_table(type);
 763         eloop_sock_table_remove_sock(table, sock);
 764 }
 765
 766
 767 int eloop_register_timeout(unsigned int secs, unsigned int usecs,
 768                            eloop_timeout_handler handler,
 769                            void *eloop_data, void *user_data)
 770 {
 771         struct eloop_timeout *timeout, *tmp;
 772         os_time_t now_sec;
 773
 774         timeout = os_zalloc(sizeof(*timeout));
 775         if (timeout == NULL)
 776                 return -1;
 777         if (os_get_reltime(&timeout->time) < 0) {
 778                 os_free(timeout);
 779                 return -1;
 780         }
 781         now_sec = timeout->time.sec;
 782         timeout->time.sec += secs;
 783         if (timeout->time.sec < now_sec) {
 784                 /*
 785                  * Integer overflow - assume long enough timeout to be assumed
 786                  * to be infinite, i.e., the timeout would never happen.
 787                  */
 788                 wpa_printf(MSG_DEBUG, "ELOOP: Too long timeout (secs=%u) to "
 789                            "ever happen - ignore it", secs);
 790                 os_free(timeout);
 791                 return 0;
 792         }
 793         timeout->time.usec += usecs;
 794         while (timeout->time.usec >= 1000000) {
 795                 timeout->time.sec++;
 796                 timeout->time.usec -= 1000000;
 797         }
 798         timeout->eloop_data = eloop_data;
 799         timeout->user_data = user_data;
 800         timeout->handler = handler;
 801         wpa_trace_add_ref(timeout, eloop, eloop_data);
 802         wpa_trace_add_ref(timeout, user, user_data);
 803         wpa_trace_record(timeout);
 804
 805         /* Maintain timeouts in order of increasing time */
 806         dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
 807                 if (os_reltime_before(&timeout->time, &tmp->time)) {
 808                         dl_list_add(tmp->list.prev, &timeout->list);
 809                         return 0;
 810                 }
 811         }
 812         dl_list_add_tail(&eloop.timeout, &timeout->list);
 813
 814         return 0;
 815 }
 816
 817
 818 static void eloop_remove_timeout(struct eloop_timeout *timeout)
 819 {
 820         dl_list_del(&timeout->list);
 821         wpa_trace_remove_ref(timeout, eloop, timeout->eloop_data);
 822         wpa_trace_remove_ref(timeout, user, timeout->user_data);
 823         os_free(timeout);
 824 }
 825
 826
 827 int eloop_cancel_timeout(eloop_timeout_handler handler,
 828                          void *eloop_data, void *user_data)
 829 {
 830         struct eloop_timeout *timeout, *prev;
 831         int removed = 0;
 832
 833         dl_list_for_each_safe(timeout, prev, &eloop.timeout,
 834                               struct eloop_timeout, list) {
 835                 if (timeout->handler == handler &&
 836                     (timeout->eloop_data == eloop_data ||
 837                      eloop_data == ELOOP_ALL_CTX) &&
 838                     (timeout->user_data == user_data ||
 839                      user_data == ELOOP_ALL_CTX)) {
 840                         eloop_remove_timeout(timeout);
 841                         removed++;
 842                 }
 843         }
 844
 845         return removed;
 846 }
 847
 848
 849 int eloop_cancel_timeout_one(eloop_timeout_handler handler,
 850                              void *eloop_data, void *user_data,
 851                              struct os_reltime *remaining)
 852 {
 853         struct eloop_timeout *timeout, *prev;
 854         int removed = 0;
 855         struct os_reltime now;
 856
 857         os_get_reltime(&now);
 858         remaining->sec = remaining->usec = 0;
 859
 860         dl_list_for_each_safe(timeout, prev, &eloop.timeout,
 861                               struct eloop_timeout, list) {
 862                 if (timeout->handler == handler &&
 863                     (timeout->eloop_data == eloop_data) &&
 864                     (timeout->user_data == user_data)) {
 865                         removed = 1;
 866                         if (os_reltime_before(&now, &timeout->time))
 867                                 os_reltime_sub(&timeout->time, &now, remaining);
 868                         eloop_remove_timeout(timeout);
 869                         break;
 870                 }
 871         }
 872         return removed;
 873 }
 874
 875
 876 int eloop_is_timeout_registered(eloop_timeout_handler handler,
 877                                 void *eloop_data, void *user_data)
 878 {
 879         struct eloop_timeout *tmp;
 880
 881         dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
 882                 if (tmp->handler == handler &&
 883                     tmp->eloop_data == eloop_data &&
 884                     tmp->user_data == user_data)
 885                         return 1;
 886         }
 887
 888         return 0;
 889 }
 890
 891
 892 int eloop_deplete_timeout(unsigned int req_secs, unsigned int req_usecs,
 893                           eloop_timeout_handler handler, void *eloop_data,
 894                           void *user_data)
 895 {
 896         struct os_reltime now, requested, remaining;
 897         struct eloop_timeout *tmp;
 898
 899         dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
 900                 if (tmp->handler == handler &&
 901                     tmp->eloop_data == eloop_data &&
 902                     tmp->user_data == user_data) {
 903                         requested.sec = req_secs;
 904                         requested.usec = req_usecs;
 905                         os_get_reltime(&now);
 906                         os_reltime_sub(&tmp->time, &now, &remaining);
 907                         if (os_reltime_before(&requested, &remaining)) {
 908                                 eloop_cancel_timeout(handler, eloop_data,
 909                                                      user_data);
 910                                 eloop_register_timeout(requested.sec,
 911                                                        requested.usec,
 912                                                        handler, eloop_data,
 913                                                        user_data);
 914                                 return 1;
 915                         }
 916                         return 0;
 917                 }
 918         }
 919
 920         return -1;
 921 }
 922
 923
 924 int eloop_replenish_timeout(unsigned int req_secs, unsigned int req_usecs,
 925                             eloop_timeout_handler handler, void *eloop_data,
 926                             void *user_data)
 927 {
 928         struct os_reltime now, requested, remaining;
 929         struct eloop_timeout *tmp;
 930
 931         dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
 932                 if (tmp->handler == handler &&
 933                     tmp->eloop_data == eloop_data &&
 934                     tmp->user_data == user_data) {
 935                         requested.sec = req_secs;
 936                         requested.usec = req_usecs;
 937                         os_get_reltime(&now);
 938                         os_reltime_sub(&tmp->time, &now, &remaining);
 939                         if (os_reltime_before(&remaining, &requested)) {
 940                                 eloop_cancel_timeout(handler, eloop_data,
 941                                                      user_data);
 942                                 eloop_register_timeout(requested.sec,
 943                                                        requested.usec,
 944                                                        handler, eloop_data,
 945                                                        user_data);
 946                                 return 1;
 947                         }
 948                         return 0;
 949                 }
 950         }
 951
 952         return -1;
 953 }
 954
 955
 956 #ifndef CONFIG_NATIVE_WINDOWS
 957 static void eloop_handle_alarm(int sig)
 958 {
 959         wpa_printf(MSG_ERROR, "eloop: could not process SIGINT or SIGTERM in "
 960                    "two seconds. Looks like there\n"
 961                    "is a bug that ends up in a busy loop that "
 962                    "prevents clean shutdown.\n"
 963                    "Killing program forcefully.\n");
 964         exit(1);
 965 }
 966 #endif /* CONFIG_NATIVE_WINDOWS */
 967
 968
 969 static void eloop_handle_signal(int sig)
 970 {
 971         int i;
 972
 973 #ifndef CONFIG_NATIVE_WINDOWS
 974         if ((sig == SIGINT || sig == SIGTERM) && !eloop.pending_terminate) {
 975                 /* Use SIGALRM to break out from potential busy loops that
 976                  * would not allow the program to be killed. */
 977                 eloop.pending_terminate = 1;
 978                 signal(SIGALRM, eloop_handle_alarm);
 979                 alarm(2);
 980         }
 981 #endif /* CONFIG_NATIVE_WINDOWS */
 982
 983         eloop.signaled++;
 984         for (i = 0; i < eloop.signal_count; i++) {
 985                 if (eloop.signals[i].sig == sig) {
 986                         eloop.signals[i].signaled++;
 987                         break;
 988                 }
 989         }
 990 }
 991
 992
 993 static void eloop_process_pending_signals(void)
 994 {
 995         int i;
 996
 997         if (eloop.signaled == 0)
 998                 return;
 999         eloop.signaled = 0;
1000
1001         if (eloop.pending_terminate) {
1002 #ifndef CONFIG_NATIVE_WINDOWS
1003                 alarm(0);
1004 #endif /* CONFIG_NATIVE_WINDOWS */
1005                 eloop.pending_terminate = 0;
1006         }
1007
1008         for (i = 0; i < eloop.signal_count; i++) {
1009                 if (eloop.signals[i].signaled) {
1010                         eloop.signals[i].signaled = 0;
1011                         eloop.signals[i].handler(eloop.signals[i].sig,
1012                                                  eloop.signals[i].user_data);
1013                 }
1014         }
1015 }
1016
1017
1018 int eloop_register_signal(int sig, eloop_signal_handler handler,
1019                           void *user_data)
1020 {
1021         struct eloop_signal *tmp;
1022
1023         tmp = os_realloc_array(eloop.signals, eloop.signal_count + 1,
1024                                sizeof(struct eloop_signal));
1025         if (tmp == NULL)
1026                 return -1;
1027
1028         tmp[eloop.signal_count].sig = sig;
1029         tmp[eloop.signal_count].user_data = user_data;
1030         tmp[eloop.signal_count].handler = handler;
1031         tmp[eloop.signal_count].signaled = 0;
1032         eloop.signal_count++;
1033         eloop.signals = tmp;
1034         signal(sig, eloop_handle_signal);
1035
1036         return 0;
1037 }
1038
1039
1040 int eloop_register_signal_terminate(eloop_signal_handler handler,
1041                                     void *user_data)
1042 {
1043         int ret = eloop_register_signal(SIGINT, handler, user_data);
1044         if (ret == 0)
1045                 ret = eloop_register_signal(SIGTERM, handler, user_data);
1046         return ret;
1047 }
1048
1049
1050 int eloop_register_signal_reconfig(eloop_signal_handler handler,
1051                                    void *user_data)
1052 {
1053 #ifdef CONFIG_NATIVE_WINDOWS
1054         return 0;
1055 #else /* CONFIG_NATIVE_WINDOWS */
1056         return eloop_register_signal(SIGHUP, handler, user_data);
1057 #endif /* CONFIG_NATIVE_WINDOWS */
1058 }
1059
1060
1061 void eloop_run(void)
1062 {
1063 #ifdef CONFIG_ELOOP_POLL
1064         int num_poll_fds;
1065         int timeout_ms = 0;
1066 #endif /* CONFIG_ELOOP_POLL */
1067 #ifdef CONFIG_ELOOP_SELECT
1068         fd_set *rfds, *wfds, *efds;
1069         struct timeval _tv;
1070 #endif /* CONFIG_ELOOP_SELECT */
1071 #ifdef CONFIG_ELOOP_EPOLL
1072         int timeout_ms = -1;
1073 #endif /* CONFIG_ELOOP_EPOLL */
1074 #ifdef CONFIG_ELOOP_KQUEUE
1075         struct timespec ts;
1076 #endif /* CONFIG_ELOOP_KQUEUE */
1077         int res;
1078         struct os_reltime tv, now;
1079
1080 #ifdef CONFIG_ELOOP_SELECT
1081         rfds = os_malloc(sizeof(*rfds));
1082         wfds = os_malloc(sizeof(*wfds));
1083         efds = os_malloc(sizeof(*efds));
1084         if (rfds == NULL || wfds == NULL || efds == NULL)
1085                 goto out;
1086 #endif /* CONFIG_ELOOP_SELECT */
1087
1088         while (!eloop.terminate &&
1089                (!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 ||
1090                 eloop.writers.count > 0 || eloop.exceptions.count > 0)) {
1091                 struct eloop_timeout *timeout;
1092
1093                 if (eloop.pending_terminate) {
1094                         /*
1095                          * This may happen in some corner cases where a signal
1096                          * is received during a blocking operation. We need to
1097                          * process the pending signals and exit if requested to
1098                          * avoid hitting the SIGALRM limit if the blocking
1099                          * operation took more than two seconds.
1100                          */
1101                         eloop_process_pending_signals();
1102                         if (eloop.terminate)
1103                                 break;
1104                 }
1105
1106                 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
1107                                         list);
1108                 if (timeout) {
1109                         os_get_reltime(&now);
1110                         if (os_reltime_before(&now, &timeout->time))
1111                                 os_reltime_sub(&timeout->time, &now, &tv);
1112                         else
1113                                 tv.sec = tv.usec = 0;
1114 #if defined(CONFIG_ELOOP_POLL) || defined(CONFIG_ELOOP_EPOLL)
1115                         timeout_ms = tv.sec * 1000 + tv.usec / 1000;
1116 #endif /* defined(CONFIG_ELOOP_POLL) || defined(CONFIG_ELOOP_EPOLL) */
1117 #ifdef CONFIG_ELOOP_SELECT
1118                         _tv.tv_sec = tv.sec;
1119                         _tv.tv_usec = tv.usec;
1120 #endif /* CONFIG_ELOOP_SELECT */
1121 #ifdef CONFIG_ELOOP_KQUEUE
1122                         ts.tv_sec = tv.sec;
1123                         ts.tv_nsec = tv.usec * 1000L;
1124 #endif /* CONFIG_ELOOP_KQUEUE */
1125                 }
1126
1127 #ifdef CONFIG_ELOOP_POLL
1128                 num_poll_fds = eloop_sock_table_set_fds(
1129                         &eloop.readers, &eloop.writers, &eloop.exceptions,
1130                         eloop.pollfds, eloop.pollfds_map,
1131                         eloop.max_pollfd_map);
1132                 res = poll(eloop.pollfds, num_poll_fds,
1133                            timeout ? timeout_ms : -1);
1134 #endif /* CONFIG_ELOOP_POLL */
1135 #ifdef CONFIG_ELOOP_SELECT
1136                 eloop_sock_table_set_fds(&eloop.readers, rfds);
1137                 eloop_sock_table_set_fds(&eloop.writers, wfds);
1138                 eloop_sock_table_set_fds(&eloop.exceptions, efds);
1139                 res = select(eloop.max_sock + 1, rfds, wfds, efds,
1140                              timeout ? &_tv : NULL);
1141 #endif /* CONFIG_ELOOP_SELECT */
1142 #ifdef CONFIG_ELOOP_EPOLL
1143                 if (eloop.count == 0) {
1144                         res = 0;
1145                 } else {
1146                         res = epoll_wait(eloop.epollfd, eloop.epoll_events,
1147                                          eloop.count, timeout_ms);
1148                 }
1149 #endif /* CONFIG_ELOOP_EPOLL */
1150 #ifdef CONFIG_ELOOP_KQUEUE
1151                 if (eloop.count == 0) {
1152                         res = 0;
1153                 } else {
1154                         res = kevent(eloop.kqueuefd, NULL, 0,
1155                                      eloop.kqueue_events, eloop.kqueue_nevents,
1156                                      timeout ? &ts : NULL);
1157                 }
1158 #endif /* CONFIG_ELOOP_KQUEUE */
1159                 if (res < 0 && errno != EINTR && errno != 0) {
1160                         wpa_printf(MSG_ERROR, "eloop: %s: %s",
1161 #ifdef CONFIG_ELOOP_POLL
1162                                    "poll"
1163 #endif /* CONFIG_ELOOP_POLL */
1164 #ifdef CONFIG_ELOOP_SELECT
1165                                    "select"
1166 #endif /* CONFIG_ELOOP_SELECT */
1167 #ifdef CONFIG_ELOOP_EPOLL
1168                                    "epoll"
1169 #endif /* CONFIG_ELOOP_EPOLL */
1170 #ifdef CONFIG_ELOOP_KQUEUE
1171                                    "kqueue"
1172 #endif /* CONFIG_ELOOP_EKQUEUE */
1173
1174                                    , strerror(errno));
1175                         goto out;
1176                 }
1177
1178                 eloop.readers.changed = 0;
1179                 eloop.writers.changed = 0;
1180                 eloop.exceptions.changed = 0;
1181
1182                 eloop_process_pending_signals();
1183
1184
1185                 /* check if some registered timeouts have occurred */
1186                 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
1187                                         list);
1188                 if (timeout) {
1189                         os_get_reltime(&now);
1190                         if (!os_reltime_before(&now, &timeout->time)) {
1191                                 void *eloop_data = timeout->eloop_data;
1192                                 void *user_data = timeout->user_data;
1193                                 eloop_timeout_handler handler =
1194                                         timeout->handler;
1195                                 eloop_remove_timeout(timeout);
1196                                 handler(eloop_data, user_data);
1197                         }
1198
1199                 }
1200
1201                 if (res <= 0)
1202                         continue;
1203
1204                 if (eloop.readers.changed ||
1205                     eloop.writers.changed ||
1206                     eloop.exceptions.changed) {
1207                          /*
1208                           * Sockets may have been closed and reopened with the
1209                           * same FD in the signal or timeout handlers, so we
1210                           * must skip the previous results and check again
1211                           * whether any of the currently registered sockets have
1212                           * events.
1213                           */
1214                         continue;
1215                 }
1216
1217 #ifdef CONFIG_ELOOP_POLL
1218                 eloop_sock_table_dispatch(&eloop.readers, &eloop.writers,
1219                                           &eloop.exceptions, eloop.pollfds_map,
1220                                           eloop.max_pollfd_map);
1221 #endif /* CONFIG_ELOOP_POLL */
1222 #ifdef CONFIG_ELOOP_SELECT
1223                 eloop_sock_table_dispatch(&eloop.readers, rfds);
1224                 eloop_sock_table_dispatch(&eloop.writers, wfds);
1225                 eloop_sock_table_dispatch(&eloop.exceptions, efds);
1226 #endif /* CONFIG_ELOOP_SELECT */
1227 #ifdef CONFIG_ELOOP_EPOLL
1228                 eloop_sock_table_dispatch(eloop.epoll_events, res);
1229 #endif /* CONFIG_ELOOP_EPOLL */
1230 #ifdef CONFIG_ELOOP_KQUEUE
1231                 eloop_sock_table_dispatch(eloop.kqueue_events, res);
1232 #endif /* CONFIG_ELOOP_KQUEUE */
1233         }
1234
1235         eloop.terminate = 0;
1236 out:
1237 #ifdef CONFIG_ELOOP_SELECT
1238         os_free(rfds);
1239         os_free(wfds);
1240         os_free(efds);
1241 #endif /* CONFIG_ELOOP_SELECT */
1242         return;
1243 }
1244
1245
1246 void eloop_terminate(void)
1247 {
1248         eloop.terminate = 1;
1249 }
1250
1251
1252 void eloop_destroy(void)
1253 {
1254         struct eloop_timeout *timeout, *prev;
1255         struct os_reltime now;
1256
1257         os_get_reltime(&now);
1258         dl_list_for_each_safe(timeout, prev, &eloop.timeout,
1259                               struct eloop_timeout, list) {
1260                 int sec, usec;
1261                 sec = timeout->time.sec - now.sec;
1262                 usec = timeout->time.usec - now.usec;
1263                 if (timeout->time.usec < now.usec) {
1264                         sec--;
1265                         usec += 1000000;
1266                 }
1267                 wpa_printf(MSG_INFO, "ELOOP: remaining timeout: %d.%06d "
1268                            "eloop_data=%p user_data=%p handler=%p",
1269                            sec, usec, timeout->eloop_data, timeout->user_data,
1270                            timeout->handler);
1271                 wpa_trace_dump_funcname("eloop unregistered timeout handler",
1272                                         timeout->handler);
1273                 wpa_trace_dump("eloop timeout", timeout);
1274                 eloop_remove_timeout(timeout);
1275         }
1276         eloop_sock_table_destroy(&eloop.readers);
1277         eloop_sock_table_destroy(&eloop.writers);
1278         eloop_sock_table_destroy(&eloop.exceptions);
1279         os_free(eloop.signals);
1280
1281 #ifdef CONFIG_ELOOP_POLL
1282         os_free(eloop.pollfds);
1283         os_free(eloop.pollfds_map);
1284 #endif /* CONFIG_ELOOP_POLL */
1285 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE)
1286         os_free(eloop.fd_table);
1287 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */
1288 #ifdef CONFIG_ELOOP_EPOLL
1289         os_free(eloop.epoll_events);
1290         close(eloop.epollfd);
1291 #endif /* CONFIG_ELOOP_EPOLL */
1292 #ifdef CONFIG_ELOOP_KQUEUE
1293         os_free(eloop.kqueue_events);
1294         close(eloop.kqueuefd);
1295 #endif /* CONFIG_ELOOP_KQUEUE */
1296 }
1297
1298
1299 int eloop_terminated(void)
1300 {
1301         return eloop.terminate || eloop.pending_terminate;
1302 }
1303
1304
1305 void eloop_wait_for_read_sock(int sock)
1306 {
1307 #ifdef CONFIG_ELOOP_POLL
1308         struct pollfd pfd;
1309
1310         if (sock < 0)
1311                 return;
1312
1313         os_memset(&pfd, 0, sizeof(pfd));
1314         pfd.fd = sock;
1315         pfd.events = POLLIN;
1316
1317         poll(&pfd, 1, -1);
1318 #endif /* CONFIG_ELOOP_POLL */
1319 #if defined(CONFIG_ELOOP_SELECT) || defined(CONFIG_ELOOP_EPOLL)
1320         /*
1321          * We can use epoll() here. But epoll() requres 4 system calls.
1322          * epoll_create1(), epoll_ctl() for ADD, epoll_wait, and close() for
1323          * epoll fd. So select() is better for performance here.
1324          */
1325         fd_set rfds;
1326
1327         if (sock < 0)
1328                 return;
1329
1330         FD_ZERO(&rfds);
1331         FD_SET(sock, &rfds);
1332         select(sock + 1, &rfds, NULL, NULL, NULL);
1333 #endif /* defined(CONFIG_ELOOP_SELECT) || defined(CONFIG_ELOOP_EPOLL) */
1334 #ifdef CONFIG_ELOOP_KQUEUE
1335         int kfd;
1336         struct kevent ke1, ke2;
1337
1338         kfd = kqueue();
1339         if (kfd == -1)
1340                 return;
1341         EV_SET(&ke1, sock, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, 0);
1342         kevent(kfd, &ke1, 1, &ke2, 1, NULL);
1343         close(kfd);
1344 #endif /* CONFIG_ELOOP_KQUEUE */
1345 }
1346
1347 #ifdef CONFIG_ELOOP_SELECT
1348 #undef CONFIG_ELOOP_SELECT
1349 #endif /* CONFIG_ELOOP_SELECT */