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
  24 void event_fd_set_writeable(struct tevent_fd *fde)
  25 {
  26         TEVENT_FD_WRITEABLE(fde);
  27 }
  28
  29 void event_fd_set_not_writeable(struct tevent_fd *fde)
  30 {
  31         TEVENT_FD_NOT_WRITEABLE(fde);
  32 }
  33
  34 void event_fd_set_readable(struct tevent_fd *fde)
  35 {
  36         TEVENT_FD_READABLE(fde);
  37 }
  38
  39 void event_fd_set_not_readable(struct tevent_fd *fde)
  40 {
  41         TEVENT_FD_NOT_READABLE(fde);
  42 }
  43
  44 /*
  45  * Return if there's something in the queue
  46  */
  47
  48 bool event_add_to_select_args(struct tevent_context *ev,
  49                               const struct timeval *now,
  50                               fd_set *read_fds, fd_set *write_fds,
  51                               struct timeval *timeout, int *maxfd)
  52 {
  53         struct tevent_fd *fde;
  54         struct timeval diff;
  55         bool ret = false;
  56
  57         for (fde = ev->fd_events; fde; fde = fde->next) {
  58                 if (fde->flags & EVENT_FD_READ) {
  59                         FD_SET(fde->fd, read_fds);
  60                         ret = true;
  61                 }
  62                 if (fde->flags & EVENT_FD_WRITE) {
  63                         FD_SET(fde->fd, write_fds);
  64                         ret = true;
  65                 }
  66
  67                 if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
  68                     && (fde->fd > *maxfd)) {
  69                         *maxfd = fde->fd;
  70                 }
  71         }
  72
  73         if (ev->immediate_events != NULL) {
  74                 *timeout = timeval_zero();
  75                 return true;
  76         }
  77
  78         if (ev->timer_events == NULL) {
  79                 return ret;
  80         }
  81
  82         diff = timeval_until(now, &ev->timer_events->next_event);
  83         *timeout = timeval_min(timeout, &diff);
  84
  85         return true;
  86 }
  87
  88 bool run_events(struct tevent_context *ev,
  89                 int selrtn, fd_set *read_fds, fd_set *write_fds)
  90 {
  91         struct tevent_fd *fde;
  92         struct timeval now;
  93
  94         if (ev->signal_events &&
  95             tevent_common_check_signal(ev)) {
  96                 return true;
  97         }
  98
  99         if (ev->immediate_events &&
 100             tevent_common_loop_immediate(ev)) {
 101                 return true;
 102         }
 103
 104         GetTimeOfDay(&now);
 105
 106         if ((ev->timer_events != NULL)
 107             && (timeval_compare(&now, &ev->timer_events->next_event) >= 0)) {
 108
 109                 DEBUG(10, ("Running timed event \"%s\" %p\n",
 110                            ev->timer_events->handler_name, ev->timer_events));
 111
 112                 ev->timer_events->handler(ev, ev->timer_events, now,
 113                                           ev->timer_events->private_data);
 114                 return true;
 115         }
 116
 117         if (selrtn == 0) {
 118                 /*
 119                  * No fd ready
 120                  */
 121                 return false;
 122         }
 123
 124         for (fde = ev->fd_events; fde; fde = fde->next) {
 125                 uint16 flags = 0;
 126
 127                 if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
 128                 if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
 129
 130                 if (flags & fde->flags) {
 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 now, 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         GetTimeOfDay(&now);
 180
 181         if (!event_add_to_select_args(ev, &now, &r_fds, &w_fds, &to, &maxfd)) {
 182                 return -1;
 183         }
 184
 185         ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
 186
 187         if (ret == -1 && errno != EINTR) {
 188                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
 189                              "sys_select() failed: %d:%s\n",
 190                              errno, strerror(errno));
 191                 return -1;
 192         }
 193
 194         run_events(ev, ret, &r_fds, &w_fds);
 195         return 0;
 196 }
 197
 198 void event_context_reinit(struct tevent_context *ev)
 199 {
 200         tevent_common_context_destructor(ev);
 201         return;
 202 }
 203
 204 static int s3_event_context_init(struct tevent_context *ev)
 205 {
 206         return 0;
 207 }
 208
 209 void dump_event_list(struct tevent_context *ev)
 210 {
 211         struct tevent_timer *te;
 212         struct tevent_fd *fe;
 213         struct timeval evt, now;
 214
 215         if (!ev) {
 216                 return;
 217         }
 218
 219         now = timeval_current();
 220
 221         DEBUG(10,("dump_event_list:\n"));
 222
 223         for (te = ev->timer_events; te; te = te->next) {
 224
 225                 evt = timeval_until(&now, &te->next_event);
 226
 227                 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
 228                            te->handler_name,
 229                            te,
 230                            (int)evt.tv_sec,
 231                            http_timestring(talloc_tos(), te->next_event.tv_sec)));
 232         }
 233
 234         for (fe = ev->fd_events; fe; fe = fe->next) {
 235
 236                 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
 237                            fe->fd,
 238                            fe,
 239                            fe->flags));
 240         }
 241 }
 242
 243 static const struct tevent_ops s3_event_ops = {
 244         .context_init           = s3_event_context_init,
 245         .add_fd                 = tevent_common_add_fd,
 246         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 247         .get_fd_flags           = tevent_common_fd_get_flags,
 248         .set_fd_flags           = tevent_common_fd_set_flags,
 249         .add_timer              = tevent_common_add_timer,
 250         .schedule_immediate     = tevent_common_schedule_immediate,
 251         .add_signal             = tevent_common_add_signal,
 252         .loop_once              = s3_event_loop_once,
 253         .loop_wait              = tevent_common_loop_wait,
 254 };
 255
 256 static bool s3_tevent_init(void)
 257 {
 258         static bool initialized;
 259         if (initialized) {
 260                 return true;
 261         }
 262         initialized = tevent_register_backend("s3", &s3_event_ops);
 263         tevent_set_default_backend("s3");
 264         return initialized;
 265 }
 266
 267 /*
 268   this is used to catch debug messages from events
 269 */
 270 static void s3_event_debug(void *context, enum tevent_debug_level level,
 271                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
 272
 273 static void s3_event_debug(void *context, enum tevent_debug_level level,
 274                            const char *fmt, va_list ap)
 275 {
 276         int samba_level = -1;
 277         char *s = NULL;
 278         switch (level) {
 279         case TEVENT_DEBUG_FATAL:
 280                 samba_level = 0;
 281                 break;
 282         case TEVENT_DEBUG_ERROR:
 283                 samba_level = 1;
 284                 break;
 285         case TEVENT_DEBUG_WARNING:
 286                 samba_level = 2;
 287                 break;
 288         case TEVENT_DEBUG_TRACE:
 289                 samba_level = 11;
 290                 break;
 291
 292         };
 293         if (vasprintf(&s, fmt, ap) == -1) {
 294                 return;
 295         }
 296         DEBUG(samba_level, ("s3_event: %s", s));
 297         free(s);
 298 }
 299
 300 struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
 301 {
 302         struct tevent_context *ev;
 303
 304         s3_tevent_init();
 305
 306         ev = tevent_context_init_byname(mem_ctx, "s3");
 307         if (ev) {
 308                 tevent_set_debug(ev, s3_event_debug, NULL);
 309         }
 310
 311         return ev;
 312 }
 313