source3/lib/events.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Timed event library.
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Volker Lendecke 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 #include "includes.h"
  22 #include <tevent_internal.h>
  23 #include "../lib/util/select.h"
  24
  25 /*
  26  * Return if there's something in the queue
  27  */
  28
  29 bool event_add_to_select_args(struct tevent_context *ev,
  30                               fd_set *read_fds, fd_set *write_fds,
  31                               struct timeval *timeout, int *maxfd)
  32 {
  33         struct timeval now;
  34         struct tevent_fd *fde;
  35         struct timeval diff;
  36         bool ret = false;
  37
  38         for (fde = ev->fd_events; fde; fde = fde->next) {
  39                 if (fde->flags & EVENT_FD_READ) {
  40                         FD_SET(fde->fd, read_fds);
  41                         ret = true;
  42                 }
  43                 if (fde->flags & EVENT_FD_WRITE) {
  44                         FD_SET(fde->fd, write_fds);
  45                         ret = true;
  46                 }
  47
  48                 if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
  49                     && (fde->fd > *maxfd)) {
  50                         *maxfd = fde->fd;
  51                 }
  52         }
  53
  54         if (ev->immediate_events != NULL) {
  55                 *timeout = timeval_zero();
  56                 return true;
  57         }
  58
  59         if (ev->timer_events == NULL) {
  60                 return ret;
  61         }
  62
  63         now = timeval_current();
  64         diff = timeval_until(&now, &ev->timer_events->next_event);
  65         *timeout = timeval_min(timeout, &diff);
  66
  67         return true;
  68 }
  69
  70 bool run_events(struct tevent_context *ev,
  71                 int selrtn, fd_set *read_fds, fd_set *write_fds)
  72 {
  73         struct tevent_fd *fde;
  74         struct timeval now;
  75
  76         if (ev->signal_events &&
  77             tevent_common_check_signal(ev)) {
  78                 return true;
  79         }
  80
  81         if (ev->immediate_events &&
  82             tevent_common_loop_immediate(ev)) {
  83                 return true;
  84         }
  85
  86         GetTimeOfDay(&now);
  87
  88         if ((ev->timer_events != NULL)
  89             && (timeval_compare(&now, &ev->timer_events->next_event) >= 0)) {
  90                 /* this older events system did not auto-free timed
  91                    events on running them, and had a race condition
  92                    where the event could be called twice if the
  93                    talloc_free of the te happened after the callback
  94                    made a call which invoked the event loop. To avoid
  95                    this while still allowing old code which frees the
  96                    te, we need to create a temporary context which
  97                    will be used to ensure the te is freed. We also
  98                    remove the te from the timed event list before we
  99                    call the handler, to ensure we can't loop */
 100
 101                 struct tevent_timer *te = ev->timer_events;
 102                 TALLOC_CTX *tmp_ctx = talloc_new(ev);
 103
 104                 DEBUG(10, ("Running timed event \"%s\" %p\n",
 105                            ev->timer_events->handler_name, ev->timer_events));
 106
 107                 DLIST_REMOVE(ev->timer_events, te);
 108                 talloc_steal(tmp_ctx, te);
 109
 110                 te->handler(ev, te, now, te->private_data);
 111
 112                 talloc_free(tmp_ctx);
 113                 return true;
 114         }
 115
 116         if (selrtn <= 0) {
 117                 /*
 118                  * No fd ready
 119                  */
 120                 return false;
 121         }
 122
 123         for (fde = ev->fd_events; fde; fde = fde->next) {
 124                 uint16 flags = 0;
 125
 126                 if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
 127                 if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
 128
 129                 if (flags & fde->flags) {
 130                         DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd);
 131                         fde->handler(ev, fde, flags, fde->private_data);
 132                         return true;
 133                 }
 134         }
 135
 136         return false;
 137 }
 138
 139
 140 struct timeval *get_timed_events_timeout(struct tevent_context *ev,
 141                                          struct timeval *to_ret)
 142 {
 143         struct timeval now;
 144
 145         if ((ev->timer_events == NULL) && (ev->immediate_events == NULL)) {
 146                 return NULL;
 147         }
 148         if (ev->immediate_events != NULL) {
 149                 *to_ret = timeval_zero();
 150                 return to_ret;
 151         }
 152
 153         now = timeval_current();
 154         *to_ret = timeval_until(&now, &ev->timer_events->next_event);
 155
 156         DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret->tv_sec,
 157                 (int)to_ret->tv_usec));
 158
 159         return to_ret;
 160 }
 161
 162 static int s3_event_loop_once(struct tevent_context *ev, const char *location)
 163 {
 164         struct timeval to;
 165         fd_set r_fds, w_fds;
 166         int maxfd = 0;
 167         int ret;
 168
 169         FD_ZERO(&r_fds);
 170         FD_ZERO(&w_fds);
 171
 172         to.tv_sec = 9999;       /* Max timeout */
 173         to.tv_usec = 0;
 174
 175         if (run_events(ev, 0, NULL, NULL)) {
 176                 return 0;
 177         }
 178
 179         if (!event_add_to_select_args(ev, &r_fds, &w_fds, &to, &maxfd)) {
 180                 return -1;
 181         }
 182
 183         ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
 184
 185         if (ret == -1 && errno != EINTR) {
 186                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
 187                              "sys_select() failed: %d:%s\n",
 188                              errno, strerror(errno));
 189                 return -1;
 190         }
 191
 192         run_events(ev, ret, &r_fds, &w_fds);
 193         return 0;
 194 }
 195
 196 static int s3_event_context_init(struct tevent_context *ev)
 197 {
 198         return 0;
 199 }
 200
 201 void dump_event_list(struct tevent_context *ev)
 202 {
 203         struct tevent_timer *te;
 204         struct tevent_fd *fe;
 205         struct timeval evt, now;
 206
 207         if (!ev) {
 208                 return;
 209         }
 210
 211         now = timeval_current();
 212
 213         DEBUG(10,("dump_event_list:\n"));
 214
 215         for (te = ev->timer_events; te; te = te->next) {
 216
 217                 evt = timeval_until(&now, &te->next_event);
 218
 219                 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
 220                            te->handler_name,
 221                            te,
 222                            (int)evt.tv_sec,
 223                            http_timestring(talloc_tos(), te->next_event.tv_sec)));
 224         }
 225
 226         for (fe = ev->fd_events; fe; fe = fe->next) {
 227
 228                 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
 229                            fe->fd,
 230                            fe,
 231                            fe->flags));
 232         }
 233 }
 234
 235 static const struct tevent_ops s3_event_ops = {
 236         .context_init           = s3_event_context_init,
 237         .add_fd                 = tevent_common_add_fd,
 238         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 239         .get_fd_flags           = tevent_common_fd_get_flags,
 240         .set_fd_flags           = tevent_common_fd_set_flags,
 241         .add_timer              = tevent_common_add_timer,
 242         .schedule_immediate     = tevent_common_schedule_immediate,
 243         .add_signal             = tevent_common_add_signal,
 244         .loop_once              = s3_event_loop_once,
 245         .loop_wait              = tevent_common_loop_wait,
 246 };
 247
 248 static bool s3_tevent_init(void)
 249 {
 250         static bool initialized;
 251         if (initialized) {
 252                 return true;
 253         }
 254         initialized = tevent_register_backend("s3", &s3_event_ops);
 255         tevent_set_default_backend("s3");
 256         return initialized;
 257 }
 258
 259 /*
 260   this is used to catch debug messages from events
 261 */
 262 static void s3_event_debug(void *context, enum tevent_debug_level level,
 263                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
 264
 265 static void s3_event_debug(void *context, enum tevent_debug_level level,
 266                            const char *fmt, va_list ap)
 267 {
 268         int samba_level = -1;
 269         char *s = NULL;
 270         switch (level) {
 271         case TEVENT_DEBUG_FATAL:
 272                 samba_level = 0;
 273                 break;
 274         case TEVENT_DEBUG_ERROR:
 275                 samba_level = 1;
 276                 break;
 277         case TEVENT_DEBUG_WARNING:
 278                 samba_level = 2;
 279                 break;
 280         case TEVENT_DEBUG_TRACE:
 281                 samba_level = 11;
 282                 break;
 283
 284         };
 285         if (vasprintf(&s, fmt, ap) == -1) {
 286                 return;
 287         }
 288         DEBUG(samba_level, ("s3_event: %s", s));
 289         free(s);
 290 }
 291
 292 struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
 293 {
 294         struct tevent_context *ev;
 295
 296         s3_tevent_init();
 297
 298         ev = tevent_context_init_byname(mem_ctx, "s3");
 299         if (ev) {
 300                 tevent_set_debug(ev, s3_event_debug, NULL);
 301         }
 302
 303         return ev;
 304 }
 305