event_handle_t *event_register(event_id_t data, event_type_t type, event_fn_t callback, void *arg);

Sets up an event of the given type to call the given function with the given argument.

The 'data' argument is type specific.

EV_READFD, EV_WRITEFD - the file descriptor to monitor EV_SIG - the signal number to monitor EV_TIME - the number of seconds between each pulse EV_WAIT - the wait identifier used with event_wakeup() EV_DEAD - internal use only

void event_release(event_handle_t *handle);

Remove an event from the queue. This can happen at any time, even while the event is firing.

void event_loop(int dontblock);

Process all pending events. If the argument is zero, this will keep running until all events have been released. If the argument is nonzero, this will do one pass over all pending events, and fire the ones that are immediately ready, and then return.

void event_wait(event_id_t id);

Like event_loop(0), except that it will stop as soon as the event id is serviced.

int event_wakeup(event_id_t id);

Fire all EV_WAIT events registered with an argument value of 'id' immediately. Returns the number of events that were fired.

This is an opaque structure that describes a registered event. It is only useful to keep if you need to unregister the event later.

This is type-specific data. The contents and format depend on on the type of the event. This is an unsigned integral type.

This is an enumerated type describing the different events we handle.

typedef void (*event_fn_t)(void *arg);

This is a function signature for the type of function that needs to get passed to event_register. The argument to the function is a pointer of the caller's choosing.

This type of event will fire when the file descriptor passed to event_register has data waiting to be read.

This type of event will fire when the file descriptor passed to event_register can have data written to it without blocking.

This type of event will fire when the signal number passed to event_register has been caught. Note that if a signal is caught while processing is not in event_loop(), the event will be delayed until processing returns to event_loop().

This type of event will fire repeatedly with a delay of the number of seconds passed to event_register between each interval.

This type of event will fire when someone calls event_wakeup() with the numeric argument equal to the argument this event was registered with.