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
67int 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
89void 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
102int 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
114void 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
134int 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
147void 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  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(QUEUE_EMPTY(&loop->watcher_queue));
170    return;
171  }
172
173  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
174    q = QUEUE_HEAD(&loop->watcher_queue);
175    QUEUE_REMOVE(q);
176    QUEUE_INIT(q);
177
178    w = 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 && QUEUE_EMPTY(&w->watcher_queue))
320        QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
321    }
322
323    if (reset_timeout != 0) {
324      timeout = user_timeout;
325      reset_timeout = 0;
326    }
327
328    if (have_signals != 0) {
329      uv__metrics_update_idle_time(loop);
330      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
331    }
332
333    loop->watchers[loop->nwatchers] = NULL;
334    loop->watchers[loop->nwatchers + 1] = NULL;
335
336    if (have_signals != 0)
337      return;  /* Event loop should cycle now so don't poll again. */
338
339    if (nevents != 0) {
340      if (nfds == ARRAY_SIZE(events) && --count != 0) {
341        /* Poll for more events but don't block this time. */
342        timeout = 0;
343        continue;
344      }
345      return;
346    }
347
348    if (saved_errno == ETIME) {
349      assert(timeout != -1);
350      return;
351    }
352
353    if (timeout == 0)
354      return;
355
356    if (timeout == -1)
357      continue;
358
359update_timeout:
360    assert(timeout > 0);
361
362    diff = loop->time - base;
363    if (diff >= (uint64_t) timeout)
364      return;
365
366    timeout -= diff;
367  }
368}
369
370
371uint64_t uv__hrtime(uv_clocktype_t type) {
372  return gethrtime();
373}
374
375
376/*
377 * We could use a static buffer for the path manipulations that we need outside
378 * of the function, but this function could be called by multiple consumers and
379 * we don't want to potentially create a race condition in the use of snprintf.
380 */
381int uv_exepath(char* buffer, size_t* size) {
382  ssize_t res;
383  char buf[128];
384
385  if (buffer == NULL || size == NULL || *size == 0)
386    return UV_EINVAL;
387
388  snprintf(buf, sizeof(buf), "/proc/%lu/path/a.out", (unsigned long) getpid());
389
390  res = *size - 1;
391  if (res > 0)
392    res = readlink(buf, buffer, res);
393
394  if (res == -1)
395    return UV__ERR(errno);
396
397  buffer[res] = '\0';
398  *size = res;
399  return 0;
400}
401
402
403uint64_t uv_get_free_memory(void) {
404  return (uint64_t) sysconf(_SC_PAGESIZE) * sysconf(_SC_AVPHYS_PAGES);
405}
406
407
408uint64_t uv_get_total_memory(void) {
409  return (uint64_t) sysconf(_SC_PAGESIZE) * sysconf(_SC_PHYS_PAGES);
410}
411
412
413uint64_t uv_get_constrained_memory(void) {
414  return 0;  /* Memory constraints are unknown. */
415}
416
417
418void uv_loadavg(double avg[3]) {
419  (void) getloadavg(avg, 3);
420}
421
422
423#if defined(PORT_SOURCE_FILE)
424
425static int uv__fs_event_rearm(uv_fs_event_t *handle) {
426  if (handle->fd == PORT_DELETED)
427    return UV_EBADF;
428
429  if (port_associate(handle->loop->fs_fd,
430                     PORT_SOURCE_FILE,
431                     (uintptr_t) &handle->fo,
432                     FILE_ATTRIB | FILE_MODIFIED,
433                     handle) == -1) {
434    return UV__ERR(errno);
435  }
436  handle->fd = PORT_LOADED;
437
438  return 0;
439}
440
441
442static void uv__fs_event_read(uv_loop_t* loop,
443                              uv__io_t* w,
444                              unsigned int revents) {
445  uv_fs_event_t *handle = NULL;
446  timespec_t timeout;
447  port_event_t pe;
448  int events;
449  int r;
450
451  (void) w;
452  (void) revents;
453
454  do {
455    uint_t n = 1;
456
457    /*
458     * Note that our use of port_getn() here (and not port_get()) is deliberate:
459     * there is a bug in event ports (Sun bug 6456558) whereby a zeroed timeout
460     * causes port_get() to return success instead of ETIME when there aren't
461     * actually any events (!); by using port_getn() in lieu of port_get(),
462     * we can at least workaround the bug by checking for zero returned events
463     * and treating it as we would ETIME.
464     */
465    do {
466      memset(&timeout, 0, sizeof timeout);
467      r = port_getn(loop->fs_fd, &pe, 1, &n, &timeout);
468    }
469    while (r == -1 && errno == EINTR);
470
471    if ((r == -1 && errno == ETIME) || n == 0)
472      break;
473
474    handle = (uv_fs_event_t*) pe.portev_user;
475    assert((r == 0) && "unexpected port_get() error");
476
477    if (uv__is_closing(handle)) {
478      uv__handle_stop(handle);
479      uv__make_close_pending((uv_handle_t*) handle);
480      break;
481    }
482
483    events = 0;
484    if (pe.portev_events & (FILE_ATTRIB | FILE_MODIFIED))
485      events |= UV_CHANGE;
486    if (pe.portev_events & ~(FILE_ATTRIB | FILE_MODIFIED))
487      events |= UV_RENAME;
488    assert(events != 0);
489    handle->fd = PORT_FIRED;
490    handle->cb(handle, NULL, events, 0);
491
492    if (handle->fd != PORT_DELETED) {
493      r = uv__fs_event_rearm(handle);
494      if (r != 0)
495        handle->cb(handle, NULL, 0, r);
496    }
497  }
498  while (handle->fd != PORT_DELETED);
499}
500
501
502int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
503  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
504  return 0;
505}
506
507
508int uv_fs_event_start(uv_fs_event_t* handle,
509                      uv_fs_event_cb cb,
510                      const char* path,
511                      unsigned int flags) {
512  int portfd;
513  int first_run;
514  int err;
515
516  if (uv__is_active(handle))
517    return UV_EINVAL;
518
519  first_run = 0;
520  if (handle->loop->fs_fd == -1) {
521    portfd = port_create();
522    if (portfd == -1)
523      return UV__ERR(errno);
524    handle->loop->fs_fd = portfd;
525    first_run = 1;
526  }
527
528  uv__handle_start(handle);
529  handle->path = uv__strdup(path);
530  handle->fd = PORT_UNUSED;
531  handle->cb = cb;
532
533  memset(&handle->fo, 0, sizeof handle->fo);
534  handle->fo.fo_name = handle->path;
535  err = uv__fs_event_rearm(handle);
536  if (err != 0) {
537    uv_fs_event_stop(handle);
538    return err;
539  }
540
541  if (first_run) {
542    uv__io_init(&handle->loop->fs_event_watcher, uv__fs_event_read, portfd);
543    uv__io_start(handle->loop, &handle->loop->fs_event_watcher, POLLIN);
544  }
545
546  return 0;
547}
548
549
550static int uv__fs_event_stop(uv_fs_event_t* handle) {
551  int ret = 0;
552
553  if (!uv__is_active(handle))
554    return 0;
555
556  if (handle->fd == PORT_LOADED) {
557    ret = port_dissociate(handle->loop->fs_fd,
558                    PORT_SOURCE_FILE,
559                    (uintptr_t) &handle->fo);
560  }
561
562  handle->fd = PORT_DELETED;
563  uv__free(handle->path);
564  handle->path = NULL;
565  handle->fo.fo_name = NULL;
566  if (ret == 0)
567    uv__handle_stop(handle);
568
569  return ret;
570}
571
572int uv_fs_event_stop(uv_fs_event_t* handle) {
573  (void) uv__fs_event_stop(handle);
574  return 0;
575}
576
577void uv__fs_event_close(uv_fs_event_t* handle) {
578  /*
579   * If we were unable to dissociate the port here, then it is most likely
580   * that there is a pending queued event. When this happens, we don't want
581   * to complete the close as it will free the underlying memory for the
582   * handle, causing a use-after-free problem when the event is processed.
583   * We defer the final cleanup until after the event is consumed in
584   * uv__fs_event_read().
585   */
586  if (uv__fs_event_stop(handle) == 0)
587    uv__make_close_pending((uv_handle_t*) handle);
588}
589
590#else /* !defined(PORT_SOURCE_FILE) */
591
592int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
593  return UV_ENOSYS;
594}
595
596
597int uv_fs_event_start(uv_fs_event_t* handle,
598                      uv_fs_event_cb cb,
599                      const char* filename,
600                      unsigned int flags) {
601  return UV_ENOSYS;
602}
603
604
605int uv_fs_event_stop(uv_fs_event_t* handle) {
606  return UV_ENOSYS;
607}
608
609
610void uv__fs_event_close(uv_fs_event_t* handle) {
611  UNREACHABLE();
612}
613
614#endif /* defined(PORT_SOURCE_FILE) */
615
616
617int uv_resident_set_memory(size_t* rss) {
618  psinfo_t psinfo;
619  int err;
620  int fd;
621
622  fd = open("/proc/self/psinfo", O_RDONLY);
623  if (fd == -1)
624    return UV__ERR(errno);
625
626  /* FIXME(bnoordhuis) Handle EINTR. */
627  err = UV_EINVAL;
628  if (read(fd, &psinfo, sizeof(psinfo)) == sizeof(psinfo)) {
629    *rss = (size_t)psinfo.pr_rssize * 1024;
630    err = 0;
631  }
632  uv__close(fd);
633
634  return err;
635}
636
637
638int uv_uptime(double* uptime) {
639  kstat_ctl_t   *kc;
640  kstat_t       *ksp;
641  kstat_named_t *knp;
642
643  long hz = sysconf(_SC_CLK_TCK);
644
645  kc = kstat_open();
646  if (kc == NULL)
647    return UV_EPERM;
648
649  ksp = kstat_lookup(kc, (char*) "unix", 0, (char*) "system_misc");
650  if (kstat_read(kc, ksp, NULL) == -1) {
651    *uptime = -1;
652  } else {
653    knp = (kstat_named_t*)  kstat_data_lookup(ksp, (char*) "clk_intr");
654    *uptime = knp->value.ul / hz;
655  }
656  kstat_close(kc);
657
658  return 0;
659}
660
661
662int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
663  int           lookup_instance;
664  kstat_ctl_t   *kc;
665  kstat_t       *ksp;
666  kstat_named_t *knp;
667  uv_cpu_info_t* cpu_info;
668
669  kc = kstat_open();
670  if (kc == NULL)
671    return UV_EPERM;
672
673  /* Get count of cpus */
674  lookup_instance = 0;
675  while ((ksp = kstat_lookup(kc, (char*) "cpu_info", lookup_instance, NULL))) {
676    lookup_instance++;
677  }
678
679  *cpu_infos = uv__malloc(lookup_instance * sizeof(**cpu_infos));
680  if (!(*cpu_infos)) {
681    kstat_close(kc);
682    return UV_ENOMEM;
683  }
684
685  *count = lookup_instance;
686
687  cpu_info = *cpu_infos;
688  lookup_instance = 0;
689  while ((ksp = kstat_lookup(kc, (char*) "cpu_info", lookup_instance, NULL))) {
690    if (kstat_read(kc, ksp, NULL) == -1) {
691      cpu_info->speed = 0;
692      cpu_info->model = NULL;
693    } else {
694      knp = kstat_data_lookup(ksp, (char*) "clock_MHz");
695      assert(knp->data_type == KSTAT_DATA_INT32 ||
696             knp->data_type == KSTAT_DATA_INT64);
697      cpu_info->speed = (knp->data_type == KSTAT_DATA_INT32) ? knp->value.i32
698                                                             : knp->value.i64;
699
700      knp = kstat_data_lookup(ksp, (char*) "brand");
701      assert(knp->data_type == KSTAT_DATA_STRING);
702      cpu_info->model = uv__strdup(KSTAT_NAMED_STR_PTR(knp));
703    }
704
705    lookup_instance++;
706    cpu_info++;
707  }
708
709  cpu_info = *cpu_infos;
710  lookup_instance = 0;
711  for (;;) {
712    ksp = kstat_lookup(kc, (char*) "cpu", lookup_instance, (char*) "sys");
713
714    if (ksp == NULL)
715      break;
716
717    if (kstat_read(kc, ksp, NULL) == -1) {
718      cpu_info->cpu_times.user = 0;
719      cpu_info->cpu_times.nice = 0;
720      cpu_info->cpu_times.sys = 0;
721      cpu_info->cpu_times.idle = 0;
722      cpu_info->cpu_times.irq = 0;
723    } else {
724      knp = kstat_data_lookup(ksp, (char*) "cpu_ticks_user");
725      assert(knp->data_type == KSTAT_DATA_UINT64);
726      cpu_info->cpu_times.user = knp->value.ui64;
727
728      knp = kstat_data_lookup(ksp, (char*) "cpu_ticks_kernel");
729      assert(knp->data_type == KSTAT_DATA_UINT64);
730      cpu_info->cpu_times.sys = knp->value.ui64;
731
732      knp = kstat_data_lookup(ksp, (char*) "cpu_ticks_idle");
733      assert(knp->data_type == KSTAT_DATA_UINT64);
734      cpu_info->cpu_times.idle = knp->value.ui64;
735
736      knp = kstat_data_lookup(ksp, (char*) "intr");
737      assert(knp->data_type == KSTAT_DATA_UINT64);
738      cpu_info->cpu_times.irq = knp->value.ui64;
739      cpu_info->cpu_times.nice = 0;
740    }
741
742    lookup_instance++;
743    cpu_info++;
744  }
745
746  kstat_close(kc);
747
748  return 0;
749}
750
751
752#ifdef SUNOS_NO_IFADDRS
753int uv_interface_addresses(uv_interface_address_t** addresses, int* count) {
754  *count = 0;
755  *addresses = NULL;
756  return UV_ENOSYS;
757}
758#else  /* SUNOS_NO_IFADDRS */
759/*
760 * Inspired By:
761 * https://blogs.oracle.com/paulie/entry/retrieving_mac_address_in_solaris
762 * http://www.pauliesworld.org/project/getmac.c
763 */
764static int uv__set_phys_addr(uv_interface_address_t* address,
765                             struct ifaddrs* ent) {
766
767  struct sockaddr_dl* sa_addr;
768  int sockfd;
769  size_t i;
770  struct arpreq arpreq;
771
772  /* This appears to only work as root */
773  sa_addr = (struct sockaddr_dl*)(ent->ifa_addr);
774  memcpy(address->phys_addr, LLADDR(sa_addr), sizeof(address->phys_addr));
775  for (i = 0; i < sizeof(address->phys_addr); i++) {
776    /* Check that all bytes of phys_addr are zero. */
777    if (address->phys_addr[i] != 0)
778      return 0;
779  }
780  memset(&arpreq, 0, sizeof(arpreq));
781  if (address->address.address4.sin_family == AF_INET) {
782    struct sockaddr_in* sin = ((struct sockaddr_in*)&arpreq.arp_pa);
783    sin->sin_addr.s_addr = address->address.address4.sin_addr.s_addr;
784  } else if (address->address.address4.sin_family == AF_INET6) {
785    struct sockaddr_in6* sin = ((struct sockaddr_in6*)&arpreq.arp_pa);
786    memcpy(sin->sin6_addr.s6_addr,
787           address->address.address6.sin6_addr.s6_addr,
788           sizeof(address->address.address6.sin6_addr.s6_addr));
789  } else {
790    return 0;
791  }
792
793  sockfd = socket(AF_INET, SOCK_DGRAM, 0);
794  if (sockfd < 0)
795    return UV__ERR(errno);
796
797  if (ioctl(sockfd, SIOCGARP, (char*)&arpreq) == -1) {
798    uv__close(sockfd);
799    return UV__ERR(errno);
800  }
801  memcpy(address->phys_addr, arpreq.arp_ha.sa_data, sizeof(address->phys_addr));
802  uv__close(sockfd);
803  return 0;
804}
805
806
807static int uv__ifaddr_exclude(struct ifaddrs *ent) {
808  if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)))
809    return 1;
810  if (ent->ifa_addr == NULL)
811    return 1;
812  if (ent->ifa_addr->sa_family != AF_INET &&
813      ent->ifa_addr->sa_family != AF_INET6)
814    return 1;
815  return 0;
816}
817
818int uv_interface_addresses(uv_interface_address_t** addresses, int* count) {
819  uv_interface_address_t* address;
820  struct ifaddrs* addrs;
821  struct ifaddrs* ent;
822
823  *count = 0;
824  *addresses = NULL;
825
826  if (getifaddrs(&addrs))
827    return UV__ERR(errno);
828
829  /* Count the number of interfaces */
830  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
831    if (uv__ifaddr_exclude(ent))
832      continue;
833    (*count)++;
834  }
835
836  if (*count == 0) {
837    freeifaddrs(addrs);
838    return 0;
839  }
840
841  *addresses = uv__malloc(*count * sizeof(**addresses));
842  if (!(*addresses)) {
843    freeifaddrs(addrs);
844    return UV_ENOMEM;
845  }
846
847  address = *addresses;
848
849  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
850    if (uv__ifaddr_exclude(ent))
851      continue;
852
853    address->name = uv__strdup(ent->ifa_name);
854
855    if (ent->ifa_addr->sa_family == AF_INET6) {
856      address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr);
857    } else {
858      address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr);
859    }
860
861    if (ent->ifa_netmask->sa_family == AF_INET6) {
862      address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask);
863    } else {
864      address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask);
865    }
866
867    address->is_internal = !!((ent->ifa_flags & IFF_PRIVATE) ||
868                           (ent->ifa_flags & IFF_LOOPBACK));
869
870    uv__set_phys_addr(address, ent);
871    address++;
872  }
873
874  freeifaddrs(addrs);
875
876  return 0;
877}
878#endif  /* SUNOS_NO_IFADDRS */
879
880void uv_free_interface_addresses(uv_interface_address_t* addresses,
881  int count) {
882  int i;
883
884  for (i = 0; i < count; i++) {
885    uv__free(addresses[i].name);
886  }
887
888  uv__free(addresses);
889}
890
891
892#if !defined(_POSIX_VERSION) || _POSIX_VERSION < 200809L
893size_t strnlen(const char* s, size_t maxlen) {
894  const char* end;
895  end = memchr(s, '\0', maxlen);
896  if (end == NULL)
897    return maxlen;
898  return end - s;
899}
900#endif
901