1 /*
2 * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27 #ifndef _EVENT2_EVENT_H_
28 #define _EVENT2_EVENT_H_
29
30 /**
31 @mainpage
32
33 @section intro Introduction
34
35 Libevent is an event notification library for developing scalable network
36 servers. The Libevent API provides a mechanism to execute a callback
37 function when a specific event occurs on a file descriptor or after a
38 timeout has been reached. Furthermore, Libevent also support callbacks due
39 to signals or regular timeouts.
40
41 Libevent is meant to replace the event loop found in event driven network
42 servers. An application just needs to call event_dispatch() and then add or
43 remove events dynamically without having to change the event loop.
44
45
46 Currently, Libevent supports /dev/poll, kqueue(2), select(2), poll(2),
47 epoll(4), and evports. The internal event mechanism is completely
48 independent of the exposed event API, and a simple update of Libevent can
49 provide new functionality without having to redesign the applications. As a
50 result, Libevent allows for portable application development and provides
51 the most scalable event notification mechanism available on an operating
52 system. Libevent can also be used for multithreaded programs. Libevent
53 should compile on Linux, *BSD, Mac OS X, Solaris and, Windows.
54
55 @section usage Standard usage
56
57 Every program that uses Libevent must inclurde the <event2/event.h>
58 header, and pass the -levent flag to the linker. (You can instead link
59 -levent_core if you only want the main event and buffered IO-based code,
60 and don't want to link any protocol code.)
61
62 @section setup Library setup
63
64 Before you call any other Libevent functions, you need to set up the
65 library. If you're going to use Libevent from multiple threads in a
66 multithreaded application, you need to initialize thread support --
67 typically by using evthread_use_pthreads() or
68 evthread_use_windows_threads(). See <event2/thread.h> for more
69 information.
70
71 This is also the point where you can replace Libevent's memory
72 management functions with event_set_mem_functions, and enable debug mode
73 with event_enable_debug_mode().
74
75 @section base Creating an event base
76
77 Next, you need to create an event_base structure, using event_base_new()
78 or event_base_new_with_config(). The event_base is responsible for
79 keeping track of which events are "pending" (that is to say, being
80 watched to see if they become active) and which events are "active".
81 Every event is associated with a single event_base.
82
83 @section event Event notification
84
85 For each file descriptor that you wish to monitor, you must create an
86 event structure with event_new(). (You may also declare an event
87 structure and call event_assign() to initialize the members of the
88 structure.) To enable notification, you add the structure to the list
89 of monitored events by calling event_add(). The event structure must
90 remain allocated as long as it is active, so it should generally be
91 allocated on the heap.
92
93 @section loop Dispaching evets.
94
95 Finally, you call event_base_dispatch() to loop and dispatch events.
96 You can also use event_base_loop() for more fine-grained control.
97
98 Currently, only one thread can be dispatching a given event_base at a
99 time. If you want to run events in multiple threads at once, you can
100 either have a single event_base whose events add work to a work queue,
101 or you can create multiple event_base objects.
102
103 @section bufferevent I/O Buffers
104
105 Libevent provides a buffered I/O abstraction on top of the regular event
106 callbacks. This abstraction is called a bufferevent. A bufferevent
107 provides input and output buffers that get filled and drained
108 automatically. The user of a buffered event no longer deals directly
109 with the I/O, but instead is reading from input and writing to output
110 buffers.
111
112 Once initialized via bufferevent_socket_new(), the bufferevent structure
113 can be used repeatedly with bufferevent_enable() and
114 bufferevent_disable(). Instead of reading and writing directly to a
115 socket, you would call bufferevent_read() and bufferevent_write().
116
117 When read enabled the bufferevent will try to read from the file descriptor
118 and call the read callback. The write callback is executed whenever the
119 output buffer is drained below the write low watermark, which is 0 by
120 default.
121
122 See <event2/bufferevent*.h> for more information.
123
124 @section timers Timers
125
126 Libevent can also be used to create timers that invoke a callback after a
127 certain amount of time has expired. The evtimer_new() function returns
128 an event struct to use as a timer. To activate the timer, call
129 evtimer_add(). Timers can be deactivated by calling evtimer_del().
130
131 @section evdns Asynchronous DNS resolution
132
133 Libevent provides an asynchronous DNS resolver that should be used instead
134 of the standard DNS resolver functions. See the <event2/dns.h>
135 functions for more detail.
136
137 @section evhttp Event-driven HTTP servers
138
139 Libevent provides a very simple event-driven HTTP server that can be
140 embedded in your program and used to service HTTP requests.
141
142 To use this capability, you need to include the <event2/http.h> header in your
143 program. See that header for more information.
144
145 @section evrpc A framework for RPC servers and clients
146
147 Libevent provides a framework for creating RPC servers and clients. It
148 takes care of marshaling and unmarshaling all data structures.
149
150 @section api API Reference
151
152 To browse the complete documentation of the libevent API, click on any of
153 the following links.
154
155 event2/event.h
156 The primary libevent header
157
158 event2/thread.h
159 Functions for use by multithreaded programs
160
161 event2/buffer.h and event2/bufferevent.h
162 Buffer management for network reading and writing
163
164 event2/util.h
165 Utility functions for portable nonblocking network code
166
167 event2/dns.h
168 Asynchronous DNS resolution
169
170 event2/http.h
171 An embedded libevent-based HTTP server
172
173 event2/rpc.h
174 A framework for creating RPC servers and clients
175
176 */
177
178 /** @file event2/event.h
179
180 Core functions for waiting for and receiving events, and using event bases.
181 */
182
183 #ifdef __cplusplus
184 extern "C" {
185 #endif
186
187 /**** OMPI CHANGE ****/
188 #include "opal_rename.h"
189 /**** END OMPI CHANGE ****/
190
191 #include <event2/event-config.h>
192 #ifdef _EVENT_HAVE_SYS_TYPES_H
193 #include <sys/types.h>
194 #endif
195 #ifdef _EVENT_HAVE_SYS_TIME_H
196 #include <sys/time.h>
197 #endif
198
199 #include <stdio.h>
200
201 /* For int types. */
202 #include <event2/util.h>
203
204 /**
205 * Structure to hold information and state for a Libevent dispatch loop.
206 *
207 * The event_base lies at the center of Libevent; every application will
208 * have one. It keeps track of all pending and active events, and
209 * notifies your application of the active ones.
210 *
211 * This is an opaque structure; you can allocate one using
212 * event_base_new() or event_base_new_with_config().
213 *
214 * @see event_base_new(), event_base_free(), event_base_loop(),
215 * event_base_new_with_config()
216 */
217 struct event_base
218 #ifdef _EVENT_IN_DOXYGEN
219 {/*Empty body so that doxygen will generate documentation here.*/}
220 #endif
221 ;
222
223 /**
224 * @struct event
225 *
226 * Structure to represent a single event.
227 *
228 * An event can have some underlying condition it represents: a socket
229 * becoming readable or writeable (or both), or a signal becoming raised.
230 * (An event that represents no underlying condition is still useful: you
231 * can use one to implement a timer, or to communicate between threads.)
232 *
233 * Generally, you can create events with event_new(), then make them
234 * pending with event_add(). As your event_base runs, it will run the
235 * callbacks of an events whose conditions are triggered. When you
236 * longer want the event, free it with event_free().
237 *
238 * In more depth:
239 *
240 * An event may be "pending" (one whose condition we are watching),
241 * "active" (one whose condition has triggered and whose callback is about
242 * to run), neither, or both. Events come into existence via
243 * event_assign() or event_new(), and are then neither active nor pending.
244 *
245 * To make an event pending, pass it to event_add(). When doing so, you
246 * can also set a timeout for the event.
247 *
248 * Events become active during an event_base_loop() call when either their
249 * condition has triggered, or when their timeout has elapsed. You can
250 * also activate an event manually using event_active(). The even_base
251 * loop will run the callbacks of active events; after it has done so, it
252 * marks them as no longer active.
253 *
254 * You can make an event non-pending by passing it to event_del(). This
255 * also makes the event non-active.
256 *
257 * Events can be "persistent" or "non-persistent". A non-persistent event
258 * becomes non-pending as soon as it is triggered: thus, it only runs at
259 * most once per call to event_add(). A persistent event remains pending
260 * even when it becomes active: you'll need to event_del() it manually in
261 * order to make it non-pending. When a persistent event with a timeout
262 * becomes active, its timeout is reset: this means you can use persistent
263 * events to implement periodic timeouts.
264 *
265 * This should be treated as an opaque structure; you should never read or
266 * write any of its fields directly. For backward compatibility with old
267 * code, it is defined in the event2/event_struct.h header; including this
268 * header may make your code incompatible with other versions of Libevent.
269 *
270 * @see event_new(), event_free(), event_assign(), event_get_assignment(),
271 * event_add(), event_del(), event_active(), event_pending(),
272 * event_get_fd(), event_get_base(), event_get_events(),
273 * event_get_callback(), event_get_callback_arg(),
274 * event_priority_set()
275 */
276 struct event
277 #ifdef _EVENT_IN_DOXYGEN
278 {/*Empty body so that doxygen will generate documentation here.*/}
279 #endif
280 ;
281
282 /**
283 * Configuration for an event_base.
284 *
285 * There are many options that can be used to alter the behavior and
286 * implementation of an event_base. To avoid having to pass them all in a
287 * complex many-argument constructor, we provide an abstract data type
288 * wrhere you set up configation information before passing it to
289 * event_base_new_with_config().
290 *
291 * @see event_config_new(), event_config_free(), event_base_new_with_config(),
292 * event_config_avoid_method(), event_config_require_features(),
293 * event_config_set_flag(), event_config_set_num_cpus_hint()
294 */
295 struct event_config
296 #ifdef _EVENT_IN_DOXYGEN
297 {/*Empty body so that doxygen will generate documentation here.*/}
298 #endif
299 ;
300
301 /**
302 * Enable some relatively expensive debugging checks in Libevent that
303 * would normally be turned off. Generally, these checks cause code that
304 * would otherwise crash mysteriously to fail earlier with an assertion
305 * failure. Note that this method MUST be called before any events or
306 * event_bases have been created.
307 *
308 * Debug mode can currently catch the following errors:
309 * An event is re-assigned while it is added
310 * Any function is called on a non-assigned event
311 *
312 * Note that debugging mode uses memory to track every event that has been
313 * initialized (via event_assign, event_set, or event_new) but not yet
314 * released (via event_free or event_debug_unassign). If you want to use
315 * debug mode, and you find yourself running out of memory, you will need
316 * to use event_debug_unassign to explicitly stop tracking events that
317 * are no longer considered set-up.
318 *
319 * @see event_debug_unassign()
320 */
321 void event_enable_debug_mode(void);
322
323 /**** OMPI CHANGE ****/
324 void event_set_debug_output(int output);
325 /**** END OMPI CHANGE ****/
326
327 /**
328 * When debugging mode is enabled, informs Libevent that an event should no
329 * longer be considered as assigned. When debugging mode is not enabled, does
330 * nothing.
331 *
332 * This function must only be called on a non-added event.
333 *
334 * @see event_enable_debug_mode()
335 */
336 void event_debug_unassign(struct event *);
337
338 /**
339 * Create and return a new event_base to use with the rest of Libevent.
340 *
341 * @return a new event_base on success, or NULL on failure.
342 *
343 * @see event_base_free(), event_base_new_with_config()
344 */
345 struct event_base *event_base_new(void);
346
347 /**
348 Reinitialize the event base after a fork
349
350 Some event mechanisms do not survive across fork. The event base needs
351 to be reinitialized with the event_reinit() function.
352
353 @param base the event base that needs to be re-initialized
354 @return 0 if successful, or -1 if some events could not be re-added.
355 @see event_base_new()
356 */
357 int event_reinit(struct event_base *base);
358
359 /**
360 Event dispatching loop
361
362 This loop will run the event base until either there are no more added
363 events, or until something calls event_base_loopbreak() or
364 event_base_loopexit().
365
366 @param base the event_base structure returned by event_base_new() or
367 event_base_new_with_config()
368 @return 0 if successful, -1 if an error occurred, or 1 if no events were
369 registered.
370 @see event_base_loop()
371 */
372 int event_base_dispatch(struct event_base *);
373
374 /**
375 Get the kernel event notification mechanism used by Libevent.
376
377 @param eb the event_base structure returned by event_base_new()
378 @return a string identifying the kernel event mechanism (kqueue, epoll, etc.)
379 */
380 const char *event_base_get_method(const struct event_base *);
381
382 /**
383 Gets all event notification mechanisms supported by Libevent.
384
385 This functions returns the event mechanism in order preferred by
386 Libevent. Note that this list will include all backends that
387 Libevent has compiled-in support for, and will not necessarily check
388 your OS to see whether it has the required resources.
389
390 @return an array with pointers to the names of support methods.
391 The end of the array is indicated by a NULL pointer. If an
392 error is encountered NULL is returned.
393 */
394 const char **event_get_supported_methods(void);
395
396 /**
397 Allocates a new event configuration object.
398
399 The event configuration object can be used to change the behavior of
400 an event base.
401
402 @return an event_config object that can be used to store configuration, or
403 NULL if an error is encountered.
404 @see event_base_new_with_config(), event_config_free(), event_config
405 */
406 struct event_config *event_config_new(void);
407
408 /**
409 Deallocates all memory associated with an event configuration object
410
411 @param cfg the event configuration object to be freed.
412 */
413 void event_config_free(struct event_config *cfg);
414
415 /**
416 Enters an event method that should be avoided into the configuration.
417
418 This can be used to avoid event mechanisms that do not support certain
419 file descriptor types, or for debugging to avoid certain event
420 mechanisms. An application can make use of multiple event bases to
421 accommodate incompatible file descriptor types.
422
423 @param cfg the event configuration object
424 @param method the name of the event method to avoid
425 @return 0 on success, -1 on failure.
426 */
427 int event_config_avoid_method(struct event_config *cfg, const char *method);
428
429 /**
430 A flag used to describe which features an event_base (must) provide.
431
432 Because of OS limitations, not every Libevent backend supports every
433 possible feature. You can use this type with
434 event_config_require_features() to tell Libevent to only proceed if your
435 event_base implements a given feature, and you can receive this type from
436 event_base_get_features() to see which features are available.
437 */
438 enum event_method_feature {
439 /** Require an event method that allows edge-triggered events with EV_ET. */
440 EV_FEATURE_ET = 0x01,
441 /** Require an event method where having one event triggered among
442 * many is [approximately] an O(1) operation. This excludes (for
443 * example) select and poll, which are approximately O(N) for N
444 * equal to the total number of possible events. */
445 EV_FEATURE_O1 = 0x02,
446 /** Require an event method that allows file descriptors as well as
447 * sockets. */
448 EV_FEATURE_FDS = 0x04
449 };
450
451 /**
452 A flag passed to event_config_set_flag().
453
454 These flags change the behavior of an allocated event_base.
455
456 @see event_config_set_flag(), event_base_new_with_config(),
457 event_method_feature
458 */
459 enum event_base_config_flag {
460 /** Do not allocate a lock for the event base, even if we have
461 locking set up. */
462 EVENT_BASE_FLAG_NOLOCK = 0x01,
463 /** Do not check the EVENT_* environment variables when configuring
464 an event_base */
465 EVENT_BASE_FLAG_IGNORE_ENV = 0x02,
466 /** Windows only: enable the IOCP dispatcher at startup
467
468 If this flag is set then bufferevent_socket_new() and
469 evconn_listener_new() will use IOCP-backed implementations
470 instead of the usual select-based one on Windows.
471 */
472 EVENT_BASE_FLAG_STARTUP_IOCP = 0x04,
473 /** Instead of checking the current time every time the event loop is
474 ready to run timeout callbacks, check after each timeout callback.
475 */
476 EVENT_BASE_FLAG_NO_CACHE_TIME = 0x08,
477
478 /** If we are using the epoll backend, this flag says that it is
479 safe to use Libevent's internal change-list code to batch up
480 adds and deletes in order to try to do as few syscalls as
481 possible. Setting this flag can make your code run faster, but
482 it may trigger a Linux bug: it is not safe to use this flag
483 if you have any fds cloned by dup() or its variants. Doing so
484 will produce strange and hard-to-diagnose bugs.
485
486 This flag can also be activated by settnig the
487 EVENT_EPOLL_USE_CHANGELIST environment variable.
488
489 This flag has no effect if you wind up using a backend other than
490 epoll.
491 */
492 EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST = 0x10
493 };
494
495 /**
496 Return a bitmask of the features implemented by an event base. This
497 will be a bitwise OR of one or more of the values of
498 event_method_feature
499
500 @see event_method_feature
501 */
502 int event_base_get_features(const struct event_base *base);
503
504 /**
505 Enters a required event method feature that the application demands.
506
507 Note that not every feature or combination of features is supported
508 on every platform. Code that requests features should be prepared
509 to handle the case where event_base_new_with_config() returns NULL, as in:
510 <pre>
511 event_config_require_features(cfg, EV_FEATURE_ET);
512 base = event_base_new_with_config(cfg);
513 if (base == NULL) {
514 // We can't get edge-triggered behavior here.
515 event_config_require_features(cfg, 0);
516 base = event_base_new_with_config(cfg);
517 }
518 </pre>
519
520 @param cfg the event configuration object
521 @param feature a bitfield of one or more event_method_feature values.
522 Replaces values from previous calls to this function.
523 @return 0 on success, -1 on failure.
524 @see event_method_feature, event_base_new_with_config()
525 */
526 int event_config_require_features(struct event_config *cfg, int feature);
527
528 /**
529 * Sets one or more flags to configure what parts of the eventual event_base
530 * will be initialized, and how they'll work.
531 *
532 * @see event_base_config_flags, event_base_new_with_config()
533 **/
534 int event_config_set_flag(struct event_config *cfg, int flag);
535
536 /**
537 * Records a hint for the number of CPUs in the system. This is used for
538 * tuning thread pools, etc, for optimal performance. In Libevent 2.0,
539 * it is only on Windows, and only when IOCP is in use.
540 *
541 * @param cfg the event configuration object
542 * @param cpus the number of cpus
543 * @return 0 on success, -1 on failure.
544 */
545 int event_config_set_num_cpus_hint(struct event_config *cfg, int cpus);
546
547 /**
548 Initialize the event API.
549
550 Use event_base_new_with_config() to initialize a new event base, taking
551 the specified configuration under consideration. The configuration object
552 can currently be used to avoid certain event notification mechanisms.
553
554 @param cfg the event configuration object
555 @return an initialized event_base that can be used to registering events,
556 or NULL if no event base can be created with the requested event_config.
557 @see event_base_new(), event_base_free(), event_init(), event_assign()
558 */
559 struct event_base *event_base_new_with_config(const struct event_config *);
560
561 /**
562 Deallocate all memory associated with an event_base, and free the base.
563
564 Note that this function will not close any fds or free any memory passed
565 to event_new as the argument to callback.
566
567 @param eb an event_base to be freed
568 */
569 void event_base_free(struct event_base *);
570
571 /** @name Log severities
572 */
573 /**@{*/
574 #define EVENT_LOG_DEBUG 0
575 #define EVENT_LOG_MSG 1
576 #define EVENT_LOG_WARN 2
577 #define EVENT_LOG_ERR 3
578 /**@}*/
579
580 /* Obsolete names: these are deprecated, but older programs might use them.
581 * They violate the reserved-identifier namespace. */
582 #define _EVENT_LOG_DEBUG EVENT_LOG_DEBUG
583 #define _EVENT_LOG_MSG EVENT_LOG_MSG
584 #define _EVENT_LOG_WARN EVENT_LOG_WARN
585 #define _EVENT_LOG_ERR EVENT_LOG_ERR
586
587 /**
588 A callback function used to intercept Libevent's log messages.
589
590 @see event_set_log_callback
591 */
592 typedef void (*event_log_cb)(int severity, const char *msg);
593 /**
594 Redirect Libevent's log messages.
595
596 @param cb a function taking two arguments: an integer severity between
597 _EVENT_LOG_DEBUG and _EVENT_LOG_ERR, and a string. If cb is NULL,
598 then the default log is used.
599
600 NOTE: The function you provide *must not* call any other libevent
601 functionality. Doing so can produce undefined behavior.
602 */
603 void event_set_log_callback(event_log_cb cb);
604
605 /**
606 A function to be called if Libevent encounters a fatal internal error.
607
608 @see event_set_fatal_callback
609 */
610 typedef void (*event_fatal_cb)(int err);
611
612 /**
613 Override Libevent's behavior in the event of a fatal internal error.
614
615 By default, Libevent will call exit(1) if a programming error makes it
616 impossible to continue correct operation. This function allows you to supply
617 another callback instead. Note that if the function is ever invoked,
618 something is wrong with your program, or with Libevent: any subsequent calls
619 to Libevent may result in undefined behavior.
620
621 Libevent will (almost) always log an _EVENT_LOG_ERR message before calling
622 this function; look at the last log message to see why Libevent has died.
623 */
624 void event_set_fatal_callback(event_fatal_cb cb);
625
626 /**
627 Associate a different event base with an event.
628
629 The event to be associated must not be currently active or pending.
630
631 @param eb the event base
632 @param ev the event
633 @return 0 on success, -1 on failure.
634 */
635 int event_base_set(struct event_base *, struct event *);
636
637 /** @name Loop flags
638
639 These flags control the behavior of event_base_loop().
640 */
641 /**@{*/
642 /** Block until we have an active event, then exit once all active events
643 * have had their callbacks run. */
644 #define EVLOOP_ONCE 0x01
645 /** Do not block: see which events are ready now, run the callbacks
646 * of the highest-priority ones, then exit. */
647 #define EVLOOP_NONBLOCK 0x02
648 /**@}*/
649
650 /**
651 Wait for events to become active, and run their callbacks.
652
653 This is a more flexible version of event_base_dispatch().
654
655 By default, this loop will run the event base until either there are no more
656 added events, or until something calls event_base_loopbreak() or
657 evenet_base_loopexit(). You can override this behavior with the 'flags'
658 argument.
659
660 @param eb the event_base structure returned by event_base_new() or
661 event_base_new_with_config()
662 @param flags any combination of EVLOOP_ONCE | EVLOOP_NONBLOCK
663 @return 0 if successful, -1 if an error occurred, or 1 if no events were
664 registered.
665 @see event_base_loopexit(), event_base_dispatch(), EVLOOP_ONCE,
666 EVLOOP_NONBLOCK
667 */
668 int event_base_loop(struct event_base *, int);
669
670 /**
671 Exit the event loop after the specified time
672
673 The next event_base_loop() iteration after the given timer expires will
674 complete normally (handling all queued events) then exit without
675 blocking for events again.
676
677 Subsequent invocations of event_base_loop() will proceed normally.
678
679 @param eb the event_base structure returned by event_init()
680 @param tv the amount of time after which the loop should terminate,
681 or NULL to exit after running all currently active events.
682 @return 0 if successful, or -1 if an error occurred
683 @see event_base_loopbreak()
684 */
685 int event_base_loopexit(struct event_base *, const struct timeval *);
686
687 /**
688 Abort the active event_base_loop() immediately.
689
690 event_base_loop() will abort the loop after the next event is completed;
691 event_base_loopbreak() is typically invoked from this event's callback.
692 This behavior is analogous to the "break;" statement.
693
694 Subsequent invocations of event_loop() will proceed normally.
695
696 @param eb the event_base structure returned by event_init()
697 @return 0 if successful, or -1 if an error occurred
698 @see event_base_loopexit()
699 */
700 int event_base_loopbreak(struct event_base *);
701
702 /**
703 Checks if the event loop was told to exit by event_loopexit().
704
705 This function will return true for an event_base at every point after
706 event_loopexit() is called, until the event loop is next entered.
707
708 @param eb the event_base structure returned by event_init()
709 @return true if event_base_loopexit() was called on this event base,
710 or 0 otherwise
711 @see event_base_loopexit()
712 @see event_base_got_break()
713 */
714 int event_base_got_exit(struct event_base *);
715
716 /**
717 Checks if the event loop was told to abort immediately by event_loopbreak().
718
719 This function will return true for an event_base at every point after
720 event_loopbreak() is called, until the event loop is next entered.
721
722 @param eb the event_base structure returned by event_init()
723 @return true if event_base_loopbreak() was called on this event base,
724 or 0 otherwise
725 @see event_base_loopbreak()
726 @see event_base_got_exit()
727 */
728 int event_base_got_break(struct event_base *);
729
730 /**
731 * @name event flags
732 *
733 * Flags to pass to event_new(), event_assign(), event_pending(), and
734 * anything else with an argument of the form "short events"
735 */
736 /**@{*/
737 /** Indicates that a timeout has occurred. It's not necessary to pass
738 * this flag to event_for new()/event_assign() to get a timeout. */
739 #define EV_TIMEOUT 0x01
740 /** Wait for a socket or FD to become readable */
741 #define EV_READ 0x02
742 /** Wait for a socket or FD to become writeable */
743 #define EV_WRITE 0x04
744 /** Wait for a POSIX signal to be raised*/
745 #define EV_SIGNAL 0x08
746 /**
747 * Persistent event: won't get removed automatically when activated.
748 *
749 * When a persistent event with a timeout becomes activated, its timeout
750 * is reset to 0.
751 */
752 #define EV_PERSIST 0x10
753 /** Select edge-triggered behavior, if supported by the backend. */
754 #define EV_ET 0x20
755 /**@}*/
756
757 /**
758 @name evtimer_* macros
759
760 Aliases for working with one-shot timer events */
761 /**@{*/
762 #define evtimer_assign(ev, b, cb, arg) \
763 event_assign((ev), (b), -1, 0, (cb), (arg))
764 #define evtimer_new(b, cb, arg) event_new((b), -1, 0, (cb), (arg))
765 #define evtimer_add(ev, tv) event_add((ev), (tv))
766 #define evtimer_del(ev) event_del(ev)
767 #define evtimer_pending(ev, tv) event_pending((ev), EV_TIMEOUT, (tv))
768 #define evtimer_initialized(ev) event_initialized(ev)
769 /**@}*/
770
771 /**
772 @name evsignal_* macros
773
774 Aliases for working with signal events
775 */
776 /**@{*/
777 #define evsignal_add(ev, tv) event_add((ev), (tv))
778 #define evsignal_assign(ev, b, x, cb, arg) \
779 event_assign((ev), (b), (x), EV_SIGNAL|EV_PERSIST, cb, (arg))
780 #define evsignal_new(b, x, cb, arg) \
781 event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
782 #define evsignal_del(ev) event_del(ev)
783 #define evsignal_pending(ev, tv) event_pending((ev), EV_SIGNAL, (tv))
784 #define evsignal_initialized(ev) event_initialized(ev)
785 /**@}*/
786
787 /**
788 A callback function for an event.
789
790 It receives three arguments:
791
792 @param fd An fd or signal
793 @param events One or more EV_* flags
794 @param arg A user-supplied argument.
795
796 @see event_new()
797 */
798 typedef void (*event_callback_fn)(evutil_socket_t, short, void *);
799
800 /**
801 Allocate and asssign a new event structure, ready to be added.
802
803 The function event_new() returns a new event that can be used in
804 future calls to event_add() and event_del(). The fd and events
805 arguments determine which conditions will trigger the event; the
806 callback and callback_arg arguments tell Libevent what to do when the
807 event becomes active.
808
809 If events contains one of EV_READ, EV_WRITE, or EV_READ|EV_WRITE, then
810 fd is a file descriptor or socket that should get monitored for
811 readiness to read, readiness to write, or readiness for either operation
812 (respectively). If events contains EV_SIGNAL, then fd is a signal
813 number to wait for. If events contains none of those flags, then the
814 event can be triggered only by a timeout or by manual activation with
815 event_active(): In this case, fd must be -1.
816
817 The EV_PERSIST flag can also be passed in the events argument: it makes
818 event_add() persistent until event_del() is called.
819
820 The EV_ET flag is compatible with EV_READ and EV_WRITE, and supported
821 only by certain backends. It tells Libevent to use edge-triggered
822 events.
823
824 The EV_TIMEOUT flag has no effect here.
825
826 It is okay to have multiple events all listening on the same fds; but
827 they must either all be edge-triggered, or all not be edge triggerd.
828
829 When the event becomes active, the event loop will run the provided
830 callbuck function, with three arguments. The first will be the provided
831 fd value. The second will be a bitfield of the events that triggered:
832 EV_READ, EV_WRITE, or EV_SIGNAL. Here the EV_TIMEOUT flag indicates
833 that a timeout occurred, and EV_ET indicates that an edge-triggered
834 event occurred. The third event will be the callback_arg pointer that
835 you provide.
836
837 @param base the event base to which the event should be attached.
838 @param fd the file descriptor or signal to be monitored, or -1.
839 @param events desired events to monitor: bitfield of EV_READ, EV_WRITE,
840 EV_SIGNAL, EV_PERSIST, EV_ET.
841 @param callback callback function to be invoked when the event occurs
842 @param callback_arg an argument to be passed to the callback function
843
844 @return a newly allocated struct event that must later be freed with
845 event_free().
846 @see event_free(), event_add(), event_del(), event_assign()
847 */
848 struct event *event_new(struct event_base *, evutil_socket_t, short, event_callback_fn, void *);
849
850
851 /**
852 Prepare a new, already-allocated event structure to be added.
853
854 The function event_assign() prepares the event structure ev to be used
855 in future calls to event_add() and event_del(). Unlike event_new(), it
856 doesn't allocate memory itself: it requires that you have already
857 allocated a struct event, probably on the heap. Doing this will
858 typically make your code depend on the size of the event structure, and
859 thereby create incompatibility with future versions of Libevent.
860
861 The easiest way to avoid this problem is just to use event_new() and
862 event_free() instead.
863
864 A slightly harder way to future-proof your code is to use
865 event_get_struct_event_size() to determine the required size of an event
866 at runtime.
867
868 Note that it is NOT safe to call this function on an event that is
869 active or pending. Doing so WILL corrupt internal data structures in
870 Libevent, and lead to strange, hard-to-diagnose bugs. You _can_ use
871 event_assign to change an existing event, but only if it is not active
872 or pending!
873
874 The arguments for this function, and the behavior of the events that it
875 makes, are as for event_new().
876
877 @param ev an event struct to be modified
878 @param base the event base to which ev should be attached.
879 @param fd the file descriptor to be monitored
880 @param events desired events to monitor; can be EV_READ and/or EV_WRITE
881 @param callback callback function to be invoked when the event occurs
882 @param callback_arg an argument to be passed to the callback function
883
884 @return 0 if success, or -1 on invalid arguments.
885
886 @see event_new(), event_add(), event_del(), event_base_once(),
887 event_get_struct_event_size()
888 */
889 int event_assign(struct event *, struct event_base *, evutil_socket_t, short, event_callback_fn, void *);
890
891 /**
892 Deallocate a struct event * returned by event_new().
893
894 If the event is pending or active, first make it non-pending and
895 non-active.
896 */
897 void event_free(struct event *);
898
899 /**
900 Schedule a one-time event
901
902 The function event_base_once() is similar to event_set(). However, it
903 schedules a callback to be called exactly once, and does not require the
904 caller to prepare an event structure.
905
906 Note that in Libevent 2.0 and earlier, if the event is never triggered,
907 the internal memory used to hold it will never be freed. This may be
908 fixed in a later version of Libevent.
909
910 @param base an event_base
911 @param fd a file descriptor to monitor, or -1 for no fd.
912 @param events event(s) to monitor; can be any of EV_READ |
913 EV_WRITE, or EV_TIMEOUT
914 @param callback callback function to be invoked when the event occurs
915 @param arg an argument to be passed to the callback function
916 @param timeout the maximum amount of time to wait for the event. NULL
917 makes an EV_READ/EV_WRITE event make forever; NULL makes an
918 EV_TIMEOUT event succees immediately.
919 @return 0 if successful, or -1 if an error occurred
920 */
921 int event_base_once(struct event_base *, evutil_socket_t, short, event_callback_fn, void *, const struct timeval *);
922
923 /**
924 Add an event to the set of pending events.
925
926 The function event_add() schedules the execution of the ev event when the
927 event specified in event_assign()/event_new() occurs, or when the time
928 specified in timeout has elapesed. If atimeout is NULL, no timeout
929 occurs and the function will only be
930 called if a matching event occurs. The event in the
931 ev argument must be already initialized by event_assign() or event_new()
932 and may not be used
933 in calls to event_assign() until it is no longer pending.
934
935 If the event in the ev argument already has a scheduled timeout, calling
936 event_add() replaces the old timeout with the new one, or clears the old
937 timeout if the timeout argument is NULL.
938
939 @param ev an event struct initialized via event_set()
940 @param timeout the maximum amount of time to wait for the event, or NULL
941 to wait forever
942 @return 0 if successful, or -1 if an error occurred
943 @see event_del(), event_assign(), event_new()
944 */
945 int event_add(struct event *ev, const struct timeval *timeout);
946
947 /**
948 Remove an event from the set of monitored events.
949
950 The function event_del() will cancel the event in the argument ev. If the
951 event has already executed or has never been added the call will have no
952 effect.
953
954 @param ev an event struct to be removed from the working set
955 @return 0 if successful, or -1 if an error occurred
956 @see event_add()
957 */
958 int event_del(struct event *);
959
960
961 /**
962 Make an event active.
963
964 You can use this function on a pending or a non-pending event to make it
965 active, so that its callback will be run by event_base_dispatch() or
966 event_base_loop().
967
968 One common use in multithreaded programs is to wake the thread running
969 event_base_loop() from another thread.
970
971 @param ev an event to make active.
972 @param res a set of flags to pass to the event's callback.
973 @param ncalls an obsolete argument: this is ignored.
974 **/
975 void event_active(struct event *ev, int res, short ncalls);
976
977 /**
978 Checks if a specific event is pending or scheduled.
979
980 @param ev an event struct previously passed to event_add()
981 @param events the requested event type; any of EV_TIMEOUT|EV_READ|
982 EV_WRITE|EV_SIGNAL
983 @param tv if this field is not NULL, and the event has a timeout,
984 this field is set to hold the time at which the timeout will
985 expire.
986
987 @return true if the event is pending on any of the events in 'what', (that
988 is to say, it has been added), or 0 if the event is not added.
989 */
990 int event_pending(const struct event *ev, short events, struct timeval *tv);
991
992
993 /**
994 Test if an event structure might be initialized.
995
996 The event_initialized() function can be used to check if an event has been
997 initialized.
998
999 Warning: This function is only useful for distinguishing a a zeroed-out
1000 piece of memory from an initialized event, it can easily be confused by
1001 uninitialized memory. Thus, it should ONLY be used to distinguish an
1002 initialized event from zero.
1003
1004 @param ev an event structure to be tested
1005 @return 1 if the structure might be initialized, or 0 if it has not been
1006 initialized
1007 */
1008 int event_initialized(const struct event *ev);
1009
1010 /**
1011 Get the signal number assigned to a signal event
1012 */
1013 #define event_get_signal(ev) ((int)event_get_fd(ev))
1014
1015 /**
1016 Get the socket or signal assigned to an event, or -1 if the event has
1017 no socket.
1018 */
1019 evutil_socket_t event_get_fd(const struct event *ev);
1020
1021 /**
1022 Get the event_base associated with an event.
1023 */
1024 struct event_base *event_get_base(const struct event *ev);
1025
1026 /**
1027 Return the events (EV_READ, EV_WRITE, etc) assigned to an event.
1028 */
1029 short event_get_events(const struct event *ev);
1030
1031 /**
1032 Return the callback assigned to an event.
1033 */
1034 event_callback_fn event_get_callback(const struct event *ev);
1035
1036 /**
1037 Return the callback argument assigned to an event.
1038 */
1039 void *event_get_callback_arg(const struct event *ev);
1040
1041 /**
1042 Extract _all_ of arguments given to construct a given event. The
1043 event_base is copied into *base_out, the fd is copied into *fd_out, and so
1044 on.
1045
1046 If any of the "_out" arguments is NULL, it will be ignored.
1047 */
1048 void event_get_assignment(const struct event *event,
1049 struct event_base **base_out, evutil_socket_t *fd_out, short *events_out,
1050 event_callback_fn *callback_out, void **arg_out);
1051
1052 /**
1053 Return the size of struct event that the Libevent library was compiled
1054 with.
1055
1056 This will be NO GREATER than sizeof(struct event) if you're running with
1057 the same version of Libevent that your application was built with, but
1058 otherwise might not.
1059
1060 Note that it might be SMALLER than sizeof(struct event) if some future
1061 version of Libevent adds extra padding to the end of struct event.
1062 We might do this to help ensure ABI-compatibility between different
1063 versions of Libevent.
1064 */
1065 size_t event_get_struct_event_size(void);
1066
1067 /**
1068 Get the Libevent version.
1069
1070 Note that this will give you the version of the library that you're
1071 currently linked against, not the version of the headers that you've
1072 compiled against.
1073
1074 @return a string containing the version number of Libevent
1075 */
1076 const char *event_get_version(void);
1077
1078 /**
1079 Return a numeric representation of Libevent's version.
1080
1081 Note that this will give you the version of the library that you're
1082 currently linked against, not the version of the headers you've used to
1083 compile.
1084
1085 The format uses one byte each for the major, minor, and patchlevel parts of
1086 the version number. The low-order byte is unused. For example, version
1087 2.0.1-alpha has a numeric representation of 0x02000100
1088 */
1089 ev_uint32_t event_get_version_number(void);
1090
1091 /** As event_get_version, but gives the version of Libevent's headers. */
1092 #define LIBEVENT_VERSION _EVENT_VERSION
1093 /** As event_get_version_number, but gives the version number of Libevent's
1094 * headers. */
1095 #define LIBEVENT_VERSION_NUMBER _EVENT_NUMERIC_VERSION
1096
1097 /** Largest number of priorities that Libevent can support. */
1098 #define EVENT_MAX_PRIORITIES 256
1099 /**
1100 Set the number of different event priorities
1101
1102 By default Libevent schedules all active events with the same priority.
1103 However, some time it is desirable to process some events with a higher
1104 priority than others. For that reason, Libevent supports strict priority
1105 queues. Active events with a lower priority are always processed before
1106 events with a higher priority.
1107
1108 The number of different priorities can be set initially with the
1109 event_base_priority_init() function. This function should be called
1110 before the first call to event_base_dispatch(). The
1111 event_priority_set() function can be used to assign a priority to an
1112 event. By default, Libevent assigns the middle priority to all events
1113 unless their priority is explicitly set.
1114
1115 Note that urgent-priority events can starve less-urgent events: after
1116 running all urgent-priority callbacks, Libevent checks for more urgent
1117 events again, before running less-urgent events. Less-urgent events
1118 will not have their callbacks run until there are no events more urgent
1119 than them that want to be active.
1120
1121 @param eb the event_base structure returned by event_base_new()
1122 @param npriorities the maximum number of priorities
1123 @return 0 if successful, or -1 if an error occurred
1124 @see event_priority_set()
1125 */
1126 int event_base_priority_init(struct event_base *, int);
1127
1128 /**
1129 Assign a priority to an event.
1130
1131 @param ev an event struct
1132 @param priority the new priority to be assigned
1133 @return 0 if successful, or -1 if an error occurred
1134 @see event_priority_init()
1135 */
1136 int event_priority_set(struct event *, int);
1137
1138 /**
1139 Prepare an event_base to use a large number of timeouts with the same
1140 duration.
1141
1142 Libevent's default scheduling algorithm is optimized for having a large
1143 number of timeouts with their durations more or less randomly
1144 distributed. But if you have a large number of timeouts that all have
1145 the same duration (for example, if you have a large number of
1146 connections that all have a 10-second timeout), then you can improve
1147 Libevent's performance by telling Libevent about it.
1148
1149 To do this, call this function with the common duration. It will return a
1150 pointer to a different, opaque timeout value. (Don't depend on its actual
1151 contents!) When you use this timeout value in event_add(), Libevent will
1152 schedule the event more efficiently.
1153
1154 (This optimization probably will not be worthwhile until you have thousands
1155 or tens of thousands of events with the same timeout.)
1156 */
1157 const struct timeval *event_base_init_common_timeout(struct event_base *base,
1158 const struct timeval *duration);
1159
1160 #if !defined(_EVENT_DISABLE_MM_REPLACEMENT) || defined(_EVENT_IN_DOXYGEN)
1161 /**
1162 Override the functions that Libevent uses for memory management.
1163
1164 Usually, Libevent uses the standard libc functions malloc, realloc, and
1165 free to allocate memory. Passing replacements for those functions to
1166 event_set_mem_functions() overrides this behavior.
1167
1168 Note that all memory returned from Libevent will be allocated by the
1169 replacement functions rather than by malloc() and realloc(). Thus, if you
1170 have replaced those functions, it will not be appropriate to free() memory
1171 that you get from Libevent. Instead, you must use the free_fn replacement
1172 that you provided.
1173
1174 Note also that if you are going to call this function, you should do so
1175 before any call to any Libevent function that does allocation.
1176 Otherwise, those funtions will allocate their memory using malloc(), but
1177 then later free it using your provided free_fn.
1178
1179 @param malloc_fn A replacement for malloc.
1180 @param realloc_fn A replacement for realloc
1181 @param free_fn A replacement for free.
1182 **/
1183 void event_set_mem_functions(
1184 void *(*malloc_fn)(size_t sz),
1185 void *(*realloc_fn)(void *ptr, size_t sz),
1186 void (*free_fn)(void *ptr));
1187 /** This definition is present if Libevent was built with support for
1188 event_set_mem_functions() */
1189 #define EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
1190 #endif
1191
1192 void event_base_dump_events(struct event_base *, FILE *);
1193
1194 /** Sets 'tv' to the current time (as returned by gettimeofday()),
1195 looking at the cached value in 'base' if possible, and calling
1196 gettimeofday() or clock_gettime() as appropriate if there is no
1197 cached time.
1198
1199 Generally, this value will only be cached while actually
1200 processing event callbacks, and may be very inaccuate if your
1201 callbacks take a long time to execute.
1202
1203 Returns 0 on success, negative on failure.
1204 */
1205 int event_base_gettimeofday_cached(struct event_base *base,
1206 struct timeval *tv);
1207
1208 #ifdef __cplusplus
1209 }
1210 #endif
1211
1212 #endif /* _EVENT2_EVENT_H_ */