Mirror of :pserver:anonymous@cvs.schmorp.de/schmorpforge libev http://software.schmorp.de/pkg/libev.html
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

365 lines
12 KiB

14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
  1. /*
  2. * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are
  7. * met:
  8. *
  9. * * Redistributions of source code must retain the above copyright
  10. * notice, this list of conditions and the following disclaimer.
  11. *
  12. * * Redistributions in binary form must reproduce the above
  13. * copyright notice, this list of conditions and the following
  14. * disclaimer in the documentation and/or other materials provided
  15. * with the distribution.
  16. *
  17. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28. */
  29. #ifndef EV_H
  30. #define EV_H
  31. #ifdef __cplusplus
  32. extern "C" {
  33. #endif
  34. typedef double ev_tstamp;
  35. /* these priorities are inclusive, higher priorities will be called earlier */
  36. #ifndef EV_MINPRI
  37. # define EV_MINPRI -2
  38. #endif
  39. #ifndef EV_MAXPRI
  40. # define EV_MAXPRI +2
  41. #endif
  42. #ifndef EV_MULTIPLICITY
  43. # define EV_MULTIPLICITY 1
  44. #endif
  45. /* support multiple event loops? */
  46. #if EV_MULTIPLICITY
  47. struct ev_loop;
  48. # define EV_P struct ev_loop *loop
  49. # define EV_P_ EV_P,
  50. # define EV_A loop
  51. # define EV_A_ EV_A,
  52. #else
  53. # define EV_P void
  54. # define EV_P_
  55. # define EV_A
  56. # define EV_A_
  57. #endif
  58. /* eventmask, revents, events... */
  59. #define EV_UNDEF -1 /* guaranteed to be invalid */
  60. #define EV_NONE 0x00
  61. #define EV_READ 0x01
  62. #define EV_WRITE 0x02
  63. #define EV_TIMEOUT 0x000100
  64. #define EV_PERIODIC 0x000200
  65. #define EV_SIGNAL 0x000400
  66. #define EV_IDLE 0x000800
  67. #define EV_CHECK 0x001000
  68. #define EV_PREPARE 0x002000
  69. #define EV_CHILD 0x004000
  70. #define EV_ERROR 0x800000 /* sent when an error occurs */
  71. /* can be used to add custom fields to all watchers */
  72. #ifndef EV_COMMON
  73. # define EV_COMMON void *data
  74. #endif
  75. #ifndef EV_PROTOTYPES
  76. # define EV_PROTOTYPES 1
  77. #endif
  78. #define EV_VERSION_MAJOR 1
  79. #define EV_VERSION_MINOR 1
  80. /*
  81. * struct member types:
  82. * private: you can look at them, but not change them, and they might not mean anything to you.
  83. * ro: can be read anytime, but only changed when the watcher isn't active
  84. * rw: can be read and modified anytime, even when the watcher is active
  85. */
  86. /* shared by all watchers */
  87. #define EV_WATCHER(type) \
  88. int active; /* private */ \
  89. int pending; /* private */ \
  90. int priority; /* private */ \
  91. EV_COMMON; /* rw */ \
  92. void (*cb)(EV_P_ struct type *, int revents); /* private */ /* gets invoked with an eventmask */
  93. #define EV_WATCHER_LIST(type) \
  94. EV_WATCHER (type); \
  95. struct ev_watcher_list *next /* private */
  96. #define EV_WATCHER_TIME(type) \
  97. EV_WATCHER (type); \
  98. ev_tstamp at /* private */
  99. /* base class, nothing to see here unless you subclass */
  100. struct ev_watcher {
  101. EV_WATCHER (ev_watcher);
  102. };
  103. /* base class, nothing to see here unless you subclass */
  104. struct ev_watcher_list {
  105. EV_WATCHER_LIST (ev_watcher_list);
  106. };
  107. /* base class, nothing to see here unless you subclass */
  108. struct ev_watcher_time {
  109. EV_WATCHER_TIME (ev_watcher_time);
  110. };
  111. /* invoked after a specific time, repeatable (based on monotonic clock) */
  112. /* revent EV_TIMEOUT */
  113. struct ev_timer
  114. {
  115. EV_WATCHER_TIME (ev_timer);
  116. ev_tstamp repeat; /* rw */
  117. };
  118. /* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */
  119. /* revent EV_PERIODIC */
  120. struct ev_periodic
  121. {
  122. EV_WATCHER_TIME (ev_periodic);
  123. ev_tstamp interval; /* rw */
  124. };
  125. /* invoked when fd is either EV_READable or EV_WRITEable */
  126. /* revent EV_READ, EV_WRITE */
  127. struct ev_io
  128. {
  129. EV_WATCHER_LIST (ev_io);
  130. int fd; /* ro */
  131. int events; /* ro */
  132. };
  133. /* invoked when the given signal has been received */
  134. /* revent EV_SIGNAL */
  135. struct ev_signal
  136. {
  137. EV_WATCHER_LIST (ev_signal);
  138. #if EV_MULTIPLICITY
  139. struct ev_loop *loop;
  140. #endif
  141. int signum; /* ro */
  142. };
  143. /* invoked when the nothing else needs to be done, keeps the process from blocking */
  144. /* revent EV_IDLE */
  145. struct ev_idle
  146. {
  147. EV_WATCHER (ev_idle);
  148. };
  149. /* invoked for each run of the mainloop, just before the blocking call */
  150. /* you can still change events in any way you like */
  151. /* revent EV_PREPARE */
  152. struct ev_prepare
  153. {
  154. EV_WATCHER (ev_prepare);
  155. };
  156. /* invoked for each run of the mainloop, just after the blocking call */
  157. /* revent EV_CHECK */
  158. struct ev_check
  159. {
  160. EV_WATCHER (ev_check);
  161. };
  162. /* invoked when sigchld is received and waitpid indicates the givne pid */
  163. /* revent EV_CHILD */
  164. /* does not support priorities */
  165. struct ev_child
  166. {
  167. EV_WATCHER_LIST (ev_child);
  168. int pid; /* ro */
  169. int rpid; /* rw, holds the received pid */
  170. int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */
  171. };
  172. union ev_any_watcher
  173. {
  174. struct ev_watcher w;
  175. struct ev_watcher_list wl;
  176. struct ev_io io;
  177. struct ev_timer timer;
  178. struct ev_periodic periodic;
  179. struct ev_signal signal;
  180. struct ev_idle idle;
  181. struct ev_child child;
  182. struct ev_prepare prepare;
  183. struct ev_check check;
  184. };
  185. #define EVMETHOD_AUTO 0 /* consults environment */
  186. #define EVMETHOD_SELECT 1
  187. #define EVMETHOD_POLL 2
  188. #define EVMETHOD_EPOLL 4
  189. #define EVMETHOD_KQUEUE 8
  190. #define EVMETHOD_DEVPOLL 16 /* NYI */
  191. #define EVMETHOD_PORT 32 /* NYI */
  192. #define EVMETHOD_WIN32 64 /* NYI */
  193. #define EVMETHOD_ANY ~0 /* any method, do not consult env */
  194. #if EV_PROTOTYPES
  195. int ev_version_major (void);
  196. int ev_version_minor (void);
  197. ev_tstamp ev_time (void);
  198. /* Sets the allocation function to use, works like realloc.
  199. * It is used to allocate and free memory.
  200. * If it returns zero when memory needs to be allocated, the library might abort
  201. * or take some potentially destructive action.
  202. * The default is your system realloc function.
  203. */
  204. void ev_set_allocator (void *(*cb)(void *ptr, long size));
  205. /* set the callback function to call on a
  206. * retryable syscall error
  207. * (such as failed select, poll, epoll_wait)
  208. */
  209. void ev_set_syserr_cb (void (*cb)(const char *msg));
  210. # if EV_MULTIPLICITY
  211. /* the default loop is the only one that handles signals and child watchers */
  212. /* you can call this as often as you like */
  213. struct ev_loop *ev_default_loop (int methods); /* returns default loop */
  214. /* create and destroy alternative loops that don't handle signals */
  215. struct ev_loop *ev_loop_new (int methods);
  216. void ev_loop_destroy (EV_P);
  217. void ev_loop_fork (EV_P);
  218. # else
  219. int ev_default_loop (int methods); /* returns true when successful */
  220. # endif
  221. void ev_default_destroy (void); /* destroy the default loop */
  222. /* this needs to be called after fork, to duplicate the default loop */
  223. /* if you create alternative loops you have to call ev_loop_fork on them */
  224. /* you can call it in either the parent or the child */
  225. /* you can actually call it at any time, anywhere :) */
  226. void ev_default_fork (void);
  227. int ev_method (EV_P);
  228. #endif
  229. #define EVLOOP_NONBLOCK 1 /* do not block/wait */
  230. #define EVLOOP_ONESHOT 2 /* block *once* only */
  231. #define EVUNLOOP_ONCE 1 /* unloop once */
  232. #define EVUNLOOP_ALL 2 /* unloop all loops */
  233. #if EV_PROTOTYPES
  234. void ev_loop (EV_P_ int flags);
  235. void ev_unloop (EV_P_ int how); /* set to 1 to break out of event loop, set to 2 to break out of all event loops */
  236. ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
  237. /*
  238. * ref/unref can be used to add or remove a refcount on the mainloop. every watcher
  239. * keeps one reference. if you have a long-runing watcher you never unregister that
  240. * should not keep ev_loop from running, unref() after starting, and ref() before stopping.
  241. */
  242. void ev_ref (EV_P);
  243. void ev_unref (EV_P);
  244. /* convinience function, wait for a single event, without registering an event watcher */
  245. /* if timeout is < 0, do wait indefinitely */
  246. void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg);
  247. #endif
  248. /* these may evaluate ev multiple times, and the other arguments at most once */
  249. /* either use ev_watcher_init + ev_TYPE_set, or the ev_TYPE_init macro, below, to first initialise a watcher */
  250. #define ev_watcher_init(ev,cb_) do { \
  251. ((struct ev_watcher *)(void *)(ev))->active = \
  252. ((struct ev_watcher *)(void *)(ev))->pending = \
  253. ((struct ev_watcher *)(void *)(ev))->priority = 0; \
  254. (ev)->cb = (cb_); \
  255. } while (0)
  256. #define ev_io_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_); } while (0)
  257. #define ev_timer_set(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); } while (0)
  258. #define ev_periodic_set(ev,at_,interval_) do { (ev)->at = (at_); (ev)->interval = (interval_); } while (0)
  259. #define ev_signal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)
  260. #define ev_idle_set(ev) /* nop, yes, this is a serious in-joke */
  261. #define ev_prepare_set(ev) /* nop, yes, this is a serious in-joke */
  262. #define ev_check_set(ev) /* nop, yes, this is a serious in-joke */
  263. #define ev_child_set(ev,pid_) do { (ev)->pid = (pid_); } while (0)
  264. #define ev_io_init(ev,cb,fd,events) do { ev_watcher_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
  265. #define ev_timer_init(ev,cb,after,repeat) do { ev_watcher_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
  266. #define ev_periodic_init(ev,cb,at,interval) do { ev_watcher_init ((ev), (cb)); ev_periodic_set ((ev),(at),(interval)); } while (0)
  267. #define ev_signal_init(ev,cb,signum) do { ev_watcher_init ((ev), (cb)); ev_signal_set ((ev), (signum)); } while (0)
  268. #define ev_idle_init(ev,cb) do { ev_watcher_init ((ev), (cb)); ev_idle_set ((ev)); } while (0)
  269. #define ev_prepare_init(ev,cb) do { ev_watcher_init ((ev), (cb)); ev_prepare_set ((ev)); } while (0)
  270. #define ev_check_init(ev,cb) do { ev_watcher_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
  271. #define ev_child_init(ev,cb,pid) do { ev_watcher_init ((ev), (cb)); ev_child_set ((ev),(pid)); } while (0)
  272. #define ev_is_pending(ev) (0 + ((struct ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
  273. #define ev_is_active(ev) (0 + ((struct ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
  274. #define ev_priority(ev) ((struct ev_watcher *)(void *)(ev))->priority /* rw */
  275. #define ev_cb(ev) (ev)->cb /* rw */
  276. #define ev_set_priority(ev,pri) ev_priority (ev) = (pri)
  277. #define ev_set_cb(ev,cb_) ev_cb (ev) = (cb_)
  278. /* stopping (enabling, adding) a watcher does nothing if it is already running */
  279. /* stopping (disabling, deleting) a watcher does nothing unless its already running */
  280. #if EV_PROTOTYPES
  281. void ev_io_start (EV_P_ struct ev_io *w);
  282. void ev_io_stop (EV_P_ struct ev_io *w);
  283. void ev_timer_start (EV_P_ struct ev_timer *w);
  284. void ev_timer_stop (EV_P_ struct ev_timer *w);
  285. /* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
  286. void ev_timer_again (EV_P_ struct ev_timer *w);
  287. void ev_periodic_start (EV_P_ struct ev_periodic *w);
  288. void ev_periodic_stop (EV_P_ struct ev_periodic *w);
  289. void ev_idle_start (EV_P_ struct ev_idle *w);
  290. void ev_idle_stop (EV_P_ struct ev_idle *w);
  291. void ev_prepare_start (EV_P_ struct ev_prepare *w);
  292. void ev_prepare_stop (EV_P_ struct ev_prepare *w);
  293. void ev_check_start (EV_P_ struct ev_check *w);
  294. void ev_check_stop (EV_P_ struct ev_check *w);
  295. /* only supported in the default loop */
  296. void ev_signal_start (EV_P_ struct ev_signal *w);
  297. void ev_signal_stop (EV_P_ struct ev_signal *w);
  298. /* only supported in the default loop */
  299. void ev_child_start (EV_P_ struct ev_child *w);
  300. void ev_child_stop (EV_P_ struct ev_child *w);
  301. #endif
  302. #ifdef __cplusplus
  303. }
  304. #endif
  305. #endif