#include "includes.h"#include "common.h"#include "trace.h"
Go to the source code of this file.
| #define eloop_trace_sock_remove_ref | ( | table | ) | do { } while (0) |
| int eloop_cancel_timeout | ( | eloop_timeout_handler | handler, | |
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
eloop_cancel_timeout - Cancel timeouts : Matching callback function : Matching eloop_data or ELOOP_ALL_CTX to match all : Matching user_data or ELOOP_ALL_CTX to match all Returns: Number of cancelled timeouts
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 | ) |
eloop_destroy - Free any resources allocated for the event loop
After calling eloop_destroy(), other eloop_* functions must not be called before re-running eloop_init().
| static struct eloop_sock_table* eloop_get_sock_table | ( | eloop_event_type | type | ) | [static, read] |
| int eloop_init | ( | void | ) |
eloop_init() - Initialize global event loop data Returns: 0 on success, -1 on failure
This function must be called before any other eloop_* function.
| int eloop_is_timeout_registered | ( | eloop_timeout_handler | handler, | |
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
eloop_is_timeout_registered - Check if a timeout is already registered : Matching callback function : Matching eloop_data : Matching user_data Returns: 1 if the timeout is registered, 0 if the timeout is not registered
Determine if a matching <handler,eloop_data,user_data> timeout is registered with eloop_register_timeout().
| int eloop_register_read_sock | ( | int | sock, | |
| eloop_sock_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
eloop_register_read_sock - Register handler for read events : File descriptor number for the socket : Callback function to be called when data is available for reading : Callback context data (eloop_ctx) : Callback context data (sock_ctx) Returns: 0 on success, -1 on failure
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.
| int eloop_register_signal | ( | int | sig, | |
| eloop_signal_handler | handler, | |||
| void * | user_data | |||
| ) |
eloop_register_signal - Register handler for signals : Signal number (e.g., SIGHUP) : Callback function to be called when the signal is received : Callback context data (signal_ctx) Returns: 0 on success, -1 on failure
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.
| int eloop_register_signal_reconfig | ( | eloop_signal_handler | handler, | |
| void * | user_data | |||
| ) |
eloop_register_signal_reconfig - Register handler for reconfig signals : Callback function to be called when the signal is received : Callback context data (signal_ctx) Returns: 0 on success, -1 on failure
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.
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.
| int eloop_register_signal_terminate | ( | eloop_signal_handler | handler, | |
| void * | user_data | |||
| ) |
eloop_register_signal_terminate - Register handler for terminate signals : Callback function to be called when the signal is received : Callback context data (signal_ctx) Returns: 0 on success, -1 on failure
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.
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.
| int eloop_register_sock | ( | int | sock, | |
| eloop_event_type | type, | |||
| eloop_sock_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) |
eloop_register_sock - Register handler for socket events : File descriptor number for the socket : Type of event to wait for : Callback function to be called when the event is triggered : Callback context data (eloop_ctx) : Callback context data (sock_ctx) Returns: 0 on success, -1 on failure
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 | |||
| ) |
eloop_register_timeout - Register timeout : Number of seconds to the timeout : Number of microseconds to the timeout : Callback function to be called when timeout occurs : Callback context data (eloop_ctx) : Callback context data (sock_ctx) Returns: 0 on success, -1 on failure
Register a timeout that will cause the handler function to be called after given time.
| static void eloop_remove_timeout | ( | struct eloop_timeout * | timeout | ) | [static] |
| void eloop_run | ( | void | ) |
| static int eloop_sock_table_add_sock | ( | struct eloop_sock_table * | table, | |
| int | sock, | |||
| eloop_sock_handler | handler, | |||
| void * | eloop_data, | |||
| void * | user_data | |||
| ) | [static] |
| static void eloop_sock_table_destroy | ( | struct eloop_sock_table * | table | ) | [static] |
| static void eloop_sock_table_dispatch | ( | struct eloop_sock_table * | table, | |
| fd_set * | fds | |||
| ) | [static] |
| static void eloop_sock_table_remove_sock | ( | struct eloop_sock_table * | table, | |
| int | sock | |||
| ) | [static] |
| static void eloop_sock_table_set_fds | ( | struct eloop_sock_table * | table, | |
| fd_set * | fds | |||
| ) | [static] |
| void eloop_terminate | ( | void | ) |
| int eloop_terminated | ( | void | ) |
eloop_terminated - Check whether event loop has been terminated Returns: 1 = event loop terminate, 0 = event loop still running
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_read_sock | ( | int | sock | ) |
eloop_unregister_read_sock - Unregister handler for read events : File descriptor number for the socket
Unregister a read socket notifier that was previously registered with eloop_register_read_sock().
| void eloop_unregister_sock | ( | int | sock, | |
| eloop_event_type | type | |||
| ) |
eloop_unregister_sock - Unregister handler for socket events : File descriptor number for the socket : Type of event for which sock was registered
Unregister a socket event notifier that was previously registered with eloop_register_sock().
| void eloop_wait_for_read_sock | ( | int | sock | ) |
struct eloop_data eloop [static] |