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)) {
 127                         flags |= EVENT_FD_READ;
 128                         FD_CLR(fde->fd, read_fds);
 129                         (*selrtn)--;
 130                 }
 131                 if (FD_ISSET(fde->fd, write_fds)) {
 132                         flags |= EVENT_FD_WRITE;
 133                         FD_CLR(fde->fd, write_fds);
 134                         (*selrtn)--;
 135                 }
 136
 137                 if (flags & fde->flags) {
 138                         fde->handler(ev, fde, flags, fde->private_data);
 139                         return true;
 140                 }
 141         }
 142
 143         return false;
 144 }
 145
 146
 147 struct timeval *get_timed_events_timeout(struct tevent_context *ev,
 148                                          struct timeval *to_ret)
 149 {
 150         struct timeval now;
 151
 152         if ((ev->timer_events == NULL) && (ev->immediate_events == NULL)) {
 153                 return NULL;
 154         }
 155         if (ev->immediate_events != NULL) {
 156                 *to_ret = timeval_zero();
 157                 return to_ret;
 158         }
 159
 160         now = timeval_current();
 161         *to_ret = timeval_until(&now, &ev->timer_events->next_event);
 162
 163         DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret->tv_sec,
 164                 (int)to_ret->tv_usec));
 165
 166         return to_ret;
 167 }
 168
 169 static int s3_event_loop_once(struct tevent_context *ev, const char *location)
 170 {
 171         struct timeval to;
 172         fd_set r_fds, w_fds;
 173         int maxfd = 0;
 174         int ret = 0;
 175
 176         FD_ZERO(&r_fds);
 177         FD_ZERO(&w_fds);
 178
 179         to.tv_sec = 9999;       /* Max timeout */
 180         to.tv_usec = 0;
 181
 182         if (run_events(ev, &ret, NULL, NULL)) {
 183                 return 0;
 184         }
 185
 186         if (!event_add_to_select_args(ev, &r_fds, &w_fds, &to, &maxfd)) {
 187                 return -1;
 188         }
 189
 190         ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
 191
 192         if (ret == -1 && errno != EINTR) {
 193                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
 194                              "sys_select() failed: %d:%s\n",
 195                              errno, strerror(errno));
 196                 return -1;
 197         }
 198
 199         run_events(ev, &ret, &r_fds, &w_fds);
 200         return 0;
 201 }
 202
 203 static int s3_event_context_init(struct tevent_context *ev)
 204 {
 205         return 0;
 206 }
 207
 208 void dump_event_list(struct tevent_context *ev)
 209 {
 210         struct tevent_timer *te;
 211         struct tevent_fd *fe;
 212         struct timeval evt, now;
 213
 214         if (!ev) {
 215                 return;
 216         }
 217
 218         now = timeval_current();
 219
 220         DEBUG(10,("dump_event_list:\n"));
 221
 222         for (te = ev->timer_events; te; te = te->next) {
 223
 224                 evt = timeval_until(&now, &te->next_event);
 225
 226                 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
 227                            te->handler_name,
 228                            te,
 229                            (int)evt.tv_sec,
 230                            http_timestring(talloc_tos(), te->next_event.tv_sec)));
 231         }
 232
 233         for (fe = ev->fd_events; fe; fe = fe->next) {
 234
 235                 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
 236                            fe->fd,
 237                            fe,
 238                            fe->flags));
 239         }
 240 }
 241
 242 static const struct tevent_ops s3_event_ops = {
 243         .context_init           = s3_event_context_init,
 244         .add_fd                 = tevent_common_add_fd,
 245         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 246         .get_fd_flags           = tevent_common_fd_get_flags,
 247         .set_fd_flags           = tevent_common_fd_set_flags,
 248         .add_timer              = tevent_common_add_timer,
 249         .schedule_immediate     = tevent_common_schedule_immediate,
 250         .add_signal             = tevent_common_add_signal,
 251         .loop_once              = s3_event_loop_once,
 252         .loop_wait              = tevent_common_loop_wait,
 253 };
 254
 255 static bool s3_tevent_init(void)
 256 {
 257         static bool initialized;
 258         if (initialized) {
 259                 return true;
 260         }
 261         initialized = tevent_register_backend("s3", &s3_event_ops);
 262         tevent_set_default_backend("s3");
 263         return initialized;
 264 }
 265
 266 /*
 267   this is used to catch debug messages from events
 268 */
 269 static void s3_event_debug(void *context, enum tevent_debug_level level,
 270                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
 271
 272 static void s3_event_debug(void *context, enum tevent_debug_level level,
 273                            const char *fmt, va_list ap)
 274 {
 275         int samba_level = -1;
 276         char *s = NULL;
 277         switch (level) {
 278         case TEVENT_DEBUG_FATAL:
 279                 samba_level = 0;
 280                 break;
 281         case TEVENT_DEBUG_ERROR:
 282                 samba_level = 1;
 283                 break;
 284         case TEVENT_DEBUG_WARNING:
 285                 samba_level = 2;
 286                 break;
 287         case TEVENT_DEBUG_TRACE:
 288                 samba_level = 11;
 289                 break;
 290
 291         };
 292         if (vasprintf(&s, fmt, ap) == -1) {
 293                 return;
 294         }
 295         DEBUG(samba_level, ("s3_event: %s", s));
 296         free(s);
 297 }
 298
 299 struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
 300 {
 301         struct tevent_context *ev;
 302
 303         s3_tevent_init();
 304
 305         ev = tevent_context_init_byname(mem_ctx, "s3");
 306         if (ev) {
 307                 tevent_set_debug(ev, s3_event_debug, NULL);
 308         }
 309
 310         return ev;
 311 }
 312