lib/tevent/tevent_select.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    main select loop and event handling
   4    Copyright (C) Andrew Tridgell        2003-2005
   5    Copyright (C) Stefan Metzmacher      2005-2009
   6
   7      ** NOTE! The following LGPL license applies to the tevent
   8      ** library. This does NOT imply that all of Samba is released
   9      ** under the LGPL
  10
  11    This library is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU Lesser General Public
  13    License as published by the Free Software Foundation; either
  14    version 3 of the License, or (at your option) any later version.
  15
  16    This library is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    Lesser General Public License for more details.
  20
  21    You should have received a copy of the GNU Lesser General Public
  22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "replace.h"
  26 #include "system/filesys.h"
  27 #include "system/select.h"
  28 #include "tevent.h"
  29 #include "tevent_util.h"
  30 #include "tevent_internal.h"
  31
  32 struct select_event_context {
  33         /* a pointer back to the generic event_context */
  34         struct tevent_context *ev;
  35
  36         /* the maximum file descriptor number in fd_events */
  37         int maxfd;
  38
  39         /* information for exiting from the event loop */
  40         int exit_code;
  41 };
  42
  43 /*
  44   create a select_event_context structure.
  45 */
  46 static int select_event_context_init(struct tevent_context *ev)
  47 {
  48         struct select_event_context *select_ev;
  49
  50         select_ev = talloc_zero(ev, struct select_event_context);
  51         if (!select_ev) return -1;
  52         select_ev->ev = ev;
  53
  54         ev->additional_data = select_ev;
  55         return 0;
  56 }
  57
  58 /*
  59   recalculate the maxfd
  60 */
  61 static void calc_maxfd(struct select_event_context *select_ev)
  62 {
  63         struct tevent_fd *fde;
  64
  65         select_ev->maxfd = 0;
  66         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
  67                 if (fde->fd > select_ev->maxfd) {
  68                         select_ev->maxfd = fde->fd;
  69                 }
  70         }
  71 }
  72
  73
  74 /* to mark the ev->maxfd invalid
  75  * this means we need to recalculate it
  76  */
  77 #define EVENT_INVALID_MAXFD (-1)
  78
  79 /*
  80   destroy an fd_event
  81 */
  82 static int select_event_fd_destructor(struct tevent_fd *fde)
  83 {
  84         struct tevent_context *ev = fde->event_ctx;
  85         struct select_event_context *select_ev = NULL;
  86
  87         if (ev) {
  88                 select_ev = talloc_get_type(ev->additional_data,
  89                                             struct select_event_context);
  90
  91                 if (select_ev->maxfd == fde->fd) {
  92                         select_ev->maxfd = EVENT_INVALID_MAXFD;
  93                 }
  94         }
  95
  96         return tevent_common_fd_destructor(fde);
  97 }
  98
  99 /*
 100   add a fd based event
 101   return NULL on failure (memory allocation error)
 102 */
 103 static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
 104                                              int fd, uint16_t flags,
 105                                              tevent_fd_handler_t handler,
 106                                              void *private_data,
 107                                              const char *handler_name,
 108                                              const char *location)
 109 {
 110         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 111                                                            struct select_event_context);
 112         struct tevent_fd *fde;
 113
 114         if (fd < 0 || fd >= FD_SETSIZE) {
 115                 errno = EBADF;
 116                 return NULL;
 117         }
 118
 119         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
 120                                    handler, private_data,
 121                                    handler_name, location);
 122         if (!fde) return NULL;
 123
 124         if ((select_ev->maxfd != EVENT_INVALID_MAXFD)
 125             && (fde->fd > select_ev->maxfd)) {
 126                 select_ev->maxfd = fde->fd;
 127         }
 128         talloc_set_destructor(fde, select_event_fd_destructor);
 129
 130         return fde;
 131 }
 132
 133 /*
 134   event loop handling using select()
 135 */
 136 static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
 137 {
 138         fd_set r_fds, w_fds;
 139         struct tevent_fd *fde;
 140         int selrtn;
 141
 142         /* we maybe need to recalculate the maxfd */
 143         if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
 144                 calc_maxfd(select_ev);
 145         }
 146
 147         FD_ZERO(&r_fds);
 148         FD_ZERO(&w_fds);
 149
 150         /* setup any fd events */
 151         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
 152                 if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
 153                         errno = EBADF;
 154                         return -1;
 155                 }
 156
 157                 if (fde->flags & TEVENT_FD_READ) {
 158                         FD_SET(fde->fd, &r_fds);
 159                 }
 160                 if (fde->flags & TEVENT_FD_WRITE) {
 161                         FD_SET(fde->fd, &w_fds);
 162                 }
 163         }
 164
 165         if (select_ev->ev->signal_events &&
 166             tevent_common_check_signal(select_ev->ev)) {
 167                 return 0;
 168         }
 169
 170         tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
 171         selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
 172         tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_AFTER_WAIT);
 173
 174         if (selrtn == -1 && errno == EINTR &&
 175             select_ev->ev->signal_events) {
 176                 tevent_common_check_signal(select_ev->ev);
 177                 return 0;
 178         }
 179
 180         if (selrtn == -1 && errno == EBADF) {
 181                 /* the socket is dead! this should never
 182                    happen as the socket should have first been
 183                    made readable and that should have removed
 184                    the event, so this must be a bug. This is a
 185                    fatal error. */
 186                 tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
 187                              "ERROR: EBADF on select_event_loop_once\n");
 188                 select_ev->exit_code = EBADF;
 189                 return -1;
 190         }
 191
 192         if (selrtn == 0 && tvalp) {
 193                 /* we don't care about a possible delay here */
 194                 tevent_common_loop_timer_delay(select_ev->ev);
 195                 return 0;
 196         }
 197
 198         if (selrtn > 0) {
 199                 /* at least one file descriptor is ready - check
 200                    which ones and call the handler, being careful to allow
 201                    the handler to remove itself when called */
 202                 for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
 203                         uint16_t flags = 0;
 204
 205                         if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
 206                         if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
 207                         if (flags) {
 208                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
 209                                 break;
 210                         }
 211                 }
 212         }
 213
 214         return 0;
 215 }
 216
 217 /*
 218   do a single event loop using the events defined in ev
 219 */
 220 static int select_event_loop_once(struct tevent_context *ev, const char *location)
 221 {
 222         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 223                                                            struct select_event_context);
 224         struct timeval tval;
 225
 226         if (ev->signal_events &&
 227             tevent_common_check_signal(ev)) {
 228                 return 0;
 229         }
 230
 231         if (ev->immediate_events &&
 232             tevent_common_loop_immediate(ev)) {
 233                 return 0;
 234         }
 235
 236         tval = tevent_common_loop_timer_delay(ev);
 237         if (tevent_timeval_is_zero(&tval)) {
 238                 return 0;
 239         }
 240
 241         return select_event_loop_select(select_ev, &tval);
 242 }
 243
 244 static const struct tevent_ops select_event_ops = {
 245         .context_init           = select_event_context_init,
 246         .add_fd                 = select_event_add_fd,
 247         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 248         .get_fd_flags           = tevent_common_fd_get_flags,
 249         .set_fd_flags           = tevent_common_fd_set_flags,
 250         .add_timer              = tevent_common_add_timer,
 251         .schedule_immediate     = tevent_common_schedule_immediate,
 252         .add_signal             = tevent_common_add_signal,
 253         .loop_once              = select_event_loop_once,
 254         .loop_wait              = tevent_common_loop_wait,
 255 };
 256
 257 _PRIVATE_ bool tevent_select_init(void)
 258 {
 259         return tevent_register_backend("select", &select_event_ops);
 260 }