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         }
 110
 111         return 0;
 112 }
 113
 114 /*
 115   add a fd based event
 116   return NULL on failure (memory allocation error)
 117 */
 118 static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
 119                                              int fd, uint16_t flags,
 120                                              tevent_fd_handler_t handler,
 121                                              void *private_data,
 122                                              const char *handler_name,
 123                                              const char *location)
 124 {
 125         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 126                                                            struct select_event_context);
 127         struct tevent_fd *fde;
 128
 129         fde = talloc(mem_ctx?mem_ctx:ev, struct tevent_fd);
 130         if (!fde) return NULL;
 131
 132         fde->event_ctx          = ev;
 133         fde->fd                 = fd;
 134         fde->flags              = flags;
 135         fde->handler            = handler;
 136         fde->close_fn           = NULL;
 137         fde->private_data       = private_data;
 138         fde->handler_name       = handler_name;
 139         fde->location           = location;
 140         fde->additional_flags   = 0;
 141         fde->additional_data    = NULL;
 142
 143         DLIST_ADD(select_ev->fd_events, fde);
 144         if (fde->fd > select_ev->maxfd) {
 145                 select_ev->maxfd = fde->fd;
 146         }
 147         talloc_set_destructor(fde, select_event_fd_destructor);
 148
 149         return fde;
 150 }
 151
 152 /*
 153   event loop handling using select()
 154 */
 155 static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
 156 {
 157         fd_set r_fds, w_fds;
 158         struct tevent_fd *fde;
 159         int selrtn;
 160         uint32_t destruction_count = ++select_ev->destruction_count;
 161
 162         /* we maybe need to recalculate the maxfd */
 163         if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
 164                 calc_maxfd(select_ev);
 165         }
 166
 167         FD_ZERO(&r_fds);
 168         FD_ZERO(&w_fds);
 169
 170         /* setup any fd events */
 171         for (fde = select_ev->fd_events; fde; fde = fde->next) {
 172                 if (fde->flags & TEVENT_FD_READ) {
 173                         FD_SET(fde->fd, &r_fds);
 174                 }
 175                 if (fde->flags & TEVENT_FD_WRITE) {
 176                         FD_SET(fde->fd, &w_fds);
 177                 }
 178         }
 179
 180         if (select_ev->ev->signal_events &&
 181             tevent_common_check_signal(select_ev->ev)) {
 182                 return 0;
 183         }
 184
 185         selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
 186
 187         if (selrtn == -1 && errno == EINTR &&
 188             select_ev->ev->signal_events) {
 189                 tevent_common_check_signal(select_ev->ev);
 190                 return 0;
 191         }
 192
 193         if (selrtn == -1 && errno == EBADF) {
 194                 /* the socket is dead! this should never
 195                    happen as the socket should have first been
 196                    made readable and that should have removed
 197                    the event, so this must be a bug. This is a
 198                    fatal error. */
 199                 tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
 200                              "ERROR: EBADF on select_event_loop_once\n");
 201                 select_ev->exit_code = EBADF;
 202                 return -1;
 203         }
 204
 205         if (selrtn == 0 && tvalp) {
 206                 /* we don't care about a possible delay here */
 207                 tevent_common_loop_timer_delay(select_ev->ev);
 208                 return 0;
 209         }
 210
 211         if (selrtn > 0) {
 212                 /* at least one file descriptor is ready - check
 213                    which ones and call the handler, being careful to allow
 214                    the handler to remove itself when called */
 215                 for (fde = select_ev->fd_events; fde; fde = fde->next) {
 216                         uint16_t flags = 0;
 217
 218                         if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
 219                         if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
 220                         if (flags) {
 221                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
 222                                 if (destruction_count != select_ev->destruction_count) {
 223                                         break;
 224                                 }
 225                         }
 226                 }
 227         }
 228
 229         return 0;
 230 }
 231
 232 /*
 233   do a single event loop using the events defined in ev
 234 */
 235 static int select_event_loop_once(struct tevent_context *ev)
 236 {
 237         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 238                                                            struct select_event_context);
 239         struct timeval tval;
 240
 241         tval = tevent_common_loop_timer_delay(ev);
 242         if (ev_timeval_is_zero(&tval)) {
 243                 return 0;
 244         }
 245
 246         return select_event_loop_select(select_ev, &tval);
 247 }
 248
 249 /*
 250   return on failure or (with 0) if all fd events are removed
 251 */
 252 static int select_event_loop_wait(struct tevent_context *ev)
 253 {
 254         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 255                                                            struct select_event_context);
 256         select_ev->exit_code = 0;
 257
 258         while (select_ev->fd_events && select_ev->exit_code == 0) {
 259                 if (select_event_loop_once(ev) != 0) {
 260                         break;
 261                 }
 262         }
 263
 264         return select_ev->exit_code;
 265 }
 266
 267 static const struct tevent_ops select_event_ops = {
 268         .context_init   = select_event_context_init,
 269         .add_fd         = select_event_add_fd,
 270         .set_fd_close_fn= tevent_common_fd_set_close_fn,
 271         .get_fd_flags   = tevent_common_fd_get_flags,
 272         .set_fd_flags   = tevent_common_fd_set_flags,
 273         .add_timer      = tevent_common_add_timer,
 274         .add_signal     = tevent_common_add_signal,
 275         .loop_once      = select_event_loop_once,
 276         .loop_wait      = select_event_loop_wait,
 277 };
 278
 279 bool tevent_select_init(void)
 280 {
 281         return tevent_register_backend("select", &select_event_ops);
 282 }