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