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