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         /*
  51          * We might be called during tevent_re_initialise()
  52          * which means we need to free our old additional_data.
  53          */
  54         TALLOC_FREE(ev->additional_data);
  55
  56         select_ev = talloc_zero(ev, struct select_event_context);
  57         if (!select_ev) return -1;
  58         select_ev->ev = ev;
  59
  60         ev->additional_data = select_ev;
  61         return 0;
  62 }
  63
  64 /*
  65   recalculate the maxfd
  66 */
  67 static void calc_maxfd(struct select_event_context *select_ev)
  68 {
  69         struct tevent_fd *fde;
  70
  71         select_ev->maxfd = 0;
  72         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
  73                 if (fde->fd > select_ev->maxfd) {
  74                         select_ev->maxfd = fde->fd;
  75                 }
  76         }
  77 }
  78
  79
  80 /* to mark the ev->maxfd invalid
  81  * this means we need to recalculate it
  82  */
  83 #define EVENT_INVALID_MAXFD (-1)
  84
  85 /*
  86   destroy an fd_event
  87 */
  88 static int select_event_fd_destructor(struct tevent_fd *fde)
  89 {
  90         struct tevent_context *ev = fde->event_ctx;
  91         struct select_event_context *select_ev = NULL;
  92
  93         if (ev) {
  94                 select_ev = talloc_get_type(ev->additional_data,
  95                                             struct select_event_context);
  96
  97                 if (select_ev->maxfd == fde->fd) {
  98                         select_ev->maxfd = EVENT_INVALID_MAXFD;
  99                 }
 100         }
 101
 102         return tevent_common_fd_destructor(fde);
 103 }
 104
 105 /*
 106   add a fd based event
 107   return NULL on failure (memory allocation error)
 108 */
 109 static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
 110                                              int fd, uint16_t flags,
 111                                              tevent_fd_handler_t handler,
 112                                              void *private_data,
 113                                              const char *handler_name,
 114                                              const char *location)
 115 {
 116         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 117                                                            struct select_event_context);
 118         struct tevent_fd *fde;
 119
 120         if (fd < 0 || fd >= FD_SETSIZE) {
 121                 errno = EBADF;
 122                 return NULL;
 123         }
 124
 125         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
 126                                    handler, private_data,
 127                                    handler_name, location);
 128         if (!fde) return NULL;
 129
 130         if ((select_ev->maxfd != EVENT_INVALID_MAXFD)
 131             && (fde->fd > select_ev->maxfd)) {
 132                 select_ev->maxfd = fde->fd;
 133         }
 134         talloc_set_destructor(fde, select_event_fd_destructor);
 135
 136         return fde;
 137 }
 138
 139 /*
 140   event loop handling using select()
 141 */
 142 static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
 143 {
 144         fd_set r_fds, w_fds;
 145         struct tevent_fd *fde;
 146         int selrtn;
 147
 148         /* we maybe need to recalculate the maxfd */
 149         if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
 150                 calc_maxfd(select_ev);
 151         }
 152
 153         FD_ZERO(&r_fds);
 154         FD_ZERO(&w_fds);
 155
 156         /* setup any fd events */
 157         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
 158                 if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
 159                         errno = EBADF;
 160                         return -1;
 161                 }
 162
 163                 if (fde->flags & TEVENT_FD_READ) {
 164                         FD_SET(fde->fd, &r_fds);
 165                 }
 166                 if (fde->flags & TEVENT_FD_WRITE) {
 167                         FD_SET(fde->fd, &w_fds);
 168                 }
 169         }
 170
 171         if (select_ev->ev->signal_events &&
 172             tevent_common_check_signal(select_ev->ev)) {
 173                 return 0;
 174         }
 175
 176         tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
 177         selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
 178         tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_AFTER_WAIT);
 179
 180         if (selrtn == -1 && errno == EINTR &&
 181             select_ev->ev->signal_events) {
 182                 tevent_common_check_signal(select_ev->ev);
 183                 return 0;
 184         }
 185
 186         if (selrtn == -1 && errno == EBADF) {
 187                 /* the socket is dead! this should never
 188                    happen as the socket should have first been
 189                    made readable and that should have removed
 190                    the event, so this must be a bug. This is a
 191                    fatal error. */
 192                 tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
 193                              "ERROR: EBADF on select_event_loop_once\n");
 194                 select_ev->exit_code = EBADF;
 195                 return -1;
 196         }
 197
 198         if (selrtn == 0 && tvalp) {
 199                 /* we don't care about a possible delay here */
 200                 tevent_common_loop_timer_delay(select_ev->ev);
 201                 return 0;
 202         }
 203
 204         if (selrtn > 0) {
 205                 /* at least one file descriptor is ready - check
 206                    which ones and call the handler, being careful to allow
 207                    the handler to remove itself when called */
 208                 for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
 209                         uint16_t flags = 0;
 210
 211                         if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
 212                         if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
 213                         if (flags) {
 214                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
 215                                 break;
 216                         }
 217                 }
 218         }
 219
 220         return 0;
 221 }
 222
 223 /*
 224   do a single event loop using the events defined in ev
 225 */
 226 static int select_event_loop_once(struct tevent_context *ev, const char *location)
 227 {
 228         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 229                                                            struct select_event_context);
 230         struct timeval tval;
 231
 232         if (ev->signal_events &&
 233             tevent_common_check_signal(ev)) {
 234                 return 0;
 235         }
 236
 237         if (ev->immediate_events &&
 238             tevent_common_loop_immediate(ev)) {
 239                 return 0;
 240         }
 241
 242         tval = tevent_common_loop_timer_delay(ev);
 243         if (tevent_timeval_is_zero(&tval)) {
 244                 return 0;
 245         }
 246
 247         return select_event_loop_select(select_ev, &tval);
 248 }
 249
 250 static const struct tevent_ops select_event_ops = {
 251         .context_init           = select_event_context_init,
 252         .add_fd                 = select_event_add_fd,
 253         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 254         .get_fd_flags           = tevent_common_fd_get_flags,
 255         .set_fd_flags           = tevent_common_fd_set_flags,
 256         .add_timer              = tevent_common_add_timer,
 257         .schedule_immediate     = tevent_common_schedule_immediate,
 258         .add_signal             = tevent_common_add_signal,
 259         .loop_once              = select_event_loop_once,
 260         .loop_wait              = tevent_common_loop_wait,
 261 };
 262
 263 _PRIVATE_ bool tevent_select_init(void)
 264 {
 265         return tevent_register_backend("select", &select_event_ops);
 266 }