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->timer_events == NULL) {
  74                 return ret;
  75         }
  76
  77         diff = timeval_until(now, &ev->timer_events->next_event);
  78         *timeout = timeval_min(timeout, &diff);
  79
  80         return true;
  81 }
  82
  83 bool run_events(struct tevent_context *ev,
  84                 int selrtn, fd_set *read_fds, fd_set *write_fds)
  85 {
  86         bool fired = false;
  87         struct tevent_fd *fde, *next;
  88
  89         if (ev->signal_events &&
  90             tevent_common_check_signal(ev)) {
  91                 return true;
  92         }
  93
  94         /* Run all events that are pending, not just one (as we
  95            did previously. */
  96
  97         while (ev->timer_events) {
  98                 struct timeval now;
  99                 GetTimeOfDay(&now);
 100
 101                 if (timeval_compare(
 102                             &now, &ev->timer_events->next_event) < 0) {
 103                         /* Nothing to do yet */
 104                         DEBUG(11, ("run_events: Nothing to do\n"));
 105                         break;
 106                 }
 107
 108                 DEBUG(10, ("Running event \"%s\" %p\n",
 109                            ev->timer_events->handler_name,
 110                            ev->timer_events));
 111
 112                 ev->timer_events->handler(
 113                         ev,
 114                         ev->timer_events, now,
 115                         ev->timer_events->private_data);
 116
 117                 fired = true;
 118         }
 119
 120         if (fired) {
 121                 /*
 122                  * We might have changed the socket status during the timed
 123                  * events, return to run select again.
 124                  */
 125                 return true;
 126         }
 127
 128         if (selrtn == 0) {
 129                 /*
 130                  * No fd ready
 131                  */
 132                 return fired;
 133         }
 134
 135         for (fde = ev->fd_events; fde; fde = next) {
 136                 uint16 flags = 0;
 137
 138                 next = fde->next;
 139                 if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
 140                 if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
 141
 142                 if (flags & fde->flags) {
 143                         fde->handler(ev, fde, flags, fde->private_data);
 144                         fired = true;
 145                 }
 146         }
 147
 148         return fired;
 149 }
 150
 151
 152 struct timeval *get_timed_events_timeout(struct tevent_context *ev,
 153                                          struct timeval *to_ret)
 154 {
 155         struct timeval now;
 156
 157         if (ev->timer_events == NULL) {
 158                 return NULL;
 159         }
 160
 161         now = timeval_current();
 162         *to_ret = timeval_until(&now, &ev->timer_events->next_event);
 163
 164         DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret->tv_sec,
 165                 (int)to_ret->tv_usec));
 166
 167         return to_ret;
 168 }
 169
 170 static int s3_event_loop_once(struct tevent_context *ev)
 171 {
 172         struct timeval now, to;
 173         fd_set r_fds, w_fds;
 174         int maxfd = 0;
 175         int ret;
 176
 177         FD_ZERO(&r_fds);
 178         FD_ZERO(&w_fds);
 179
 180         to.tv_sec = 9999;       /* Max timeout */
 181         to.tv_usec = 0;
 182
 183         if (run_events(ev, 0, NULL, NULL)) {
 184                 return 0;
 185         }
 186
 187         GetTimeOfDay(&now);
 188
 189         if (!event_add_to_select_args(ev, &now, &r_fds, &w_fds, &to, &maxfd)) {
 190                 return -1;
 191         }
 192
 193         ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
 194
 195         if (ret == -1 && errno != EINTR) {
 196                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
 197                              "sys_select() failed: %d:%s\n",
 198                              errno, strerror(errno));
 199                 return -1;
 200         }
 201
 202         run_events(ev, ret, &r_fds, &w_fds);
 203         return 0;
 204 }
 205
 206 static int s3_event_loop_wait(struct tevent_context *ev)
 207 {
 208         int ret = 0;
 209
 210         while (ret == 0) {
 211                 ret = s3_event_loop_once(ev);
 212         }
 213
 214         return ret;
 215 }
 216
 217 void event_context_reinit(struct tevent_context *ev)
 218 {
 219         tevent_common_context_destructor(ev);
 220         return;
 221 }
 222
 223 static int s3_event_context_init(struct tevent_context *ev)
 224 {
 225         return 0;
 226 }
 227
 228 void dump_event_list(struct tevent_context *ev)
 229 {
 230         struct tevent_timer *te;
 231         struct tevent_fd *fe;
 232         struct timeval evt, now;
 233
 234         if (!ev) {
 235                 return;
 236         }
 237
 238         now = timeval_current();
 239
 240         DEBUG(10,("dump_event_list:\n"));
 241
 242         for (te = ev->timer_events; te; te = te->next) {
 243
 244                 evt = timeval_until(&now, &te->next_event);
 245
 246                 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
 247                            te->handler_name,
 248                            te,
 249                            (int)evt.tv_sec,
 250                            http_timestring(talloc_tos(), te->next_event.tv_sec)));
 251         }
 252
 253         for (fe = ev->fd_events; fe; fe = fe->next) {
 254
 255                 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
 256                            fe->fd,
 257                            fe,
 258                            fe->flags));
 259         }
 260 }
 261
 262 static const struct tevent_ops s3_event_ops = {
 263         .context_init   = s3_event_context_init,
 264         .add_fd         = tevent_common_add_fd,
 265         .set_fd_close_fn= tevent_common_fd_set_close_fn,
 266         .get_fd_flags   = tevent_common_fd_get_flags,
 267         .set_fd_flags   = tevent_common_fd_set_flags,
 268         .add_timer      = tevent_common_add_timer,
 269         .add_signal     = tevent_common_add_signal,
 270         .loop_once      = s3_event_loop_once,
 271         .loop_wait      = s3_event_loop_wait,
 272 };
 273
 274 static bool s3_tevent_init(void)
 275 {
 276         static bool initialized;
 277         if (initialized) {
 278                 return true;
 279         }
 280         initialized = tevent_register_backend("s3", &s3_event_ops);
 281         tevent_set_default_backend("s3");
 282         return initialized;
 283 }
 284
 285 /*
 286   this is used to catch debug messages from events
 287 */
 288 static void s3_event_debug(void *context, enum tevent_debug_level level,
 289                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
 290
 291 static void s3_event_debug(void *context, enum tevent_debug_level level,
 292                            const char *fmt, va_list ap)
 293 {
 294         int samba_level = -1;
 295         char *s = NULL;
 296         switch (level) {
 297         case TEVENT_DEBUG_FATAL:
 298                 samba_level = 0;
 299                 break;
 300         case TEVENT_DEBUG_ERROR:
 301                 samba_level = 1;
 302                 break;
 303         case TEVENT_DEBUG_WARNING:
 304                 samba_level = 2;
 305                 break;
 306         case TEVENT_DEBUG_TRACE:
 307                 samba_level = 5;
 308                 break;
 309
 310         };
 311         vasprintf(&s, fmt, ap);
 312         if (!s) return;
 313         DEBUG(samba_level, ("s3_event: %s", s));
 314         free(s);
 315 }
 316
 317 struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
 318 {
 319         struct tevent_context *ev;
 320
 321         s3_tevent_init();
 322
 323         ev = tevent_context_init_byname(mem_ctx, "s3");
 324         if (ev) {
 325                 tevent_set_debug(ev, s3_event_debug, NULL);
 326         }
 327
 328         return ev;
 329 }
 330