ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.126
Committed: Sun Nov 18 01:25:23 2007 UTC (16 years, 8 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.125: +17 -0 lines
Log Message:
really rely on autoconf

File Contents

# Content
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