compat_libevent.c File Reference

Wrappers and utility functions for Libevent. More...

#include "orconfig.h"
#include "compat.h"
#include "compat_libevent.h"
#include "crypto_rand.h"
#include "util.h"
#include "torlog.h"
#include <event2/event.h>
#include <event2/thread.h>

Include dependency graph for compat_libevent.c:

Data Structures
struct	periodic_timer_t
struct	mainloop_event_t

Functions
STATIC void	libevent_logging_callback (int severity, const char *msg)
void	configure_libevent_logging (void)
void	suppress_libevent_log_msg (const char *msg)
void	tor_event_free_ (struct event *ev)
void	tor_libevent_initialize (tor_libevent_cfg *torcfg)
	MOCK_IMPL (struct event_base *, tor_libevent_get_base,(void))
const char *	tor_libevent_get_method (void)
const char *	tor_libevent_get_version_str (void)
const char *	tor_libevent_get_header_version_str (void)
periodic_timer_t *	periodic_timer_new (struct event_base *base, const struct timeval *tv, void(*cb)(periodic_timer_t *timer, void *data), void *data)
void	periodic_timer_launch (periodic_timer_t *timer, const struct timeval *tv)
void	periodic_timer_disable (periodic_timer_t *timer)
void	periodic_timer_free_ (periodic_timer_t *timer)
mainloop_event_t *	mainloop_event_new (void(*cb)(mainloop_event_t *, void *), void *userdata)
mainloop_event_t *	mainloop_event_postloop_new (void(*cb)(mainloop_event_t *, void *), void *userdata)
void	mainloop_event_activate (mainloop_event_t *event)
int	mainloop_event_schedule (mainloop_event_t *event, const struct timeval *tv)
void	mainloop_event_cancel (mainloop_event_t *event)
void	mainloop_event_free_ (mainloop_event_t *event)
int	tor_init_libevent_rng (void)
void	tor_libevent_free_all (void)
int	tor_libevent_run_event_loop (struct event_base *base, int once)
void	tor_libevent_exit_loop_after_delay (struct event_base *base, const struct timeval *delay)
void	tor_libevent_exit_loop_after_callback (struct event_base *base)

Detailed Description

Wrappers and utility functions for Libevent.

Function Documentation

configure_libevent_logging()

void configure_libevent_logging

(

void

)

Set hook to intercept log messages from libevent.

Here is the call graph for this function:

libevent_logging_callback()

STATIC void libevent_logging_callback	(	int	severity,
		const char *	msg
	)

Callback function passed to event_set_log() so we can intercept log messages from libevent.

Here is the caller graph for this function:

mainloop_event_activate()

void mainloop_event_activate

(

mainloop_event_t *

event

)

Schedule event to run in the main loop, immediately. If it is not scheduled, it will run anyway. If it is already scheduled to run later, it will run now instead. This function will have no effect if the event is already scheduled to run.

This function may only be called from the main thread.

Here is the caller graph for this function:

mainloop_event_cancel()

void mainloop_event_cancel

(

mainloop_event_t *

event

)

Cancel event if it is currently active or pending. (Do nothing if the event is not currently active or pending.)

Here is the caller graph for this function:

mainloop_event_free_()

void mainloop_event_free_

(

mainloop_event_t *

event

)

Cancel event and release all storage associated with it.

mainloop_event_new()

mainloop_event_t* mainloop_event_new	(	void(*)(mainloop_event_t *, void *)	cb,
		void *	userdata
	)

Create and return a new mainloop_event_t to run the function cb.

When run, the callback function will be passed the mainloop_event_t and userdata as its arguments. The userdata pointer must remain valid for as long as the mainloop_event_t event exists: it is your responsibility to free it.

The event is not scheduled by default: Use mainloop_event_activate() or mainloop_event_schedule() to make it run.

Here is the caller graph for this function:

mainloop_event_postloop_new()

mainloop_event_t* mainloop_event_postloop_new	(	void(*)(mainloop_event_t *, void *)	cb,
		void *	userdata
	)

As mainloop_event_new(), but create a post-loop event.

A post-loop event behaves like any ordinary event, but any events that it activates cannot run until Libevent has checked for other events at least once.

Here is the caller graph for this function:

mainloop_event_schedule()

int mainloop_event_schedule	(	mainloop_event_t *	event,
		const struct timeval *	tv
	)

Schedule event to run in the main loop, after a delay of tv.

If the event is scheduled for a different time, cancel it and run after this delay instead. If the event is currently pending to run now, has no effect.

Do not call this function with tv == NULL – use mainloop_event_activate() instead.

This function may only be called from the main thread.

MOCK_IMPL()

MOCK_IMPL	(	struct event_base *	,
		tor_libevent_get_base	,
		(void)
	)

Return the current Libevent event base that we're set up to use.

periodic_timer_disable()

void periodic_timer_disable

(

periodic_timer_t *

timer

)

Disable the provided timer, but do not free it.

You can reenable the same timer later with periodic_timer_launch.

If the timer is already disabled, this function does nothing.

periodic_timer_free_()

void periodic_timer_free_

(

periodic_timer_t *

timer

)

Stop and free a periodic timer

periodic_timer_launch()

void periodic_timer_launch	(	periodic_timer_t *	timer,
		const struct timeval *	tv
	)

Launch the timer timer to run at tv from now, and every tv thereafter.

If the timer is already enabled, this function does nothing.

periodic_timer_new()

periodic_timer_t* periodic_timer_new	(	struct event_base *	base,
		const struct timeval *	tv,
		void(*)(periodic_timer_t *timer, void *data)	cb,
		void *	data
	)

Create and schedule a new timer that will run every tv in the event loop of base. When the timer fires, it will run the timer in cb with the user-supplied data in data.

Here is the caller graph for this function:

suppress_libevent_log_msg()

void suppress_libevent_log_msg

(

const char *

msg

)

Ignore any libevent log message that contains msg.

tor_libevent_exit_loop_after_callback()

void tor_libevent_exit_loop_after_callback

(

struct event_base *

base

)

Tell the event loop to exit after running whichever callback is currently active.

tor_libevent_exit_loop_after_delay()

void tor_libevent_exit_loop_after_delay	(	struct event_base *	base,
		const struct timeval *	delay
	)

Tell the event loop to exit after delay. If delay is NULL, instead exit after we're done running the currently active events.

tor_libevent_free_all()

void tor_libevent_free_all

(

void

)

Un-initialize libevent in preparation for an exit

tor_libevent_get_header_version_str()

const char* tor_libevent_get_header_version_str

(

void

)

Return a string representation of the version of Libevent that was used at compilation time.

tor_libevent_get_method()

const char* tor_libevent_get_method

(

void

)

Return the name of the Libevent backend we're using.

tor_libevent_get_version_str()

const char* tor_libevent_get_version_str

(

void

)

Return a string representation of the version of the currently running version of Libevent.

tor_libevent_initialize()

void tor_libevent_initialize

(

tor_libevent_cfg *

torcfg

)

Initialize the Libevent library and set up the event base.

Here is the caller graph for this function:

tor_libevent_run_event_loop()

int tor_libevent_run_event_loop	(	struct event_base *	base,
		int	once
	)

Run the event loop for the provided event_base, handling events until something stops it. If once is set, then just poll-and-run once, then exit. Return 0 on success, -1 if an error occurred, or 1 if we exited because no events were pending or active.

This isn't reentrant or multithreaded.