granicus.if.org Git - sudo/blob - lib/util/event_poll.c

   1 /*
   2  * Copyright (c) 2013-2015 Todd C. Miller <Todd.Miller@sudo.ws>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 /*
  18  * This is an open source non-commercial project. Dear PVS-Studio, please check it.
  19  * PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
  20  */
  21
  22 #include <config.h>
  23
  24 #include <sys/types.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #ifdef HAVE_STDBOOL_H
  28 # include <stdbool.h>
  29 #else
  30 # include "compat/stdbool.h"
  31 #endif /* HAVE_STDBOOL_H */
  32 #ifdef HAVE_STRING_H
  33 # include <string.h>
  34 #endif /* HAVE_STRING_H */
  35 #ifdef HAVE_STRINGS_H
  36 # include <strings.h>
  37 #endif /* HAVE_STRINGS_H */
  38 #include <time.h>
  39 #include <unistd.h>
  40 #include <errno.h>
  41 #include <poll.h>
  42
  43 #include "sudo_compat.h"
  44 #include "sudo_util.h"
  45 #include "sudo_fatal.h"
  46 #include "sudo_debug.h"
  47 #include "sudo_event.h"
  48
  49 int
  50 sudo_ev_base_alloc_impl(struct sudo_event_base *base)
  51 {
  52     int i;
  53     debug_decl(sudo_ev_base_alloc_impl, SUDO_DEBUG_EVENT)
  54
  55     base->pfd_high = -1;
  56     base->pfd_max = 32;
  57     base->pfds = reallocarray(NULL, base->pfd_max, sizeof(struct pollfd));
  58     if (base->pfds == NULL) {
  59         sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO,
  60             "%s: unable to allocate %d pollfds", __func__, base->pfd_max);
  61         base->pfd_max = 0;
  62         debug_return_int(-1);
  63     }
  64     for (i = 0; i < base->pfd_max; i++) {
  65         base->pfds[i].fd = -1;
  66     }
  67
  68     debug_return_int(0);
  69 }
  70
  71 void
  72 sudo_ev_base_free_impl(struct sudo_event_base *base)
  73 {
  74     debug_decl(sudo_ev_base_free_impl, SUDO_DEBUG_EVENT)
  75     free(base->pfds);
  76     debug_return;
  77 }
  78
  79 int
  80 sudo_ev_add_impl(struct sudo_event_base *base, struct sudo_event *ev)
  81 {
  82     struct pollfd *pfd;
  83     debug_decl(sudo_ev_add_impl, SUDO_DEBUG_EVENT)
  84
  85     /* If out of space in pfds array, realloc. */
  86     if (base->pfd_free == base->pfd_max) {
  87         struct pollfd *pfds;
  88         int i;
  89
  90         pfds =
  91             reallocarray(base->pfds, base->pfd_max, 2 * sizeof(struct pollfd));
  92         if (pfds == NULL) {
  93             sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO,
  94                 "%s: unable to allocate %d pollfds", __func__, base->pfd_max * 2);
  95             debug_return_int(-1);
  96         }
  97         base->pfds = pfds;
  98         base->pfd_max *= 2;
  99         for (i = base->pfd_free; i < base->pfd_max; i++) {
 100             base->pfds[i].fd = -1;
 101         }
 102     }
 103
 104     /* Fill in pfd entry. */
 105     ev->pfd_idx = base->pfd_free;
 106     pfd = &base->pfds[ev->pfd_idx];
 107     pfd->fd = ev->fd;
 108     pfd->events = 0;
 109     if (ISSET(ev->events, SUDO_EV_READ))
 110         pfd->events |= POLLIN;
 111     if (ISSET(ev->events, SUDO_EV_WRITE))
 112         pfd->events |= POLLOUT;
 113
 114     /* Update pfd_high and pfd_free. */
 115     if (ev->pfd_idx > base->pfd_high)
 116         base->pfd_high = ev->pfd_idx;
 117     for (;;) {
 118         if (++base->pfd_free == base->pfd_max)
 119             break;
 120         if (base->pfds[base->pfd_free].fd == -1)
 121             break;
 122     }
 123
 124     debug_return_int(0);
 125 }
 126
 127 int
 128 sudo_ev_del_impl(struct sudo_event_base *base, struct sudo_event *ev)
 129 {
 130     debug_decl(sudo_ev_del_impl, SUDO_DEBUG_EVENT)
 131
 132     /* Mark pfd entry unused, add to free list and adjust high slot. */
 133     base->pfds[ev->pfd_idx].fd = -1;
 134     if (ev->pfd_idx < base->pfd_free)
 135         base->pfd_free = ev->pfd_idx;
 136     while (base->pfd_high >= 0 && base->pfds[base->pfd_high].fd == -1)
 137         base->pfd_high--;
 138
 139     debug_return_int(0);
 140 }
 141
 142 #ifdef HAVE_PPOLL
 143 static int
 144 sudo_ev_poll(struct pollfd *fds, nfds_t nfds, const struct timespec *timo)
 145 {
 146     return ppoll(fds, nfds, timo, NULL);
 147 }
 148 #else
 149 static int
 150 sudo_ev_poll(struct pollfd *fds, nfds_t nfds, const struct timespec *timo)
 151 {
 152     const int timeout =
 153         timo ? (timo->tv_sec * 1000) + (timo->tv_nsec / 1000000) : -1;
 154
 155     return poll(fds, nfds, timeout);
 156 }
 157 #endif /* HAVE_PPOLL */
 158
 159 int
 160 sudo_ev_scan_impl(struct sudo_event_base *base, int flags)
 161 {
 162     struct timespec now, ts, *timeout;
 163     struct sudo_event *ev;
 164     int nready;
 165     debug_decl(sudo_ev_scan_impl, SUDO_DEBUG_EVENT)
 166
 167     if ((ev = TAILQ_FIRST(&base->timeouts)) != NULL) {
 168         sudo_gettime_mono(&now);
 169         sudo_timespecsub(&ev->timeout, &now, &ts);
 170         if (ts.tv_sec < 0)
 171             sudo_timespecclear(&ts);
 172         timeout = &ts;
 173     } else {
 174         if (ISSET(flags, SUDO_EVLOOP_NONBLOCK)) {
 175             sudo_timespecclear(&ts);
 176             timeout = &ts;
 177         } else {
 178             timeout = NULL;
 179         }
 180     }
 181
 182     nready = sudo_ev_poll(base->pfds, base->pfd_high + 1, timeout);
 183     sudo_debug_printf(SUDO_DEBUG_INFO, "%s: %d fds ready", __func__, nready);
 184     switch (nready) {
 185     case -1:
 186         /* Error or interrupted by signal. */
 187         debug_return_int(-1);
 188     case 0:
 189         /* Front end will activate timeout events. */
 190         break;
 191     default:
 192         /* Activate each I/O event that fired. */
 193         TAILQ_FOREACH(ev, &base->events, entries) {
 194             if (ev->pfd_idx != -1 && base->pfds[ev->pfd_idx].revents) {
 195                 int what = 0;
 196                 if (base->pfds[ev->pfd_idx].revents & (POLLIN|POLLHUP|POLLNVAL|POLLERR))
 197                     what |= (ev->events & SUDO_EV_READ);
 198                 if (base->pfds[ev->pfd_idx].revents & (POLLOUT|POLLHUP|POLLNVAL|POLLERR))
 199                     what |= (ev->events & SUDO_EV_WRITE);
 200                 /* Make event active. */
 201                 sudo_debug_printf(SUDO_DEBUG_DEBUG,
 202                     "%s: polled fd %d, events %d, activating %p",
 203                     __func__, ev->fd, what, ev);
 204                 ev->revents = what;
 205                 sudo_ev_activate(base, ev);
 206             }
 207         }
 208         break;
 209     }
 210     debug_return_int(nready);
 211 }