1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. 2 * Permission is hereby granted, free of charge, to any person obtaining a copy 3 * of this software and associated documentation files (the "Software"), to 4 * deal in the Software without restriction, including without limitation the 5 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 6 * sell copies of the Software, and to permit persons to whom the Software is 7 * furnished to do so, subject to the following conditions: 8 * 9 * The above copyright notice and this permission notice shall be included in 10 * all copies or substantial portions of the Software. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 15 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 16 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 17 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 18 * IN THE SOFTWARE. 19 */ 20 21 #include "uv.h" 22 #include "internal.h" 23 24 #include <stdio.h> 25 #include <stdint.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <assert.h> 29 #include <errno.h> 30 31 #ifndef SUNOS_NO_IFADDRS 32 # include <ifaddrs.h> 33 #endif 34 #include <net/if.h> 35 #include <net/if_dl.h> 36 #include <net/if_arp.h> 37 #include <sys/sockio.h> 38 39 #include <sys/loadavg.h> 40 #include <sys/time.h> 41 #include <unistd.h> 42 #include <kstat.h> 43 #include <fcntl.h> 44 45 #include <sys/port.h> 46 #include <port.h> 47 48 #define PORT_FIRED 0x69 49 #define PORT_UNUSED 0x0 50 #define PORT_LOADED 0x99 51 #define PORT_DELETED -1 52 53 #if (!defined(_LP64)) && (_FILE_OFFSET_BITS - 0 == 64) 54 #define PROCFS_FILE_OFFSET_BITS_HACK 1 55 #undef _FILE_OFFSET_BITS 56 #else 57 #define PROCFS_FILE_OFFSET_BITS_HACK 0 58 #endif 59 60 #include <procfs.h> 61 62 #if (PROCFS_FILE_OFFSET_BITS_HACK - 0 == 1) 63 #define _FILE_OFFSET_BITS 64 64 #endif 65 66 67 int uv__platform_loop_init(uv_loop_t* loop) { 68 int err; 69 int fd; 70 71 loop->fs_fd = -1; 72 loop->backend_fd = -1; 73 74 fd = port_create(); 75 if (fd == -1) 76 return UV__ERR(errno); 77 78 err = uv__cloexec(fd, 1); 79 if (err) { 80 uv__close(fd); 81 return err; 82 } 83 loop->backend_fd = fd; 84 85 return 0; 86 } 87 88 89 void uv__platform_loop_delete(uv_loop_t* loop) { 90 if (loop->fs_fd != -1) { 91 uv__close(loop->fs_fd); 92 loop->fs_fd = -1; 93 } 94 95 if (loop->backend_fd != -1) { 96 uv__close(loop->backend_fd); 97 loop->backend_fd = -1; 98 } 99 } 100 101 102 int uv__io_fork(uv_loop_t* loop) { 103 #if defined(PORT_SOURCE_FILE) 104 if (loop->fs_fd != -1) { 105 /* stop the watcher before we blow away its fileno */ 106 uv__io_stop(loop, &loop->fs_event_watcher, POLLIN); 107 } 108 #endif 109 uv__platform_loop_delete(loop); 110 return uv__platform_loop_init(loop); 111 } 112 113 114 void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) { 115 struct port_event* events; 116 uintptr_t i; 117 uintptr_t nfds; 118 119 assert(loop->watchers != NULL); 120 assert(fd >= 0); 121 122 events = (struct port_event*) loop->watchers[loop->nwatchers]; 123 nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1]; 124 if (events == NULL) 125 return; 126 127 /* Invalidate events with same file descriptor */ 128 for (i = 0; i < nfds; i++) 129 if ((int) events[i].portev_object == fd) 130 events[i].portev_object = -1; 131 } 132 133 134 int uv__io_check_fd(uv_loop_t* loop, int fd) { 135 if (port_associate(loop->backend_fd, PORT_SOURCE_FD, fd, POLLIN, 0)) 136 return UV__ERR(errno); 137 138 if (port_dissociate(loop->backend_fd, PORT_SOURCE_FD, fd)) { 139 perror("(libuv) port_dissociate()"); 140 abort(); 141 } 142 143 return 0; 144 } 145 146 147 void uv__io_poll(uv_loop_t* loop, int timeout) { 148 struct port_event events[1024]; 149 struct port_event* pe; 150 struct timespec spec; 151 struct uv__queue* q; 152 uv__io_t* w; 153 sigset_t* pset; 154 sigset_t set; 155 uint64_t base; 156 uint64_t diff; 157 unsigned int nfds; 158 unsigned int i; 159 int saved_errno; 160 int have_signals; 161 int nevents; 162 int count; 163 int err; 164 int fd; 165 int user_timeout; 166 int reset_timeout; 167 168 if (loop->nfds == 0) { 169 assert(uv__queue_empty(&loop->watcher_queue)); 170 return; 171 } 172 173 while (!uv__queue_empty(&loop->watcher_queue)) { 174 q = uv__queue_head(&loop->watcher_queue); 175 uv__queue_remove(q); 176 uv__queue_init(q); 177 178 w = uv__queue_data(q, uv__io_t, watcher_queue); 179 assert(w->pevents != 0); 180 181 if (port_associate(loop->backend_fd, 182 PORT_SOURCE_FD, 183 w->fd, 184 w->pevents, 185 0)) { 186 perror("(libuv) port_associate()"); 187 abort(); 188 } 189 190 w->events = w->pevents; 191 } 192 193 pset = NULL; 194 if (loop->flags & UV_LOOP_BLOCK_SIGPROF) { 195 pset = &set; 196 sigemptyset(pset); 197 sigaddset(pset, SIGPROF); 198 } 199 200 assert(timeout >= -1); 201 base = loop->time; 202 count = 48; /* Benchmarks suggest this gives the best throughput. */ 203 204 if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { 205 reset_timeout = 1; 206 user_timeout = timeout; 207 timeout = 0; 208 } else { 209 reset_timeout = 0; 210 } 211 212 for (;;) { 213 /* Only need to set the provider_entry_time if timeout != 0. The function 214 * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME. 215 */ 216 if (timeout != 0) 217 uv__metrics_set_provider_entry_time(loop); 218 219 if (timeout != -1) { 220 spec.tv_sec = timeout / 1000; 221 spec.tv_nsec = (timeout % 1000) * 1000000; 222 } 223 224 /* Work around a kernel bug where nfds is not updated. */ 225 events[0].portev_source = 0; 226 227 nfds = 1; 228 saved_errno = 0; 229 230 if (pset != NULL) 231 pthread_sigmask(SIG_BLOCK, pset, NULL); 232 233 err = port_getn(loop->backend_fd, 234 events, 235 ARRAY_SIZE(events), 236 &nfds, 237 timeout == -1 ? NULL : &spec); 238 239 if (pset != NULL) 240 pthread_sigmask(SIG_UNBLOCK, pset, NULL); 241 242 if (err) { 243 /* Work around another kernel bug: port_getn() may return events even 244 * on error. 245 */ 246 if (errno == EINTR || errno == ETIME) { 247 saved_errno = errno; 248 } else { 249 perror("(libuv) port_getn()"); 250 abort(); 251 } 252 } 253 254 /* Update loop->time unconditionally. It's tempting to skip the update when 255 * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the 256 * operating system didn't reschedule our process while in the syscall. 257 */ 258 SAVE_ERRNO(uv__update_time(loop)); 259 260 if (events[0].portev_source == 0) { 261 if (reset_timeout != 0) { 262 timeout = user_timeout; 263 reset_timeout = 0; 264 } 265 266 if (timeout == 0) 267 return; 268 269 if (timeout == -1) 270 continue; 271 272 goto update_timeout; 273 } 274 275 if (nfds == 0) { 276 assert(timeout != -1); 277 return; 278 } 279 280 have_signals = 0; 281 nevents = 0; 282 283 assert(loop->watchers != NULL); 284 loop->watchers[loop->nwatchers] = (void*) events; 285 loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds; 286 for (i = 0; i < nfds; i++) { 287 pe = events + i; 288 fd = pe->portev_object; 289 290 /* Skip invalidated events, see uv__platform_invalidate_fd */ 291 if (fd == -1) 292 continue; 293 294 assert(fd >= 0); 295 assert((unsigned) fd < loop->nwatchers); 296 297 w = loop->watchers[fd]; 298 299 /* File descriptor that we've stopped watching, ignore. */ 300 if (w == NULL) 301 continue; 302 303 /* Run signal watchers last. This also affects child process watchers 304 * because those are implemented in terms of signal watchers. 305 */ 306 if (w == &loop->signal_io_watcher) { 307 have_signals = 1; 308 } else { 309 uv__metrics_update_idle_time(loop); 310 w->cb(loop, w, pe->portev_events); 311 } 312 313 nevents++; 314 315 if (w != loop->watchers[fd]) 316 continue; /* Disabled by callback. */ 317 318 /* Events Ports operates in oneshot mode, rearm timer on next run. */ 319 if (w->pevents != 0 && uv__queue_empty(&w->watcher_queue)) 320 uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue); 321 } 322 323 uv__metrics_inc_events(loop, nevents); 324 if (reset_timeout != 0) { 325 timeout = user_timeout; 326 reset_timeout = 0; 327 uv__metrics_inc_events_waiting(loop, nevents); 328 } 329 330 if (have_signals != 0) { 331 uv__metrics_update_idle_time(loop); 332 loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN); 333 } 334 335 loop->watchers[loop->nwatchers] = NULL; 336 loop->watchers[loop->nwatchers + 1] = NULL; 337 338 if (have_signals != 0) 339 return; /* Event loop should cycle now so don't poll again. */ 340 341 if (nevents != 0) { 342 if (nfds == ARRAY_SIZE(events) && --count != 0) { 343 /* Poll for more events but don't block this time. */ 344 timeout = 0; 345 continue; 346 } 347 return; 348 } 349 350 if (saved_errno == ETIME) { 351 assert(timeout != -1); 352 return; 353 } 354 355 if (timeout == 0) 356 return; 357 358 if (timeout == -1) 359 continue; 360 361 update_timeout: 362 assert(timeout > 0); 363 364 diff = loop->time - base; 365 if (diff >= (uint64_t) timeout) 366 return; 367 368 timeout -= diff; 369 } 370 } 371 372 373 uint64_t uv__hrtime(uv_clocktype_t type) { 374 return gethrtime(); 375 } 376 377 378 /* 379 * We could use a static buffer for the path manipulations that we need outside 380 * of the function, but this function could be called by multiple consumers and 381 * we don't want to potentially create a race condition in the use of snprintf. 382 */ 383 int uv_exepath(char* buffer, size_t* size) { 384 ssize_t res; 385 char buf[128]; 386 387 if (buffer == NULL || size == NULL || *size == 0) 388 return UV_EINVAL; 389 390 snprintf(buf, sizeof(buf), "/proc/%lu/path/a.out", (unsigned long) getpid()); 391 392 res = *size - 1; 393 if (res > 0) 394 res = readlink(buf, buffer, res); 395 396 if (res == -1) 397 return UV__ERR(errno); 398 399 buffer[res] = '\0'; 400 *size = res; 401 return 0; 402 } 403 404 405 uint64_t uv_get_free_memory(void) { 406 return (uint64_t) sysconf(_SC_PAGESIZE) * sysconf(_SC_AVPHYS_PAGES); 407 } 408 409 410 uint64_t uv_get_total_memory(void) { 411 return (uint64_t) sysconf(_SC_PAGESIZE) * sysconf(_SC_PHYS_PAGES); 412 } 413 414 415 uint64_t uv_get_constrained_memory(void) { 416 return 0; /* Memory constraints are unknown. */ 417 } 418 419 420 uint64_t uv_get_available_memory(void) { 421 return uv_get_free_memory(); 422 } 423 424 425 void uv_loadavg(double avg[3]) { 426 (void) getloadavg(avg, 3); 427 } 428 429 430 #if defined(PORT_SOURCE_FILE) 431 432 static int uv__fs_event_rearm(uv_fs_event_t *handle) { 433 if (handle->fd == PORT_DELETED) 434 return UV_EBADF; 435 436 if (port_associate(handle->loop->fs_fd, 437 PORT_SOURCE_FILE, 438 (uintptr_t) &handle->fo, 439 FILE_ATTRIB | FILE_MODIFIED, 440 handle) == -1) { 441 return UV__ERR(errno); 442 } 443 handle->fd = PORT_LOADED; 444 445 return 0; 446 } 447 448 449 static void uv__fs_event_read(uv_loop_t* loop, 450 uv__io_t* w, 451 unsigned int revents) { 452 uv_fs_event_t *handle = NULL; 453 timespec_t timeout; 454 port_event_t pe; 455 int events; 456 int r; 457 458 (void) w; 459 (void) revents; 460 461 do { 462 uint_t n = 1; 463 464 /* 465 * Note that our use of port_getn() here (and not port_get()) is deliberate: 466 * there is a bug in event ports (Sun bug 6456558) whereby a zeroed timeout 467 * causes port_get() to return success instead of ETIME when there aren't 468 * actually any events (!); by using port_getn() in lieu of port_get(), 469 * we can at least workaround the bug by checking for zero returned events 470 * and treating it as we would ETIME. 471 */ 472 do { 473 memset(&timeout, 0, sizeof timeout); 474 r = port_getn(loop->fs_fd, &pe, 1, &n, &timeout); 475 } 476 while (r == -1 && errno == EINTR); 477 478 if ((r == -1 && errno == ETIME) || n == 0) 479 break; 480 481 handle = (uv_fs_event_t*) pe.portev_user; 482 assert((r == 0) && "unexpected port_get() error"); 483 484 if (uv__is_closing(handle)) { 485 uv__handle_stop(handle); 486 uv__make_close_pending((uv_handle_t*) handle); 487 break; 488 } 489 490 events = 0; 491 if (pe.portev_events & (FILE_ATTRIB | FILE_MODIFIED)) 492 events |= UV_CHANGE; 493 if (pe.portev_events & ~(FILE_ATTRIB | FILE_MODIFIED)) 494 events |= UV_RENAME; 495 assert(events != 0); 496 handle->fd = PORT_FIRED; 497 handle->cb(handle, NULL, events, 0); 498 499 if (handle->fd != PORT_DELETED) { 500 r = uv__fs_event_rearm(handle); 501 if (r != 0) 502 handle->cb(handle, NULL, 0, r); 503 } 504 } 505 while (handle->fd != PORT_DELETED); 506 } 507 508 509 int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) { 510 uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT); 511 return 0; 512 } 513 514 515 int uv_fs_event_start(uv_fs_event_t* handle, 516 uv_fs_event_cb cb, 517 const char* path, 518 unsigned int flags) { 519 int portfd; 520 int first_run; 521 int err; 522 523 if (uv__is_active(handle)) 524 return UV_EINVAL; 525 526 first_run = 0; 527 if (handle->loop->fs_fd == -1) { 528 portfd = port_create(); 529 if (portfd == -1) 530 return UV__ERR(errno); 531 handle->loop->fs_fd = portfd; 532 first_run = 1; 533 } 534 535 uv__handle_start(handle); 536 handle->path = uv__strdup(path); 537 handle->fd = PORT_UNUSED; 538 handle->cb = cb; 539 540 memset(&handle->fo, 0, sizeof handle->fo); 541 handle->fo.fo_name = handle->path; 542 err = uv__fs_event_rearm(handle); 543 if (err != 0) { 544 uv_fs_event_stop(handle); 545 return err; 546 } 547 548 if (first_run) { 549 err = uv__io_init_start(handle->loop, 550 &handle->loop->fs_event_watcher, 551 uv__fs_event_read, 552 portfd, 553 POLLIN); 554 if (err) 555 uv__handle_stop(handle); 556 557 return err; 558 } 559 560 return 0; 561 } 562 563 564 static int uv__fs_event_stop(uv_fs_event_t* handle) { 565 int ret = 0; 566 567 if (!uv__is_active(handle)) 568 return 0; 569 570 if (handle->fd == PORT_LOADED) { 571 ret = port_dissociate(handle->loop->fs_fd, 572 PORT_SOURCE_FILE, 573 (uintptr_t) &handle->fo); 574 } 575 576 handle->fd = PORT_DELETED; 577 uv__free(handle->path); 578 handle->path = NULL; 579 handle->fo.fo_name = NULL; 580 if (ret == 0) 581 uv__handle_stop(handle); 582 583 return ret; 584 } 585 586 int uv_fs_event_stop(uv_fs_event_t* handle) { 587 (void) uv__fs_event_stop(handle); 588 return 0; 589 } 590 591 void uv__fs_event_close(uv_fs_event_t* handle) { 592 /* 593 * If we were unable to dissociate the port here, then it is most likely 594 * that there is a pending queued event. When this happens, we don't want 595 * to complete the close as it will free the underlying memory for the 596 * handle, causing a use-after-free problem when the event is processed. 597 * We defer the final cleanup until after the event is consumed in 598 * uv__fs_event_read(). 599 */ 600 if (uv__fs_event_stop(handle) == 0) 601 uv__make_close_pending((uv_handle_t*) handle); 602 } 603 604 #else /* !defined(PORT_SOURCE_FILE) */ 605 606 int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) { 607 return UV_ENOSYS; 608 } 609 610 611 int uv_fs_event_start(uv_fs_event_t* handle, 612 uv_fs_event_cb cb, 613 const char* filename, 614 unsigned int flags) { 615 return UV_ENOSYS; 616 } 617 618 619 int uv_fs_event_stop(uv_fs_event_t* handle) { 620 return UV_ENOSYS; 621 } 622 623 624 void uv__fs_event_close(uv_fs_event_t* handle) { 625 UNREACHABLE(); 626 } 627 628 #endif /* defined(PORT_SOURCE_FILE) */ 629 630 631 int uv_resident_set_memory(size_t* rss) { 632 psinfo_t psinfo; 633 int err; 634 int fd; 635 636 fd = open("/proc/self/psinfo", O_RDONLY); 637 if (fd == -1) 638 return UV__ERR(errno); 639 640 /* FIXME(bnoordhuis) Handle EINTR. */ 641 err = UV_EINVAL; 642 if (read(fd, &psinfo, sizeof(psinfo)) == sizeof(psinfo)) { 643 *rss = (size_t)psinfo.pr_rssize * 1024; 644 err = 0; 645 } 646 uv__close(fd); 647 648 return err; 649 } 650 651 652 int uv_uptime(double* uptime) { 653 kstat_ctl_t *kc; 654 kstat_t *ksp; 655 kstat_named_t *knp; 656 657 long hz = sysconf(_SC_CLK_TCK); 658 659 kc = kstat_open(); 660 if (kc == NULL) 661 return UV_EPERM; 662 663 ksp = kstat_lookup(kc, (char*) "unix", 0, (char*) "system_misc"); 664 if (kstat_read(kc, ksp, NULL) == -1) { 665 *uptime = -1; 666 } else { 667 knp = (kstat_named_t*) kstat_data_lookup(ksp, (char*) "clk_intr"); 668 *uptime = knp->value.ul / hz; 669 } 670 kstat_close(kc); 671 672 return 0; 673 } 674 675 676 int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { 677 int lookup_instance; 678 kstat_ctl_t *kc; 679 kstat_t *ksp; 680 kstat_named_t *knp; 681 uv_cpu_info_t* cpu_info; 682 683 kc = kstat_open(); 684 if (kc == NULL) 685 return UV_EPERM; 686 687 /* Get count of cpus */ 688 lookup_instance = 0; 689 while ((ksp = kstat_lookup(kc, (char*) "cpu_info", lookup_instance, NULL))) { 690 lookup_instance++; 691 } 692 693 *cpu_infos = uv__malloc(lookup_instance * sizeof(**cpu_infos)); 694 if (!(*cpu_infos)) { 695 kstat_close(kc); 696 return UV_ENOMEM; 697 } 698 699 *count = lookup_instance; 700 701 cpu_info = *cpu_infos; 702 lookup_instance = 0; 703 while ((ksp = kstat_lookup(kc, (char*) "cpu_info", lookup_instance, NULL))) { 704 if (kstat_read(kc, ksp, NULL) == -1) { 705 cpu_info->speed = 0; 706 cpu_info->model = NULL; 707 } else { 708 knp = kstat_data_lookup(ksp, (char*) "clock_MHz"); 709 assert(knp->data_type == KSTAT_DATA_INT32 || 710 knp->data_type == KSTAT_DATA_INT64); 711 cpu_info->speed = (knp->data_type == KSTAT_DATA_INT32) ? knp->value.i32 712 : knp->value.i64; 713 714 knp = kstat_data_lookup(ksp, (char*) "brand"); 715 assert(knp->data_type == KSTAT_DATA_STRING); 716 cpu_info->model = uv__strdup(KSTAT_NAMED_STR_PTR(knp)); 717 } 718 719 lookup_instance++; 720 cpu_info++; 721 } 722 723 cpu_info = *cpu_infos; 724 lookup_instance = 0; 725 for (;;) { 726 ksp = kstat_lookup(kc, (char*) "cpu", lookup_instance, (char*) "sys"); 727 728 if (ksp == NULL) 729 break; 730 731 if (kstat_read(kc, ksp, NULL) == -1) { 732 cpu_info->cpu_times.user = 0; 733 cpu_info->cpu_times.nice = 0; 734 cpu_info->cpu_times.sys = 0; 735 cpu_info->cpu_times.idle = 0; 736 cpu_info->cpu_times.irq = 0; 737 } else { 738 knp = kstat_data_lookup(ksp, (char*) "cpu_ticks_user"); 739 assert(knp->data_type == KSTAT_DATA_UINT64); 740 cpu_info->cpu_times.user = knp->value.ui64; 741 742 knp = kstat_data_lookup(ksp, (char*) "cpu_ticks_kernel"); 743 assert(knp->data_type == KSTAT_DATA_UINT64); 744 cpu_info->cpu_times.sys = knp->value.ui64; 745 746 knp = kstat_data_lookup(ksp, (char*) "cpu_ticks_idle"); 747 assert(knp->data_type == KSTAT_DATA_UINT64); 748 cpu_info->cpu_times.idle = knp->value.ui64; 749 750 knp = kstat_data_lookup(ksp, (char*) "intr"); 751 assert(knp->data_type == KSTAT_DATA_UINT64); 752 cpu_info->cpu_times.irq = knp->value.ui64; 753 cpu_info->cpu_times.nice = 0; 754 } 755 756 lookup_instance++; 757 cpu_info++; 758 } 759 760 kstat_close(kc); 761 762 return 0; 763 } 764 765 766 #ifdef SUNOS_NO_IFADDRS 767 int uv_interface_addresses(uv_interface_address_t** addresses, int* count) { 768 *count = 0; 769 *addresses = NULL; 770 return UV_ENOSYS; 771 } 772 #else /* SUNOS_NO_IFADDRS */ 773 /* 774 * Inspired By: 775 * https://blogs.oracle.com/paulie/entry/retrieving_mac_address_in_solaris 776 * http://www.pauliesworld.org/project/getmac.c 777 */ 778 static int uv__set_phys_addr(uv_interface_address_t* address, 779 struct ifaddrs* ent) { 780 781 struct sockaddr_dl* sa_addr; 782 int sockfd; 783 size_t i; 784 struct arpreq arpreq; 785 786 /* This appears to only work as root */ 787 sa_addr = (struct sockaddr_dl*)(ent->ifa_addr); 788 memcpy(address->phys_addr, LLADDR(sa_addr), sizeof(address->phys_addr)); 789 for (i = 0; i < sizeof(address->phys_addr); i++) { 790 /* Check that all bytes of phys_addr are zero. */ 791 if (address->phys_addr[i] != 0) 792 return 0; 793 } 794 memset(&arpreq, 0, sizeof(arpreq)); 795 if (address->address.address4.sin_family == AF_INET) { 796 struct sockaddr_in* sin = ((struct sockaddr_in*)&arpreq.arp_pa); 797 sin->sin_addr.s_addr = address->address.address4.sin_addr.s_addr; 798 } else if (address->address.address4.sin_family == AF_INET6) { 799 struct sockaddr_in6* sin = ((struct sockaddr_in6*)&arpreq.arp_pa); 800 memcpy(sin->sin6_addr.s6_addr, 801 address->address.address6.sin6_addr.s6_addr, 802 sizeof(address->address.address6.sin6_addr.s6_addr)); 803 } else { 804 return 0; 805 } 806 807 sockfd = socket(AF_INET, SOCK_DGRAM, 0); 808 if (sockfd < 0) 809 return UV__ERR(errno); 810 811 if (ioctl(sockfd, SIOCGARP, (char*)&arpreq) == -1) { 812 uv__close(sockfd); 813 return UV__ERR(errno); 814 } 815 memcpy(address->phys_addr, arpreq.arp_ha.sa_data, sizeof(address->phys_addr)); 816 uv__close(sockfd); 817 return 0; 818 } 819 820 821 static int uv__ifaddr_exclude(struct ifaddrs *ent) { 822 if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING))) 823 return 1; 824 if (ent->ifa_addr == NULL) 825 return 1; 826 if (ent->ifa_addr->sa_family != AF_INET && 827 ent->ifa_addr->sa_family != AF_INET6) 828 return 1; 829 return 0; 830 } 831 832 int uv_interface_addresses(uv_interface_address_t** addresses, int* count) { 833 uv_interface_address_t* address; 834 struct ifaddrs* addrs; 835 struct ifaddrs* ent; 836 size_t namelen; 837 char* name; 838 839 *count = 0; 840 *addresses = NULL; 841 842 if (getifaddrs(&addrs)) 843 return UV__ERR(errno); 844 845 /* Count the number of interfaces */ 846 namelen = 0; 847 for (ent = addrs; ent != NULL; ent = ent->ifa_next) { 848 if (uv__ifaddr_exclude(ent)) 849 continue; 850 namelen += strlen(ent->ifa_name) + 1; 851 (*count)++; 852 } 853 854 if (*count == 0) { 855 freeifaddrs(addrs); 856 return 0; 857 } 858 859 *addresses = uv__calloc(1, *count * sizeof(**addresses) + namelen); 860 if (*addresses == NULL) { 861 freeifaddrs(addrs); 862 return UV_ENOMEM; 863 } 864 865 name = (char*) &(*addresses)[*count]; 866 address = *addresses; 867 868 for (ent = addrs; ent != NULL; ent = ent->ifa_next) { 869 if (uv__ifaddr_exclude(ent)) 870 continue; 871 872 namelen = strlen(ent->ifa_name) + 1; 873 address->name = memcpy(name, ent->ifa_name, namelen); 874 name += namelen; 875 876 if (ent->ifa_addr->sa_family == AF_INET6) { 877 address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr); 878 } else { 879 address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr); 880 } 881 882 if (ent->ifa_netmask->sa_family == AF_INET6) { 883 address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask); 884 } else { 885 address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask); 886 } 887 888 address->is_internal = !!((ent->ifa_flags & IFF_PRIVATE) || 889 (ent->ifa_flags & IFF_LOOPBACK)); 890 891 uv__set_phys_addr(address, ent); 892 address++; 893 } 894 895 freeifaddrs(addrs); 896 897 return 0; 898 } 899 #endif /* SUNOS_NO_IFADDRS */ 900 901 void uv_free_interface_addresses(uv_interface_address_t* addresses, 902 int count) { 903 uv__free(addresses); 904 } 905 906 907 #if !defined(_POSIX_VERSION) || _POSIX_VERSION < 200809L 908 size_t strnlen(const char* s, size_t maxlen) { 909 const char* end; 910 end = memchr(s, '\0', maxlen); 911 if (end == NULL) 912 return maxlen; 913 return end - s; 914 } 915 #endif 916
Indexes created Mon May 25 00:24:39 UTC 2026