grpc 1.73.0 → 1.75.0

data/third_party/cares/cares/src/lib/event/ares_event_epoll.c

@@ -0,0 +1,192 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 Brad House
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "ares_private.h"
+#include "ares_event.h"
+
+#if defined(HAVE_EPOLL) && defined(CARES_THREADS)
+
+#ifdef HAVE_SYS_EPOLL_H
+#  include <sys/epoll.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+
+typedef struct {
+  int epoll_fd;
+} ares_evsys_epoll_t;
+
+static void ares_evsys_epoll_destroy(ares_event_thread_t *e)
+{
+  ares_evsys_epoll_t *ep = NULL;
+
+  if (e == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  ep = e->ev_sys_data;
+  if (ep == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (ep->epoll_fd != -1) {
+    close(ep->epoll_fd);
+  }
+
+  ares_free(ep);
+  e->ev_sys_data = NULL;
+}
+
+static ares_bool_t ares_evsys_epoll_init(ares_event_thread_t *e)
+{
+  ares_evsys_epoll_t *ep = NULL;
+
+  ep = ares_malloc_zero(sizeof(*ep));
+  if (ep == NULL) {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  e->ev_sys_data = ep;
+
+  ep->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+  if (ep->epoll_fd == -1) {
+    ares_evsys_epoll_destroy(e); /* LCOV_EXCL_LINE: UntestablePath */
+    return ARES_FALSE;           /* LCOV_EXCL_LINE: UntestablePath */
+  }
+
+  e->ev_signal = ares_pipeevent_create(e);
+  if (e->ev_signal == NULL) {
+    ares_evsys_epoll_destroy(e); /* LCOV_EXCL_LINE: UntestablePath */
+    return ARES_FALSE;           /* LCOV_EXCL_LINE: UntestablePath */
+  }
+
+  return ARES_TRUE;
+}
+
+static ares_bool_t ares_evsys_epoll_event_add(ares_event_t *event)
+{
+  const ares_event_thread_t *e  = event->e;
+  const ares_evsys_epoll_t  *ep = e->ev_sys_data;
+  struct epoll_event         epev;
+
+  memset(&epev, 0, sizeof(epev));
+  epev.data.fd = event->fd;
+  epev.events  = EPOLLRDHUP | EPOLLERR | EPOLLHUP;
+  if (event->flags & ARES_EVENT_FLAG_READ) {
+    epev.events |= EPOLLIN;
+  }
+  if (event->flags & ARES_EVENT_FLAG_WRITE) {
+    epev.events |= EPOLLOUT;
+  }
+  if (epoll_ctl(ep->epoll_fd, EPOLL_CTL_ADD, event->fd, &epev) != 0) {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: UntestablePath */
+  }
+  return ARES_TRUE;
+}
+
+static void ares_evsys_epoll_event_del(ares_event_t *event)
+{
+  const ares_event_thread_t *e  = event->e;
+  const ares_evsys_epoll_t  *ep = e->ev_sys_data;
+  struct epoll_event         epev;
+
+  memset(&epev, 0, sizeof(epev));
+  epev.data.fd = event->fd;
+  epoll_ctl(ep->epoll_fd, EPOLL_CTL_DEL, event->fd, &epev);
+}
+
+static void ares_evsys_epoll_event_mod(ares_event_t      *event,
+                                       ares_event_flags_t new_flags)
+{
+  const ares_event_thread_t *e  = event->e;
+  const ares_evsys_epoll_t  *ep = e->ev_sys_data;
+  struct epoll_event         epev;
+
+  memset(&epev, 0, sizeof(epev));
+  epev.data.fd = event->fd;
+  epev.events  = EPOLLRDHUP | EPOLLERR | EPOLLHUP;
+  if (new_flags & ARES_EVENT_FLAG_READ) {
+    epev.events |= EPOLLIN;
+  }
+  if (new_flags & ARES_EVENT_FLAG_WRITE) {
+    epev.events |= EPOLLOUT;
+  }
+  epoll_ctl(ep->epoll_fd, EPOLL_CTL_MOD, event->fd, &epev);
+}
+
+static size_t ares_evsys_epoll_wait(ares_event_thread_t *e,
+                                    unsigned long        timeout_ms)
+{
+  struct epoll_event        events[8];
+  size_t                    nevents = sizeof(events) / sizeof(*events);
+  const ares_evsys_epoll_t *ep      = e->ev_sys_data;
+  int                       rv;
+  size_t                    i;
+  size_t                    cnt = 0;
+
+  memset(events, 0, sizeof(events));
+
+  rv = epoll_wait(ep->epoll_fd, events, (int)nevents,
+                  (timeout_ms == 0) ? -1 : (int)timeout_ms);
+  if (rv < 0) {
+    return 0; /* LCOV_EXCL_LINE: UntestablePath */
+  }
+
+  nevents = (size_t)rv;
+
+  for (i = 0; i < nevents; i++) {
+    ares_event_t      *ev;
+    ares_event_flags_t flags = 0;
+
+    ev = ares_htable_asvp_get_direct(e->ev_sock_handles,
+                                     (ares_socket_t)events[i].data.fd);
+    if (ev == NULL || ev->cb == NULL) {
+      continue; /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+
+    cnt++;
+
+    if (events[i].events & (EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLERR)) {
+      flags |= ARES_EVENT_FLAG_READ;
+    }
+    if (events[i].events & EPOLLOUT) {
+      flags |= ARES_EVENT_FLAG_WRITE;
+    }
+
+    ev->cb(e, ev->fd, ev->data, flags);
+  }
+
+  return cnt;
+}
+
+const ares_event_sys_t ares_evsys_epoll = { "epoll",
+                                            ares_evsys_epoll_init,
+                                            ares_evsys_epoll_destroy,
+                                            ares_evsys_epoll_event_add,
+                                            ares_evsys_epoll_event_del,
+                                            ares_evsys_epoll_event_mod,
+                                            ares_evsys_epoll_wait };
+#endif

data/third_party/cares/cares/src/lib/event/ares_event_kqueue.c

@@ -0,0 +1,248 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 Brad House
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "ares_private.h"
+#include "ares_event.h"
+
+#if defined(HAVE_KQUEUE) && defined(CARES_THREADS)
+
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_EVENT_H
+#  include <sys/event.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+
+typedef struct {
+  int            kqueue_fd;
+  struct kevent *changelist;
+  size_t         nchanges;
+  size_t         nchanges_alloc;
+} ares_evsys_kqueue_t;
+
+static void ares_evsys_kqueue_destroy(ares_event_thread_t *e)
+{
+  ares_evsys_kqueue_t *kq = NULL;
+
+  if (e == NULL) {
+    return;
+  }
+
+  kq = e->ev_sys_data;
+  if (kq == NULL) {
+    return;
+  }
+
+  if (kq->kqueue_fd != -1) {
+    close(kq->kqueue_fd);
+  }
+
+  ares_free(kq->changelist);
+  ares_free(kq);
+  e->ev_sys_data = NULL;
+}
+
+static ares_bool_t ares_evsys_kqueue_init(ares_event_thread_t *e)
+{
+  ares_evsys_kqueue_t *kq = NULL;
+
+  kq = ares_malloc_zero(sizeof(*kq));
+  if (kq == NULL) {
+    return ARES_FALSE;
+  }
+
+  e->ev_sys_data = kq;
+
+  kq->kqueue_fd = kqueue();
+  if (kq->kqueue_fd == -1) {
+    ares_evsys_kqueue_destroy(e);
+    return ARES_FALSE;
+  }
+
+#  ifdef FD_CLOEXEC
+  fcntl(kq->kqueue_fd, F_SETFD, FD_CLOEXEC);
+#  endif
+
+  kq->nchanges_alloc = 8;
+  kq->changelist =
+    ares_malloc_zero(kq->nchanges_alloc * sizeof(*kq->changelist));
+  if (kq->changelist == NULL) {
+    ares_evsys_kqueue_destroy(e);
+    return ARES_FALSE;
+  }
+
+  e->ev_signal = ares_pipeevent_create(e);
+  if (e->ev_signal == NULL) {
+    ares_evsys_kqueue_destroy(e);
+    return ARES_FALSE;
+  }
+
+  return ARES_TRUE;
+}
+
+static void ares_evsys_kqueue_enqueue(ares_evsys_kqueue_t *kq, int fd,
+                                      int16_t filter, uint16_t flags)
+{
+  size_t idx;
+
+  if (kq == NULL) {
+    return;
+  }
+
+  idx = kq->nchanges;
+
+  kq->nchanges++;
+
+  if (kq->nchanges > kq->nchanges_alloc) {
+    kq->nchanges_alloc <<= 1;
+    kq->changelist       = ares_realloc_zero(
+      kq->changelist, (kq->nchanges_alloc >> 1) * sizeof(*kq->changelist),
+      kq->nchanges_alloc * sizeof(*kq->changelist));
+  }
+
+  EV_SET(&kq->changelist[idx], fd, filter, flags, 0, 0, 0);
+}
+
+static void ares_evsys_kqueue_event_process(ares_event_t      *event,
+                                            ares_event_flags_t old_flags,
+                                            ares_event_flags_t new_flags)
+{
+  ares_event_thread_t *e = event->e;
+  ares_evsys_kqueue_t *kq;
+
+  if (e == NULL) {
+    return;
+  }
+
+  kq = e->ev_sys_data;
+  if (kq == NULL) {
+    return;
+  }
+
+  if (new_flags & ARES_EVENT_FLAG_READ && !(old_flags & ARES_EVENT_FLAG_READ)) {
+    ares_evsys_kqueue_enqueue(kq, event->fd, EVFILT_READ, EV_ADD | EV_ENABLE);
+  }
+
+  if (!(new_flags & ARES_EVENT_FLAG_READ) && old_flags & ARES_EVENT_FLAG_READ) {
+    ares_evsys_kqueue_enqueue(kq, event->fd, EVFILT_READ, EV_DELETE);
+  }
+
+  if (new_flags & ARES_EVENT_FLAG_WRITE &&
+      !(old_flags & ARES_EVENT_FLAG_WRITE)) {
+    ares_evsys_kqueue_enqueue(kq, event->fd, EVFILT_WRITE, EV_ADD | EV_ENABLE);
+  }
+
+  if (!(new_flags & ARES_EVENT_FLAG_WRITE) &&
+      old_flags & ARES_EVENT_FLAG_WRITE) {
+    ares_evsys_kqueue_enqueue(kq, event->fd, EVFILT_WRITE, EV_DELETE);
+  }
+}
+
+static ares_bool_t ares_evsys_kqueue_event_add(ares_event_t *event)
+{
+  ares_evsys_kqueue_event_process(event, 0, event->flags);
+  return ARES_TRUE;
+}
+
+static void ares_evsys_kqueue_event_del(ares_event_t *event)
+{
+  ares_evsys_kqueue_event_process(event, event->flags, 0);
+}
+
+static void ares_evsys_kqueue_event_mod(ares_event_t      *event,
+                                        ares_event_flags_t new_flags)
+{
+  ares_evsys_kqueue_event_process(event, event->flags, new_flags);
+}
+
+static size_t ares_evsys_kqueue_wait(ares_event_thread_t *e,
+                                     unsigned long        timeout_ms)
+{
+  struct kevent        events[8];
+  size_t               nevents = sizeof(events) / sizeof(*events);
+  ares_evsys_kqueue_t *kq      = e->ev_sys_data;
+  int                  rv;
+  size_t               i;
+  struct timespec      ts;
+  struct timespec     *timeout = NULL;
+  size_t               cnt     = 0;
+
+  if (timeout_ms != 0) {
+    ts.tv_sec  = (time_t)timeout_ms / 1000;
+    ts.tv_nsec = (timeout_ms % 1000) * 1000 * 1000;
+    timeout    = &ts;
+  }
+
+  memset(events, 0, sizeof(events));
+
+  rv = kevent(kq->kqueue_fd, kq->changelist, (int)kq->nchanges, events,
+              (int)nevents, timeout);
+  if (rv < 0) {
+    return 0;
+  }
+
+  /* Changelist was consumed */
+  kq->nchanges = 0;
+  nevents      = (size_t)rv;
+
+  for (i = 0; i < nevents; i++) {
+    ares_event_t      *ev;
+    ares_event_flags_t flags = 0;
+
+    ev = ares_htable_asvp_get_direct(e->ev_sock_handles,
+                                     (ares_socket_t)events[i].ident);
+    if (ev == NULL || ev->cb == NULL) {
+      continue;
+    }
+
+    cnt++;
+
+    if (events[i].filter == EVFILT_READ ||
+        events[i].flags & (EV_EOF | EV_ERROR)) {
+      flags |= ARES_EVENT_FLAG_READ;
+    } else {
+      flags |= ARES_EVENT_FLAG_WRITE;
+    }
+
+    ev->cb(e, ev->fd, ev->data, flags);
+  }
+
+  return cnt;
+}
+
+const ares_event_sys_t ares_evsys_kqueue = { "kqueue",
+                                             ares_evsys_kqueue_init,
+                                             ares_evsys_kqueue_destroy,
+                                             ares_evsys_kqueue_event_add,
+                                             ares_evsys_kqueue_event_del,
+                                             ares_evsys_kqueue_event_mod,
+                                             ares_evsys_kqueue_wait };
+#endif

data/third_party/cares/cares/src/lib/event/ares_event_poll.c

@@ -0,0 +1,140 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 Brad House
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "ares_private.h"
+#include "ares_event.h"
+
+#if defined(HAVE_POLL) && defined(CARES_THREADS)
+
+#ifdef HAVE_POLL_H
+#  include <poll.h>
+#endif
+
+static ares_bool_t ares_evsys_poll_init(ares_event_thread_t *e)
+{
+  e->ev_signal = ares_pipeevent_create(e);
+  if (e->ev_signal == NULL) {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: UntestablePath */
+  }
+  return ARES_TRUE;
+}
+
+static void ares_evsys_poll_destroy(ares_event_thread_t *e)
+{
+  (void)e;
+}
+
+static ares_bool_t ares_evsys_poll_event_add(ares_event_t *event)
+{
+  (void)event;
+  return ARES_TRUE;
+}
+
+static void ares_evsys_poll_event_del(ares_event_t *event)
+{
+  (void)event;
+}
+
+static void ares_evsys_poll_event_mod(ares_event_t      *event,
+                                      ares_event_flags_t new_flags)
+{
+  (void)event;
+  (void)new_flags;
+}
+
+static size_t ares_evsys_poll_wait(ares_event_thread_t *e,
+                                   unsigned long        timeout_ms)
+{
+  size_t         num_fds = 0;
+  ares_socket_t *fdlist  = ares_htable_asvp_keys(e->ev_sock_handles, &num_fds);
+  struct pollfd *pollfd  = NULL;
+  int            rv;
+  size_t         cnt = 0;
+  size_t         i;
+
+  if (fdlist != NULL && num_fds) {
+    pollfd = ares_malloc_zero(sizeof(*pollfd) * num_fds);
+    if (pollfd == NULL) {
+      goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    for (i = 0; i < num_fds; i++) {
+      const ares_event_t *ev =
+        ares_htable_asvp_get_direct(e->ev_sock_handles, fdlist[i]);
+      pollfd[i].fd = ev->fd;
+      if (ev->flags & ARES_EVENT_FLAG_READ) {
+        pollfd[i].events |= POLLIN;
+      }
+      if (ev->flags & ARES_EVENT_FLAG_WRITE) {
+        pollfd[i].events |= POLLOUT;
+      }
+    }
+  }
+  ares_free(fdlist);
+
+  rv = poll(pollfd, (nfds_t)num_fds, (timeout_ms == 0) ? -1 : (int)timeout_ms);
+  if (rv <= 0) {
+    goto done;
+  }
+
+  for (i = 0; pollfd != NULL && i < num_fds; i++) {
+    ares_event_t      *ev;
+    ares_event_flags_t flags = 0;
+
+    if (pollfd[i].revents == 0) {
+      continue;
+    }
+
+    cnt++;
+
+    ev = ares_htable_asvp_get_direct(e->ev_sock_handles, pollfd[i].fd);
+    if (ev == NULL || ev->cb == NULL) {
+      continue; /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+
+    if (pollfd[i].revents & (POLLERR | POLLHUP | POLLIN)) {
+      flags |= ARES_EVENT_FLAG_READ;
+    }
+
+    if (pollfd[i].revents & POLLOUT) {
+      flags |= ARES_EVENT_FLAG_WRITE;
+    }
+
+    ev->cb(e, pollfd[i].fd, ev->data, flags);
+  }
+
+done:
+  ares_free(pollfd);
+  return cnt;
+}
+
+const ares_event_sys_t ares_evsys_poll = { "poll",
+                                           ares_evsys_poll_init,
+                                           ares_evsys_poll_destroy,   /* NoOp */
+                                           ares_evsys_poll_event_add, /* NoOp */
+                                           ares_evsys_poll_event_del, /* NoOp */
+                                           ares_evsys_poll_event_mod, /* NoOp */
+                                           ares_evsys_poll_wait };
+
+#endif