ev.c

   1 /*
   2  * libev event processing core, watcher management
   3  *
   4  * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *
  14  *     * Redistributions in binary form must reproduce the above
  15  *       copyright notice, this list of conditions and the following
  16  *       disclaimer in the documentation and/or other materials provided
  17  *       with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifdef __cplusplus
  33 extern "C" {
  34 #endif
  35
  36 #ifndef EV_STANDALONE
  37 # include "config.h"
  38
  39 # if HAVE_CLOCK_GETTIME
  40 #  ifndef EV_USE_MONOTONIC
  41 #   define EV_USE_MONOTONIC 1
  42 #  endif
  43 #  ifndef EV_USE_REALTIME
  44 #   define EV_USE_REALTIME  1
  45 #  endif
  46 # endif
  47
  48 # if HAVE_SELECT && HAVE_SYS_SELECT_H && !defined (EV_USE_SELECT)
  49 #  define EV_USE_SELECT 1
  50 # endif
  51
  52 # if HAVE_POLL && HAVE_POLL_H && !defined (EV_USE_POLL) && !defined (__APPLE__)
  53 #  define EV_USE_POLL 1
  54 # endif
  55
  56 # if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H && !defined (EV_USE_EPOLL)
  57 #  define EV_USE_EPOLL 1
  58 # endif
  59
  60 # if HAVE_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H && !defined (EV_USE_KQUEUE) && !defined (__APPLE__)
  61 #  define EV_USE_KQUEUE 1
  62 # endif
  63
  64 #endif
  65
  66 #include <math.h>
  67 #include <stdlib.h>
  68 #include <fcntl.h>
  69 #include <stddef.h>
  70
  71 #include <stdio.h>
  72
  73 #include <assert.h>
  74 #include <errno.h>
  75 #include <sys/types.h>
  76 #include <time.h>
  77
  78 #include <signal.h>
  79
  80 #ifndef _WIN32
  81 # include <unistd.h>
  82 # include <sys/time.h>
  83 # include <sys/wait.h>
  84 #else
  85 # define WIN32_LEAN_AND_MEAN
  86 # include <windows.h>
  87 # ifndef EV_SELECT_IS_WINSOCKET
  88 #  define EV_SELECT_IS_WINSOCKET 1
  89 # endif
  90 #endif
  91
  92 /**/
  93
  94 #ifndef EV_USE_MONOTONIC
  95 # define EV_USE_MONOTONIC 1
  96 #endif
  97
  98 #ifndef EV_USE_SELECT
  99 # define EV_USE_SELECT 1
 100 # define EV_SELECT_USE_FD_SET 1
 101 #endif
 102
 103 #ifndef EV_USE_POLL
 104 # ifdef _WIN32
 105 #  define EV_USE_POLL 0
 106 # else
 107 #  define EV_USE_POLL 1
 108 # endif
 109 #endif
 110
 111 #ifndef EV_USE_EPOLL
 112 # define EV_USE_EPOLL 0
 113 #endif
 114
 115 #ifndef EV_USE_KQUEUE
 116 # define EV_USE_KQUEUE 0
 117 #endif
 118
 119 #ifndef EV_USE_REALTIME
 120 # define EV_USE_REALTIME 1
 121 #endif
 122
 123 /**/
 124
 125 #ifndef CLOCK_MONOTONIC
 126 # undef EV_USE_MONOTONIC
 127 # define EV_USE_MONOTONIC 0
 128 #endif
 129
 130 #ifndef CLOCK_REALTIME
 131 # undef EV_USE_REALTIME
 132 # define EV_USE_REALTIME 0
 133 #endif
 134
 135 #if EV_SELECT_IS_WINSOCKET
 136 # include <winsock.h>
 137 #endif
 138
 139 /**/
 140
 141 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 142 #define MAX_BLOCKTIME 59.731 /* never wait longer than this time (to detect time jumps) */
 143 #define PID_HASHSIZE  16 /* size of pid hash table, must be power of two */
 144 /*#define CLEANUP_INTERVAL 300. /* how often to try to free memory and re-check fds */
 145
 146 #ifdef EV_H
 147 # include EV_H
 148 #else
 149 # include "ev.h"
 150 #endif
 151
 152 #if __GNUC__ >= 3
 153 # define expect(expr,value)         __builtin_expect ((expr),(value))
 154 # define inline                     inline
 155 #else
 156 # define expect(expr,value)         (expr)
 157 # define inline                     static
 158 #endif
 159
 160 #define expect_false(expr) expect ((expr) != 0, 0)
 161 #define expect_true(expr)  expect ((expr) != 0, 1)
 162
 163 #define NUMPRI    (EV_MAXPRI - EV_MINPRI + 1)
 164 #define ABSPRI(w) ((w)->priority - EV_MINPRI)
 165
 166 #define EMPTY /* required for microsofts broken pseudo-c compiler */
 167
 168 typedef struct ev_watcher *W;
 169 typedef struct ev_watcher_list *WL;
 170 typedef struct ev_watcher_time *WT;
 171
 172 static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 173
 174 #ifdef _WIN32
 175 # include "ev_win32.c"
 176 #endif
 177
 178 /*****************************************************************************/
 179
 180 static void (*syserr_cb)(const char *msg);
 181
 182 void ev_set_syserr_cb (void (*cb)(const char *msg))
 183 {
 184   syserr_cb = cb;
 185 }
 186
 187 static void
 188 syserr (const char *msg)
 189 {
 190   if (!msg)
 191     msg = "(libev) system error";
 192
 193   if (syserr_cb)
 194     syserr_cb (msg);
 195   else
 196     {
 197       perror (msg);
 198       abort ();
 199     }
 200 }
 201
 202 static void *(*alloc)(void *ptr, long size);
 203
 204 void ev_set_allocator (void *(*cb)(void *ptr, long size))
 205 {
 206   alloc = cb;
 207 }
 208
 209 static void *
 210 ev_realloc (void *ptr, long size)
 211 {
 212   ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
 213
 214   if (!ptr && size)
 215     {
 216       fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
 217       abort ();
 218     }
 219
 220   return ptr;
 221 }
 222
 223 #define ev_malloc(size) ev_realloc (0, (size))
 224 #define ev_free(ptr)    ev_realloc ((ptr), 0)
 225
 226 /*****************************************************************************/
 227
 228 typedef struct
 229 {
 230   WL head;
 231   unsigned char events;
 232   unsigned char reify;
 233 #if EV_SELECT_IS_WINSOCKET
 234   SOCKET handle;
 235 #endif
 236 } ANFD;
 237
 238 typedef struct
 239 {
 240   W w;
 241   int events;
 242 } ANPENDING;
 243
 244 #if EV_MULTIPLICITY
 245
 246   struct ev_loop
 247   {
 248     ev_tstamp ev_rt_now;
 249     #define ev_rt_now ((loop)->ev_rt_now)
 250     #define VAR(name,decl) decl;
 251       #include "ev_vars.h"
 252     #undef VAR
 253   };
 254   #include "ev_wrap.h"
 255
 256   struct ev_loop default_loop_struct;
 257   static struct ev_loop *default_loop;
 258
 259 #else
 260
 261   ev_tstamp ev_rt_now;
 262   #define VAR(name,decl) static decl;
 263     #include "ev_vars.h"
 264   #undef VAR
 265
 266   static int default_loop;
 267
 268 #endif
 269
 270 /*****************************************************************************/
 271
 272 ev_tstamp
 273 ev_time (void)
 274 {
 275 #if EV_USE_REALTIME
 276   struct timespec ts;
 277   clock_gettime (CLOCK_REALTIME, &ts);
 278   return ts.tv_sec + ts.tv_nsec * 1e-9;
 279 #else
 280   struct timeval tv;
 281   gettimeofday (&tv, 0);
 282   return tv.tv_sec + tv.tv_usec * 1e-6;
 283 #endif
 284 }
 285
 286 inline ev_tstamp
 287 get_clock (void)
 288 {
 289 #if EV_USE_MONOTONIC
 290   if (expect_true (have_monotonic))
 291     {
 292       struct timespec ts;
 293       clock_gettime (CLOCK_MONOTONIC, &ts);
 294       return ts.tv_sec + ts.tv_nsec * 1e-9;
 295     }
 296 #endif
 297
 298   return ev_time ();
 299 }
 300
 301 #if EV_MULTIPLICITY
 302 ev_tstamp
 303 ev_now (EV_P)
 304 {
 305   return ev_rt_now;
 306 }
 307 #endif
 308
 309 #define array_roundsize(type,n) ((n) | 4 & ~3)
 310
 311 #define array_needsize(type,base,cur,cnt,init)                  \
 312   if (expect_false ((cnt) > cur))                               \
 313     {                                                           \
 314       int newcnt = cur;                                         \
 315       do                                                        \
 316         {                                                       \
 317           newcnt = array_roundsize (type, newcnt << 1);         \
 318         }                                                       \
 319       while ((cnt) > newcnt);                                   \
 320                                                                 \
 321       base = (type *)ev_realloc (base, sizeof (type) * (newcnt));\
 322       init (base + cur, newcnt - cur);                          \
 323       cur = newcnt;                                             \
 324     }
 325
 326 #define array_slim(type,stem)                                   \
 327   if (stem ## max < array_roundsize (stem ## cnt >> 2))         \
 328     {                                                           \
 329       stem ## max = array_roundsize (stem ## cnt >> 1);         \
 330       base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
 331       fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
 332     }
 333
 334 #define array_free(stem, idx) \
 335   ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 336
 337 /*****************************************************************************/
 338
 339 static void
 340 anfds_init (ANFD *base, int count)
 341 {
 342   while (count--)
 343     {
 344       base->head   = 0;
 345       base->events = EV_NONE;
 346       base->reify  = 0;
 347
 348       ++base;
 349     }
 350 }
 351
 352 void
 353 ev_feed_event (EV_P_ void *w, int revents)
 354 {
 355   W w_ = (W)w;
 356
 357   if (w_->pending)
 358     {
 359       pendings [ABSPRI (w_)][w_->pending - 1].events |= revents;
 360       return;
 361     }
 362
 363   w_->pending = ++pendingcnt [ABSPRI (w_)];
 364   array_needsize (ANPENDING, pendings [ABSPRI (w_)], pendingmax [ABSPRI (w_)], pendingcnt [ABSPRI (w_)], (void));
 365   pendings [ABSPRI (w_)][w_->pending - 1].w      = w_;
 366   pendings [ABSPRI (w_)][w_->pending - 1].events = revents;
 367 }
 368
 369 static void
 370 queue_events (EV_P_ W *events, int eventcnt, int type)
 371 {
 372   int i;
 373
 374   for (i = 0; i < eventcnt; ++i)
 375     ev_feed_event (EV_A_ events [i], type);
 376 }
 377
 378 inline void
 379 fd_event (EV_P_ int fd, int revents)
 380 {
 381   ANFD *anfd = anfds + fd;
 382   struct ev_io *w;
 383
 384   for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 385     {
 386       int ev = w->events & revents;
 387
 388       if (ev)
 389         ev_feed_event (EV_A_ (W)w, ev);
 390     }
 391 }
 392
 393 void
 394 ev_feed_fd_event (EV_P_ int fd, int revents)
 395 {
 396   fd_event (EV_A_ fd, revents);
 397 }
 398
 399 /*****************************************************************************/
 400
 401 static void
 402 fd_reify (EV_P)
 403 {
 404   int i;
 405
 406   for (i = 0; i < fdchangecnt; ++i)
 407     {
 408       int fd = fdchanges [i];
 409       ANFD *anfd = anfds + fd;
 410       struct ev_io *w;
 411
 412       int events = 0;
 413
 414       for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 415         events |= w->events;
 416
 417 #if EV_SELECT_IS_WINSOCKET
 418       if (events)
 419         {
 420           unsigned long argp;
 421           anfd->handle = _get_osfhandle (fd);
 422           assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &argp) == 0));
 423         }
 424 #endif
 425
 426       anfd->reify = 0;
 427
 428       method_modify (EV_A_ fd, anfd->events, events);
 429       anfd->events = events;
 430     }
 431
 432   fdchangecnt = 0;
 433 }
 434
 435 static void
 436 fd_change (EV_P_ int fd)
 437 {
 438   if (anfds [fd].reify)
 439     return;
 440
 441   anfds [fd].reify = 1;
 442
 443   ++fdchangecnt;
 444   array_needsize (int, fdchanges, fdchangemax, fdchangecnt, (void));
 445   fdchanges [fdchangecnt - 1] = fd;
 446 }
 447
 448 static void
 449 fd_kill (EV_P_ int fd)
 450 {
 451   struct ev_io *w;
 452
 453   while ((w = (struct ev_io *)anfds [fd].head))
 454     {
 455       ev_io_stop (EV_A_ w);
 456       ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
 457     }
 458 }
 459
 460 static int
 461 fd_valid (int fd)
 462 {
 463 #ifdef _WIN32
 464   return _get_osfhandle (fd) != -1;
 465 #else
 466   return fcntl (fd, F_GETFD) != -1;
 467 #endif
 468 }
 469
 470 /* called on EBADF to verify fds */
 471 static void
 472 fd_ebadf (EV_P)
 473 {
 474   int fd;
 475
 476   for (fd = 0; fd < anfdmax; ++fd)
 477     if (anfds [fd].events)
 478       if (!fd_valid (fd) == -1 && errno == EBADF)
 479         fd_kill (EV_A_ fd);
 480 }
 481
 482 /* called on ENOMEM in select/poll to kill some fds and retry */
 483 static void
 484 fd_enomem (EV_P)
 485 {
 486   int fd;
 487
 488   for (fd = anfdmax; fd--; )
 489     if (anfds [fd].events)
 490       {
 491         fd_kill (EV_A_ fd);
 492         return;
 493       }
 494 }
 495
 496 /* usually called after fork if method needs to re-arm all fds from scratch */
 497 static void
 498 fd_rearm_all (EV_P)
 499 {
 500   int fd;
 501
 502   /* this should be highly optimised to not do anything but set a flag */
 503   for (fd = 0; fd < anfdmax; ++fd)
 504     if (anfds [fd].events)
 505       {
 506         anfds [fd].events = 0;
 507         fd_change (EV_A_ fd);
 508       }
 509 }
 510
 511 /*****************************************************************************/
 512
 513 static void
 514 upheap (WT *heap, int k)
 515 {
 516   WT w = heap [k];
 517
 518   while (k && heap [k >> 1]->at > w->at)
 519     {
 520       heap [k] = heap [k >> 1];
 521       ((W)heap [k])->active = k + 1;
 522       k >>= 1;
 523     }
 524
 525   heap [k] = w;
 526   ((W)heap [k])->active = k + 1;
 527
 528 }
 529
 530 static void
 531 downheap (WT *heap, int N, int k)
 532 {
 533   WT w = heap [k];
 534
 535   while (k < (N >> 1))
 536     {
 537       int j = k << 1;
 538
 539       if (j + 1 < N && heap [j]->at > heap [j + 1]->at)
 540         ++j;
 541
 542       if (w->at <= heap [j]->at)
 543         break;
 544
 545       heap [k] = heap [j];
 546       ((W)heap [k])->active = k + 1;
 547       k = j;
 548     }
 549
 550   heap [k] = w;
 551   ((W)heap [k])->active = k + 1;
 552 }
 553
 554 inline void
 555 adjustheap (WT *heap, int N, int k)
 556 {
 557   upheap (heap, k);
 558   downheap (heap, N, k);
 559 }
 560
 561 /*****************************************************************************/
 562
 563 typedef struct
 564 {
 565   WL head;
 566   sig_atomic_t volatile gotsig;
 567 } ANSIG;
 568
 569 static ANSIG *signals;
 570 static int signalmax;
 571
 572 static int sigpipe [2];
 573 static sig_atomic_t volatile gotsig;
 574 static struct ev_io sigev;
 575
 576 static void
 577 signals_init (ANSIG *base, int count)
 578 {
 579   while (count--)
 580     {
 581       base->head   = 0;
 582       base->gotsig = 0;
 583
 584       ++base;
 585     }
 586 }
 587
 588 static void
 589 sighandler (int signum)
 590 {
 591 #if _WIN32
 592   signal (signum, sighandler);
 593 #endif
 594
 595   signals [signum - 1].gotsig = 1;
 596
 597   if (!gotsig)
 598     {
 599       int old_errno = errno;
 600       gotsig = 1;
 601       write (sigpipe [1], &signum, 1);
 602       errno = old_errno;
 603     }
 604 }
 605
 606 void
 607 ev_feed_signal_event (EV_P_ int signum)
 608 {
 609   WL w;
 610
 611 #if EV_MULTIPLICITY
 612   assert (("feeding signal events is only supported in the default loop", loop == default_loop));
 613 #endif
 614
 615   --signum;
 616
 617   if (signum < 0 || signum >= signalmax)
 618     return;
 619
 620   signals [signum].gotsig = 0;
 621
 622   for (w = signals [signum].head; w; w = w->next)
 623     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 624 }
 625
 626 static void
 627 sigcb (EV_P_ struct ev_io *iow, int revents)
 628 {
 629   int signum;
 630
 631   read (sigpipe [0], &revents, 1);
 632   gotsig = 0;
 633
 634   for (signum = signalmax; signum--; )
 635     if (signals [signum].gotsig)
 636       ev_feed_signal_event (EV_A_ signum + 1);
 637 }
 638
 639 inline void
 640 fd_intern (int fd)
 641 {
 642 #ifdef _WIN32
 643   int arg = 1;
 644   ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
 645 #else
 646   fcntl (fd, F_SETFD, FD_CLOEXEC);
 647   fcntl (fd, F_SETFL, O_NONBLOCK);
 648 #endif
 649 }
 650
 651 static void
 652 siginit (EV_P)
 653 {
 654   fd_intern (sigpipe [0]);
 655   fd_intern (sigpipe [1]);
 656
 657   ev_io_set (&sigev, sigpipe [0], EV_READ);
 658   ev_io_start (EV_A_ &sigev);
 659   ev_unref (EV_A); /* child watcher should not keep loop alive */
 660 }
 661
 662 /*****************************************************************************/
 663
 664 static struct ev_child *childs [PID_HASHSIZE];
 665
 666 #ifndef _WIN32
 667
 668 static struct ev_signal childev;
 669
 670 #ifndef WCONTINUED
 671 # define WCONTINUED 0
 672 #endif
 673
 674 static void
 675 child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
 676 {
 677   struct ev_child *w;
 678
 679   for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
 680     if (w->pid == pid || !w->pid)
 681       {
 682         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
 683         w->rpid         = pid;
 684         w->rstatus      = status;
 685         ev_feed_event (EV_A_ (W)w, EV_CHILD);
 686       }
 687 }
 688
 689 static void
 690 childcb (EV_P_ struct ev_signal *sw, int revents)
 691 {
 692   int pid, status;
 693
 694   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
 695     {
 696       /* make sure we are called again until all childs have been reaped */
 697       ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
 698
 699       child_reap (EV_A_ sw, pid, pid, status);
 700       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */
 701     }
 702 }
 703
 704 #endif
 705
 706 /*****************************************************************************/
 707
 708 #if EV_USE_KQUEUE
 709 # include "ev_kqueue.c"
 710 #endif
 711 #if EV_USE_EPOLL
 712 # include "ev_epoll.c"
 713 #endif
 714 #if EV_USE_POLL
 715 # include "ev_poll.c"
 716 #endif
 717 #if EV_USE_SELECT
 718 # include "ev_select.c"
 719 #endif
 720
 721 int
 722 ev_version_major (void)
 723 {
 724   return EV_VERSION_MAJOR;
 725 }
 726
 727 int
 728 ev_version_minor (void)
 729 {
 730   return EV_VERSION_MINOR;
 731 }
 732
 733 /* return true if we are running with elevated privileges and should ignore env variables */
 734 static int
 735 enable_secure (void)
 736 {
 737 #ifdef _WIN32
 738   return 0;
 739 #else
 740   return getuid () != geteuid ()
 741       || getgid () != getegid ();
 742 #endif
 743 }
 744
 745 int
 746 ev_method (EV_P)
 747 {
 748   return method;
 749 }
 750
 751 static void
 752 loop_init (EV_P_ int methods)
 753 {
 754   if (!method)
 755     {
 756 #if EV_USE_MONOTONIC
 757       {
 758         struct timespec ts;
 759         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
 760           have_monotonic = 1;
 761       }
 762 #endif
 763
 764       ev_rt_now = ev_time ();
 765       mn_now    = get_clock ();
 766       now_floor = mn_now;
 767       rtmn_diff = ev_rt_now - mn_now;
 768
 769       if (methods == EVMETHOD_AUTO)
 770         if (!enable_secure () && getenv ("LIBEV_METHODS"))
 771           methods = atoi (getenv ("LIBEV_METHODS"));
 772         else
 773           methods = EVMETHOD_ANY;
 774
 775       method = 0;
 776 #if EV_USE_KQUEUE
 777       if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
 778 #endif
 779 #if EV_USE_EPOLL
 780       if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init  (EV_A_ methods);
 781 #endif
 782 #if EV_USE_POLL
 783       if (!method && (methods & EVMETHOD_POLL  )) method = poll_init   (EV_A_ methods);
 784 #endif
 785 #if EV_USE_SELECT
 786       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 787 #endif
 788
 789       ev_init (&sigev, sigcb);
 790       ev_set_priority (&sigev, EV_MAXPRI);
 791     }
 792 }
 793
 794 void
 795 loop_destroy (EV_P)
 796 {
 797   int i;
 798
 799 #if EV_USE_KQUEUE
 800   if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
 801 #endif
 802 #if EV_USE_EPOLL
 803   if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
 804 #endif
 805 #if EV_USE_POLL
 806   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 807 #endif
 808 #if EV_USE_SELECT
 809   if (method == EVMETHOD_SELECT) select_destroy (EV_A);
 810 #endif
 811
 812   for (i = NUMPRI; i--; )
 813     array_free (pending, [i]);
 814
 815   /* have to use the microsoft-never-gets-it-right macro */
 816   array_free (fdchange, EMPTY);
 817   array_free (timer, EMPTY);
 818 #if EV_PERIODICS
 819   array_free (periodic, EMPTY);
 820 #endif
 821   array_free (idle, EMPTY);
 822   array_free (prepare, EMPTY);
 823   array_free (check, EMPTY);
 824
 825   method = 0;
 826 }
 827
 828 static void
 829 loop_fork (EV_P)
 830 {
 831 #if EV_USE_EPOLL
 832   if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
 833 #endif
 834 #if EV_USE_KQUEUE
 835   if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
 836 #endif
 837
 838   if (ev_is_active (&sigev))
 839     {
 840       /* default loop */
 841
 842       ev_ref (EV_A);
 843       ev_io_stop (EV_A_ &sigev);
 844       close (sigpipe [0]);
 845       close (sigpipe [1]);
 846
 847       while (pipe (sigpipe))
 848         syserr ("(libev) error creating pipe");
 849
 850       siginit (EV_A);
 851     }
 852
 853   postfork = 0;
 854 }
 855
 856 #if EV_MULTIPLICITY
 857 struct ev_loop *
 858 ev_loop_new (int methods)
 859 {
 860   struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
 861
 862   memset (loop, 0, sizeof (struct ev_loop));
 863
 864   loop_init (EV_A_ methods);
 865
 866   if (ev_method (EV_A))
 867     return loop;
 868
 869   return 0;
 870 }
 871
 872 void
 873 ev_loop_destroy (EV_P)
 874 {
 875   loop_destroy (EV_A);
 876   ev_free (loop);
 877 }
 878
 879 void
 880 ev_loop_fork (EV_P)
 881 {
 882   postfork = 1;
 883 }
 884
 885 #endif
 886
 887 #if EV_MULTIPLICITY
 888 struct ev_loop *
 889 #else
 890 int
 891 #endif
 892 ev_default_loop (int methods)
 893 {
 894   if (sigpipe [0] == sigpipe [1])
 895     if (pipe (sigpipe))
 896       return 0;
 897
 898   if (!default_loop)
 899     {
 900 #if EV_MULTIPLICITY
 901       struct ev_loop *loop = default_loop = &default_loop_struct;
 902 #else
 903       default_loop = 1;
 904 #endif
 905
 906       loop_init (EV_A_ methods);
 907
 908       if (ev_method (EV_A))
 909         {
 910           siginit (EV_A);
 911
 912 #ifndef _WIN32
 913           ev_signal_init (&childev, childcb, SIGCHLD);
 914           ev_set_priority (&childev, EV_MAXPRI);
 915           ev_signal_start (EV_A_ &childev);
 916           ev_unref (EV_A); /* child watcher should not keep loop alive */
 917 #endif
 918         }
 919       else
 920         default_loop = 0;
 921     }
 922
 923   return default_loop;
 924 }
 925
 926 void
 927 ev_default_destroy (void)
 928 {
 929 #if EV_MULTIPLICITY
 930   struct ev_loop *loop = default_loop;
 931 #endif
 932
 933 #ifndef _WIN32
 934   ev_ref (EV_A); /* child watcher */
 935   ev_signal_stop (EV_A_ &childev);
 936 #endif
 937
 938   ev_ref (EV_A); /* signal watcher */
 939   ev_io_stop (EV_A_ &sigev);
 940
 941   close (sigpipe [0]); sigpipe [0] = 0;
 942   close (sigpipe [1]); sigpipe [1] = 0;
 943
 944   loop_destroy (EV_A);
 945 }
 946
 947 void
 948 ev_default_fork (void)
 949 {
 950 #if EV_MULTIPLICITY
 951   struct ev_loop *loop = default_loop;
 952 #endif
 953
 954   if (method)
 955     postfork = 1;
 956 }
 957
 958 /*****************************************************************************/
 959
 960 static int
 961 any_pending (EV_P)
 962 {
 963   int pri;
 964
 965   for (pri = NUMPRI; pri--; )
 966     if (pendingcnt [pri])
 967       return 1;
 968
 969   return 0;
 970 }
 971
 972 static void
 973 call_pending (EV_P)
 974 {
 975   int pri;
 976
 977   for (pri = NUMPRI; pri--; )
 978     while (pendingcnt [pri])
 979       {
 980         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
 981
 982         if (p->w)
 983           {
 984             p->w->pending = 0;
 985             EV_CB_INVOKE (p->w, p->events);
 986           }
 987       }
 988 }
 989
 990 static void
 991 timers_reify (EV_P)
 992 {
 993   while (timercnt && ((WT)timers [0])->at <= mn_now)
 994     {
 995       struct ev_timer *w = timers [0];
 996
 997       assert (("inactive timer on timer heap detected", ev_is_active (w)));
 998
 999       /* first reschedule or stop timer */
1000       if (w->repeat)
1001         {
1002           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
1003
1004           ((WT)w)->at += w->repeat;
1005           if (((WT)w)->at < mn_now)
1006             ((WT)w)->at = mn_now;
1007
1008           downheap ((WT *)timers, timercnt, 0);
1009         }
1010       else
1011         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
1012
1013       ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
1014     }
1015 }
1016
1017 #if EV_PERIODICS
1018 static void
1019 periodics_reify (EV_P)
1020 {
1021   while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now)
1022     {
1023       struct ev_periodic *w = periodics [0];
1024
1025       assert (("inactive timer on periodic heap detected", ev_is_active (w)));
1026
1027       /* first reschedule or stop timer */
1028       if (w->reschedule_cb)
1029         {
1030           ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, ev_rt_now + 0.0001);
1031
1032           assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now));
1033           downheap ((WT *)periodics, periodiccnt, 0);
1034         }
1035       else if (w->interval)
1036         {
1037           ((WT)w)->at += floor ((ev_rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
1038           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));
1039           downheap ((WT *)periodics, periodiccnt, 0);
1040         }
1041       else
1042         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1043
1044       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
1045     }
1046 }
1047
1048 static void
1049 periodics_reschedule (EV_P)
1050 {
1051   int i;
1052
1053   /* adjust periodics after time jump */
1054   for (i = 0; i < periodiccnt; ++i)
1055     {
1056       struct ev_periodic *w = periodics [i];
1057
1058       if (w->reschedule_cb)
1059         ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1060       else if (w->interval)
1061         ((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval;
1062     }
1063
1064   /* now rebuild the heap */
1065   for (i = periodiccnt >> 1; i--; )
1066     downheap ((WT *)periodics, periodiccnt, i);
1067 }
1068 #endif
1069
1070 inline int
1071 time_update_monotonic (EV_P)
1072 {
1073   mn_now = get_clock ();
1074
1075   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
1076     {
1077       ev_rt_now = rtmn_diff + mn_now;
1078       return 0;
1079     }
1080   else
1081     {
1082       now_floor = mn_now;
1083       ev_rt_now = ev_time ();
1084       return 1;
1085     }
1086 }
1087
1088 static void
1089 time_update (EV_P)
1090 {
1091   int i;
1092
1093 #if EV_USE_MONOTONIC
1094   if (expect_true (have_monotonic))
1095     {
1096       if (time_update_monotonic (EV_A))
1097         {
1098           ev_tstamp odiff = rtmn_diff;
1099
1100           for (i = 4; --i; ) /* loop a few times, before making important decisions */
1101             {
1102               rtmn_diff = ev_rt_now - mn_now;
1103
1104               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
1105                 return; /* all is well */
1106
1107               ev_rt_now = ev_time ();
1108               mn_now    = get_clock ();
1109               now_floor = mn_now;
1110             }
1111
1112 # if EV_PERIODICS
1113           periodics_reschedule (EV_A);
1114 # endif
1115           /* no timer adjustment, as the monotonic clock doesn't jump */
1116           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1117         }
1118     }
1119   else
1120 #endif
1121     {
1122       ev_rt_now = ev_time ();
1123
1124       if (expect_false (mn_now > ev_rt_now || mn_now < ev_rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
1125         {
1126 #if EV_PERIODICS
1127           periodics_reschedule (EV_A);
1128 #endif
1129
1130           /* adjust timers. this is easy, as the offset is the same for all */
1131           for (i = 0; i < timercnt; ++i)
1132             ((WT)timers [i])->at += ev_rt_now - mn_now;
1133         }
1134
1135       mn_now = ev_rt_now;
1136     }
1137 }
1138
1139 void
1140 ev_ref (EV_P)
1141 {
1142   ++activecnt;
1143 }
1144
1145 void
1146 ev_unref (EV_P)
1147 {
1148   --activecnt;
1149 }
1150
1151 static int loop_done;
1152
1153 void
1154 ev_loop (EV_P_ int flags)
1155 {
1156   double block;
1157   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
1158
1159   do
1160     {
1161       /* queue check watchers (and execute them) */
1162       if (expect_false (preparecnt))
1163         {
1164           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1165           call_pending (EV_A);
1166         }
1167
1168       /* we might have forked, so reify kernel state if necessary */
1169       if (expect_false (postfork))
1170         loop_fork (EV_A);
1171
1172       /* update fd-related kernel structures */
1173       fd_reify (EV_A);
1174
1175       /* calculate blocking time */
1176
1177       /* we only need this for !monotonic clock or timers, but as we basically
1178          always have timers, we just calculate it always */
1179 #if EV_USE_MONOTONIC
1180       if (expect_true (have_monotonic))
1181         time_update_monotonic (EV_A);
1182       else
1183 #endif
1184         {
1185           ev_rt_now = ev_time ();
1186           mn_now    = ev_rt_now;
1187         }
1188
1189       if (flags & EVLOOP_NONBLOCK || idlecnt)
1190         block = 0.;
1191       else
1192         {
1193           block = MAX_BLOCKTIME;
1194
1195           if (timercnt)
1196             {
1197               ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
1198               if (block > to) block = to;
1199             }
1200
1201 #if EV_PERIODICS
1202           if (periodiccnt)
1203             {
1204               ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + method_fudge;
1205               if (block > to) block = to;
1206             }
1207 #endif
1208
1209           if (block < 0.) block = 0.;
1210         }
1211
1212       method_poll (EV_A_ block);
1213
1214       /* update ev_rt_now, do magic */
1215       time_update (EV_A);
1216
1217       /* queue pending timers and reschedule them */
1218       timers_reify (EV_A); /* relative timers called last */
1219 #if EV_PERIODICS
1220       periodics_reify (EV_A); /* absolute timers called first */
1221 #endif
1222
1223       /* queue idle watchers unless io or timers are pending */
1224       if (idlecnt && !any_pending (EV_A))
1225         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1226
1227       /* queue check watchers, to be executed first */
1228       if (checkcnt)
1229         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1230
1231       call_pending (EV_A);
1232     }
1233   while (activecnt && !loop_done);
1234
1235   if (loop_done != 2)
1236     loop_done = 0;
1237 }
1238
1239 void
1240 ev_unloop (EV_P_ int how)
1241 {
1242   loop_done = how;
1243 }
1244
1245 /*****************************************************************************/
1246
1247 inline void
1248 wlist_add (WL *head, WL elem)
1249 {
1250   elem->next = *head;
1251   *head = elem;
1252 }
1253
1254 inline void
1255 wlist_del (WL *head, WL elem)
1256 {
1257   while (*head)
1258     {
1259       if (*head == elem)
1260         {
1261           *head = elem->next;
1262           return;
1263         }
1264
1265       head = &(*head)->next;
1266     }
1267 }
1268
1269 inline void
1270 ev_clear_pending (EV_P_ W w)
1271 {
1272   if (w->pending)
1273     {
1274       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1275       w->pending = 0;
1276     }
1277 }
1278
1279 inline void
1280 ev_start (EV_P_ W w, int active)
1281 {
1282   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1283   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1284
1285   w->active = active;
1286   ev_ref (EV_A);
1287 }
1288
1289 inline void
1290 ev_stop (EV_P_ W w)
1291 {
1292   ev_unref (EV_A);
1293   w->active = 0;
1294 }
1295
1296 /*****************************************************************************/
1297
1298 void
1299 ev_io_start (EV_P_ struct ev_io *w)
1300 {
1301   int fd = w->fd;
1302
1303   if (ev_is_active (w))
1304     return;
1305
1306   assert (("ev_io_start called with negative fd", fd >= 0));
1307
1308   ev_start (EV_A_ (W)w, 1);
1309   array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
1310   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1311
1312   fd_change (EV_A_ fd);
1313 }
1314
1315 void
1316 ev_io_stop (EV_P_ struct ev_io *w)
1317 {
1318   ev_clear_pending (EV_A_ (W)w);
1319   if (!ev_is_active (w))
1320     return;
1321
1322   assert (("ev_io_start called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
1323
1324   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1325   ev_stop (EV_A_ (W)w);
1326
1327   fd_change (EV_A_ w->fd);
1328 }
1329
1330 void
1331 ev_timer_start (EV_P_ struct ev_timer *w)
1332 {
1333   if (ev_is_active (w))
1334     return;
1335
1336   ((WT)w)->at += mn_now;
1337
1338   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1339
1340   ev_start (EV_A_ (W)w, ++timercnt);
1341   array_needsize (struct ev_timer *, timers, timermax, timercnt, (void));
1342   timers [timercnt - 1] = w;
1343   upheap ((WT *)timers, timercnt - 1);
1344
1345   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1346 }
1347
1348 void
1349 ev_timer_stop (EV_P_ struct ev_timer *w)
1350 {
1351   ev_clear_pending (EV_A_ (W)w);
1352   if (!ev_is_active (w))
1353     return;
1354
1355   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1356
1357   if (((W)w)->active < timercnt--)
1358     {
1359       timers [((W)w)->active - 1] = timers [timercnt];
1360       adjustheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1361     }
1362
1363   ((WT)w)->at -= mn_now;
1364
1365   ev_stop (EV_A_ (W)w);
1366 }
1367
1368 void
1369 ev_timer_again (EV_P_ struct ev_timer *w)
1370 {
1371   if (ev_is_active (w))
1372     {
1373       if (w->repeat)
1374         {
1375           ((WT)w)->at = mn_now + w->repeat;
1376           adjustheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1377         }
1378       else
1379         ev_timer_stop (EV_A_ w);
1380     }
1381   else if (w->repeat)
1382     ev_timer_start (EV_A_ w);
1383 }
1384
1385 #if EV_PERIODICS
1386 void
1387 ev_periodic_start (EV_P_ struct ev_periodic *w)
1388 {
1389   if (ev_is_active (w))
1390     return;
1391
1392   if (w->reschedule_cb)
1393     ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1394   else if (w->interval)
1395     {
1396       assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1397       /* this formula differs from the one in periodic_reify because we do not always round up */
1398       ((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval;
1399     }
1400
1401   ev_start (EV_A_ (W)w, ++periodiccnt);
1402   array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, (void));
1403   periodics [periodiccnt - 1] = w;
1404   upheap ((WT *)periodics, periodiccnt - 1);
1405
1406   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1407 }
1408
1409 void
1410 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1411 {
1412   ev_clear_pending (EV_A_ (W)w);
1413   if (!ev_is_active (w))
1414     return;
1415
1416   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1417
1418   if (((W)w)->active < periodiccnt--)
1419     {
1420       periodics [((W)w)->active - 1] = periodics [periodiccnt];
1421       adjustheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
1422     }
1423
1424   ev_stop (EV_A_ (W)w);
1425 }
1426
1427 void
1428 ev_periodic_again (EV_P_ struct ev_periodic *w)
1429 {
1430   /* TODO: use adjustheap and recalculation */
1431   ev_periodic_stop (EV_A_ w);
1432   ev_periodic_start (EV_A_ w);
1433 }
1434 #endif
1435
1436 void
1437 ev_idle_start (EV_P_ struct ev_idle *w)
1438 {
1439   if (ev_is_active (w))
1440     return;
1441
1442   ev_start (EV_A_ (W)w, ++idlecnt);
1443   array_needsize (struct ev_idle *, idles, idlemax, idlecnt, (void));
1444   idles [idlecnt - 1] = w;
1445 }
1446
1447 void
1448 ev_idle_stop (EV_P_ struct ev_idle *w)
1449 {
1450   ev_clear_pending (EV_A_ (W)w);
1451   if (!ev_is_active (w))
1452     return;
1453
1454   idles [((W)w)->active - 1] = idles [--idlecnt];
1455   ev_stop (EV_A_ (W)w);
1456 }
1457
1458 void
1459 ev_prepare_start (EV_P_ struct ev_prepare *w)
1460 {
1461   if (ev_is_active (w))
1462     return;
1463
1464   ev_start (EV_A_ (W)w, ++preparecnt);
1465   array_needsize (struct ev_prepare *, prepares, preparemax, preparecnt, (void));
1466   prepares [preparecnt - 1] = w;
1467 }
1468
1469 void
1470 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1471 {
1472   ev_clear_pending (EV_A_ (W)w);
1473   if (!ev_is_active (w))
1474     return;
1475
1476   prepares [((W)w)->active - 1] = prepares [--preparecnt];
1477   ev_stop (EV_A_ (W)w);
1478 }
1479
1480 void
1481 ev_check_start (EV_P_ struct ev_check *w)
1482 {
1483   if (ev_is_active (w))
1484     return;
1485
1486   ev_start (EV_A_ (W)w, ++checkcnt);
1487   array_needsize (struct ev_check *, checks, checkmax, checkcnt, (void));
1488   checks [checkcnt - 1] = w;
1489 }
1490
1491 void
1492 ev_check_stop (EV_P_ struct ev_check *w)
1493 {
1494   ev_clear_pending (EV_A_ (W)w);
1495   if (!ev_is_active (w))
1496     return;
1497
1498   checks [((W)w)->active - 1] = checks [--checkcnt];
1499   ev_stop (EV_A_ (W)w);
1500 }
1501
1502 #ifndef SA_RESTART
1503 # define SA_RESTART 0
1504 #endif
1505
1506 void
1507 ev_signal_start (EV_P_ struct ev_signal *w)
1508 {
1509 #if EV_MULTIPLICITY
1510   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1511 #endif
1512   if (ev_is_active (w))
1513     return;
1514
1515   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1516
1517   ev_start (EV_A_ (W)w, 1);
1518   array_needsize (ANSIG, signals, signalmax, w->signum, signals_init);
1519   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1520
1521   if (!((WL)w)->next)
1522     {
1523 #if _WIN32
1524       signal (w->signum, sighandler);
1525 #else
1526       struct sigaction sa;
1527       sa.sa_handler = sighandler;
1528       sigfillset (&sa.sa_mask);
1529       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1530       sigaction (w->signum, &sa, 0);
1531 #endif
1532     }
1533 }
1534
1535 void
1536 ev_signal_stop (EV_P_ struct ev_signal *w)
1537 {
1538   ev_clear_pending (EV_A_ (W)w);
1539   if (!ev_is_active (w))
1540     return;
1541
1542   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1543   ev_stop (EV_A_ (W)w);
1544
1545   if (!signals [w->signum - 1].head)
1546     signal (w->signum, SIG_DFL);
1547 }
1548
1549 void
1550 ev_child_start (EV_P_ struct ev_child *w)
1551 {
1552 #if EV_MULTIPLICITY
1553   assert (("child watchers are only supported in the default loop", loop == default_loop));
1554 #endif
1555   if (ev_is_active (w))
1556     return;
1557
1558   ev_start (EV_A_ (W)w, 1);
1559   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1560 }
1561
1562 void
1563 ev_child_stop (EV_P_ struct ev_child *w)
1564 {
1565   ev_clear_pending (EV_A_ (W)w);
1566   if (!ev_is_active (w))
1567     return;
1568
1569   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1570   ev_stop (EV_A_ (W)w);
1571 }
1572
1573 /*****************************************************************************/
1574
1575 struct ev_once
1576 {
1577   struct ev_io io;
1578   struct ev_timer to;
1579   void (*cb)(int revents, void *arg);
1580   void *arg;
1581 };
1582
1583 static void
1584 once_cb (EV_P_ struct ev_once *once, int revents)
1585 {
1586   void (*cb)(int revents, void *arg) = once->cb;
1587   void *arg = once->arg;
1588
1589   ev_io_stop (EV_A_ &once->io);
1590   ev_timer_stop (EV_A_ &once->to);
1591   ev_free (once);
1592
1593   cb (revents, arg);
1594 }
1595
1596 static void
1597 once_cb_io (EV_P_ struct ev_io *w, int revents)
1598 {
1599   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1600 }
1601
1602 static void
1603 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1604 {
1605   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1606 }
1607
1608 void
1609 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1610 {
1611   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
1612
1613   if (!once)
1614     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1615   else
1616     {
1617       once->cb  = cb;
1618       once->arg = arg;
1619
1620       ev_init (&once->io, once_cb_io);
1621       if (fd >= 0)
1622         {
1623           ev_io_set (&once->io, fd, events);
1624           ev_io_start (EV_A_ &once->io);
1625         }
1626
1627       ev_init (&once->to, once_cb_to);
1628       if (timeout >= 0.)
1629         {
1630           ev_timer_set (&once->to, timeout, 0.);
1631           ev_timer_start (EV_A_ &once->to);
1632         }
1633     }
1634 }
1635
1636 #ifdef __cplusplus
1637 }
1638 #endif
1639