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