Event loop. More...
Go to the source code of this file.
Defines | |
| #define | ELOOP_ALL_CTX (void *) -1 |
| eloop_cancel_timeout() magic number to match all timeouts | |
Typedefs | |
| typedef void(* | eloop_sock_handler )(int sock, void *eloop_ctx, void *sock_ctx) |
| eloop socket event callback type | |
| typedef void(* | eloop_event_handler )(void *eloop_data, void *user_ctx) |
| eloop generic event callback type | |
| typedef void(* | eloop_timeout_handler )(void *eloop_data, void *user_ctx) |
| eloop timeout event callback type | |
| typedef void(* | eloop_signal_handler )(int sig, void *eloop_ctx, void *signal_ctx) |
| eloop signal event callback type | |
Enumerations | |
| enum | eloop_event_type { EVENT_TYPE_READ = 0, EVENT_TYPE_WRITE, EVENT_TYPE_EXCEPTION } |
eloop socket event type for eloop_register_sock() More... | |
Functions | |
| int | eloop_init (void *user_data) |
| Initialize global event loop data. | |
| int | eloop_register_read_sock (int sock, eloop_sock_handler handler, void *eloop_data, void *user_data) |
| Register handler for read events. | |
| void | eloop_unregister_read_sock (int sock) |
| Unregister handler for read events. | |
| int | eloop_register_sock (int sock, eloop_event_type type, eloop_sock_handler handler, void *eloop_data, void *user_data) |
| Register handler for socket events. | |
| void | eloop_unregister_sock (int sock, eloop_event_type type) |
| Unregister handler for socket events. | |
| int | eloop_register_event (void *event, size_t event_size, eloop_event_handler handler, void *eloop_data, void *user_data) |
| Register handler for generic events. | |
| void | eloop_unregister_event (void *event, size_t event_size) |
| Unregister handler for a generic event. | |
| int | eloop_register_timeout (unsigned int secs, unsigned int usecs, eloop_timeout_handler handler, void *eloop_data, void *user_data) |
| Register timeout. | |
| int | eloop_cancel_timeout (eloop_timeout_handler handler, void *eloop_data, void *user_data) |
| Cancel timeouts. | |
| int | eloop_is_timeout_registered (eloop_timeout_handler handler, void *eloop_data, void *user_data) |
| Check if a timeout is already registered. | |
| int | eloop_register_signal (int sig, eloop_signal_handler handler, void *user_data) |
| Register handler for signals. | |
| int | eloop_register_signal_terminate (eloop_signal_handler handler, void *user_data) |
| Register handler for terminate signals. | |
| int | eloop_register_signal_reconfig (eloop_signal_handler handler, void *user_data) |
| Register handler for reconfig signals. | |
| void | eloop_run (void) |
| Start the event loop. | |
| void | eloop_terminate (void) |
| Terminate event loop. | |
| void | eloop_destroy (void) |
| Free any resources allocated for the event loop. | |
| int | eloop_terminated (void) |
| Check whether event loop has been terminated. | |
| void | eloop_wait_for_read_sock (int sock) |
| Wait for a single reader. | |
| void * | eloop_get_user_data (void) |
| Get global user data. | |
Event loop.
This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation.
Alternatively, this software may be distributed under the terms of BSD license.
See README and COPYING for more details.
This file defines an event loop interface that supports processing events from registered timeouts (i.e., do something after N seconds), sockets (e.g., a new packet available for reading), and signals. eloop.c is an implementation of this interface using select() and sockets. This is suitable for most UNIX/POSIX systems. When porting to other operating systems, it may be necessary to replace that implementation with OS specific mechanisms.
Definition in file eloop.h.
| typedef void(* eloop_event_handler)(void *eloop_data, void *user_ctx) |
eloop generic event callback type
| eloop_ctx | Registered callback context data (eloop_data) | |
| sock_ctx | Registered callback context data (user_data) |
| typedef void(* eloop_signal_handler)(int sig, void *eloop_ctx, void *signal_ctx) |
eloop signal event callback type
| sig | Signal number | |
| eloop_ctx | Registered callback context data (global user_data from eloop_init() call) | |
| signal_ctx | Registered callback context data (user_data from eloop_register_signal(), eloop_register_signal_terminate(), or eloop_register_signal_reconfig() call) |
| typedef void(* eloop_sock_handler)(int sock, void *eloop_ctx, void *sock_ctx) |
eloop socket event callback type
| sock | File descriptor number for the socket | |
| eloop_ctx | Registered callback context data (eloop_data) | |
| sock_ctx | Registered callback context data (user_data) |
| typedef void(* eloop_timeout_handler)(void *eloop_data, void *user_ctx) |
eloop timeout event callback type
| eloop_ctx | Registered callback context data (eloop_data) | |
| sock_ctx | Registered callback context data (user_data) |
| enum eloop_event_type |
eloop socket event type for eloop_register_sock()
| EVENT_TYPE_READ | Socket has data available for reading | |
| EVENT_TYPE_WRITE | Socket has room for new data to be written | |
| EVENT_TYPE_EXCEPTION | An exception has been reported |
| int eloop_cancel_timeout | ( | eloop_timeout_handler | handler, | |
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
Cancel timeouts.
| handler | Matching callback function | |
| eloop_data | Matching eloop_data or ELOOP_ALL_CTX to match all | |
| user_data | Matching user_data or ELOOP_ALL_CTX to match all |
Cancel matching <handler,eloop_data,user_data> timeouts registered with eloop_register_timeout(). ELOOP_ALL_CTX can be used as a wildcard for cancelling all timeouts regardless of eloop_data/user_data.
| void eloop_destroy | ( | void | ) |
Free any resources allocated for the event loop.
After calling eloop_destroy(), other eloop_* functions must not be called before re-running eloop_init().
Definition at line 525 of file eloop.c.
| void* eloop_get_user_data | ( | void | ) |
Get global user data.
| int eloop_init | ( | void * | user_data | ) |
Initialize global event loop data.
| user_data | Pointer to global data passed as eloop_ctx to signal handlers |
This function must be called before any other eloop_* function. user_data can be used to configure a global (to the process) pointer that will be passed as eloop_ctx parameter to signal handlers.
| int eloop_is_timeout_registered | ( | eloop_timeout_handler | handler, | |
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
Check if a timeout is already registered.
| handler | Matching callback function | |
| eloop_data | Matching eloop_data | |
| user_data | Matching user_data |
Determine if a matching <handler,eloop_data,user_data> timeout is registered with eloop_register_timeout().
| int eloop_register_event | ( | void * | event, | |
| size_t | event_size, | |||
| eloop_event_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
Register handler for generic events.
| event | Event to wait (eloop implementation specific) | |
| event_size | Size of event data | |
| handler | Callback function to be called when event is triggered | |
| eloop_data | Callback context data (eloop_data) | |
| user_data | Callback context data (user_data) |
Register an event handler for the given event. This function is used to register eloop implementation specific events which are mainly targetted for operating system specific code (driver interface and l2_packet) since the portable code will not be able to use such an OS-specific call. The handler function will be called whenever the event is triggered. The handler function is responsible for clearing the event after having processed it in order to avoid eloop from calling the handler again for the same event.
In case of Windows implementation (eloop_win.c), event pointer is of HANDLE type, i.e., void*. The callers are likely to have 'HANDLE h' type variable, and they would call this function with eloop_register_event(h, sizeof(h), ...).
Definition at line 191 of file eloop_win.c.
| int eloop_register_read_sock | ( | int | sock, | |
| eloop_sock_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
Register handler for read events.
| sock | File descriptor number for the socket | |
| handler | Callback function to be called when data is available for reading | |
| eloop_data | Callback context data (eloop_ctx) | |
| user_data | Callback context data (sock_ctx) |
Register a read socket notifier for the given file descriptor. The handler function will be called whenever data is available for reading from the socket. The handler function is responsible for clearing the event after having processed it in order to avoid eloop from calling the handler again for the same event.
Definition at line 187 of file eloop.c.
| int eloop_register_signal | ( | int | sig, | |
| eloop_signal_handler | handler, | |||
| void * | user_data | |||
| ) |
Register handler for signals.
| sig | Signal number (e.g., SIGHUP) | |
| handler | Callback function to be called when the signal is received | |
| user_data | Callback context data (signal_ctx) |
Register a callback function that will be called when a signal is received. The callback function is actually called only after the system signal handler has returned. This means that the normal limits for sighandlers (i.e., only "safe functions" allowed) do not apply for the registered callback.
Signals are 'global' events and there is no local eloop_data pointer like with other handlers. The global user_data pointer registered with eloop_init() will be used as eloop_ctx for signal handlers.
| int eloop_register_signal_reconfig | ( | eloop_signal_handler | handler, | |
| void * | user_data | |||
| ) |
Register handler for reconfig signals.
| handler | Callback function to be called when the signal is received | |
| user_data | Callback context data (signal_ctx) |
Register a callback function that will be called when a reconfiguration / hangup signal is received. The callback function is actually called only after the system signal handler has returned. This means that the normal limits for sighandlers (i.e., only "safe functions" allowed) do not apply for the registered callback.
Signals are 'global' events and there is no local eloop_data pointer like with other handlers. The global user_data pointer registered with eloop_init() will be used as eloop_ctx for signal handlers.
This function is a more portable version of eloop_register_signal() since the knowledge of exact details of the signals is hidden in eloop implementation. In case of operating systems using signal(), this function registers a handler for SIGHUP.
Definition at line 435 of file eloop.c.
| int eloop_register_signal_terminate | ( | eloop_signal_handler | handler, | |
| void * | user_data | |||
| ) |
Register handler for terminate signals.
| handler | Callback function to be called when the signal is received | |
| user_data | Callback context data (signal_ctx) |
Register a callback function that will be called when a process termination signal is received. The callback function is actually called only after the system signal handler has returned. This means that the normal limits for sighandlers (i.e., only "safe functions" allowed) do not apply for the registered callback.
Signals are 'global' events and there is no local eloop_data pointer like with other handlers. The global user_data pointer registered with eloop_init() will be used as eloop_ctx for signal handlers.
This function is a more portable version of eloop_register_signal() since the knowledge of exact details of the signals is hidden in eloop implementation. In case of operating systems using signal(), this function registers handlers for SIGINT and SIGTERM.
Definition at line 425 of file eloop.c.
| int eloop_register_sock | ( | int | sock, | |
| eloop_event_type | type, | |||
| eloop_sock_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
Register handler for socket events.
| sock | File descriptor number for the socket | |
| type | Type of event to wait for | |
| handler | Callback function to be called when the event is triggered | |
| eloop_data | Callback context data (eloop_ctx) | |
| user_data | Callback context data (sock_ctx) |
Register an event notifier for the given socket's file descriptor. The handler function will be called whenever the that event is triggered for the socket. The handler function is responsible for clearing the event after having processed it in order to avoid eloop from calling the handler again for the same event.
| int eloop_register_timeout | ( | unsigned int | secs, | |
| unsigned int | usecs, | |||
| eloop_timeout_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
Register timeout.
| secs | Number of seconds to the timeout | |
| usecs | Number of microseconds to the timeout | |
| handler | Callback function to be called when timeout occurs | |
| eloop_data | Callback context data (eloop_ctx) | |
| user_data | Callback context data (sock_ctx) |
Register a timeout that will cause the handler function to be called after given time.
Definition at line 237 of file eloop.c.
| void eloop_run | ( | void | ) |
Start the event loop.
Start the event loop and continue running as long as there are any registered event handlers. This function is run after event loop has been initialized with event_init() and one or more events have been registered.
Definition at line 446 of file eloop.c.
| void eloop_terminate | ( | void | ) |
| int eloop_terminated | ( | void | ) |
Check whether event loop has been terminated.
This function can be used to check whether eloop_terminate() has been called to request termination of the event loop. This is normally used to abort operations that may still be queued to be run when eloop_terminate() was called.
| void eloop_unregister_event | ( | void * | event, | |
| size_t | event_size | |||
| ) |
Unregister handler for a generic event.
| event | Event to cancel (eloop implementation specific) | |
| event_size | Size of event data |
Unregister a generic event notifier that was previously registered with eloop_register_event().
Definition at line 220 of file eloop_win.c.
| void eloop_unregister_read_sock | ( | int | sock | ) |
Unregister handler for read events.
| sock | File descriptor number for the socket |
Unregister a read socket notifier that was previously registered with eloop_register_read_sock().
Definition at line 195 of file eloop.c.
| void eloop_unregister_sock | ( | int | sock, | |
| eloop_event_type | type | |||
| ) |
Unregister handler for socket events.
| sock | File descriptor number for the socket | |
| type | Type of event for which sock was registered |
Unregister a socket event notifier that was previously registered with eloop_register_sock().
1.6.1
