libevent

https://libevent.org/doc
Admin
libevent is an event notification library for developing scalable network servers, providing a...
Tokens:97,226
Snippets:1,073
Trust Score:9.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### evhttp_start

Source: https://libevent.org/doc/http__compat_8h_source.html

Starts an HTTP server on the specified address and port.

```APIDOC
## evhttp_start

### Description
Starts an HTTP server on the specified address and port.

### Signature
`struct evhttp *evhttp_start(const char *address, ev_uint16_t port);`
```

--------------------------------

### evhttp_start

Source: https://libevent.org/doc/http__compat_8h.html

Starts an HTTP server on the specified address and port.

```APIDOC
## evhttp_start

### Description
Starts an HTTP server on the specified address and port. This function is deprecated because it does not allow an event base to be specified.

### Signature
struct evhttp * evhttp_start(const char *address, ev_uint16_t port)

### Parameters
- **address** (const char *) - The address to which the HTTP server should be bound.
- **port** (ev_uint16_t) - The port number on which the HTTP server should listen.

### Returns
- **struct evhttp*** - A pointer to a newly initialized evhttp server structure or NULL on error.
```

--------------------------------

### Initialize and perform an asynchronous DNS lookup

Source: https://libevent.org/doc/dns_8h.html

Demonstrates the basic setup for parsing a configuration file and initiating a DNS resolution request.

```c
#include "evdns.h"
void callback(int result, char type, int count, int ttl,
void *addresses, void *arg);
evdns_resolv_conf_parse(DNS_OPTIONS_ALL, "/etc/resolv.conf");
evdns_resolve("www.hostname.com", 0, callback, NULL);
```

--------------------------------

### HTTP Server and Connection Management

Source: https://libevent.org/doc/http__compat_8h_source.html

Functions for starting an HTTP server and managing connection objects.

```c
EVENT2_EXPORT_SYMBOL
struct evhttp *evhttp_start(const char *address, ev_uint16_t port);
```

```c
EVENT2_EXPORT_SYMBOL
struct evhttp_connection *evhttp_connection_new(
 const char *address, ev_uint16_t port);
```

```c
EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_base(struct evhttp_connection *evcon,
 struct event_base *base);
```

--------------------------------

### event_dispatch

Source: https://libevent.org/doc/event__compat_8h_source.html

Starts the event loop.

```APIDOC
## int event_dispatch(void)

### Description
Enters the loop to process events until no events remain or the loop is terminated.
```

--------------------------------

### Recognized Hostname Formats

Source: https://libevent.org/doc/bufferevent_8h.html

Examples of valid hostname formats accepted by the connection function.

```text
www.example.com (hostname)
1.2.3.4     (ipv4address)
::1     (ipv6address)
[::1]       ([ipv6address])
```

--------------------------------

### event_dispatch

Source: https://libevent.org/doc/event__compat_8h_source.html

Starts the event loop to dispatch events.

```APIDOC
## int event_dispatch(void)

### Description
Starts the event loop to dispatch events. Returns 0 on success, -1 on error.

### Returns
- **int** - 0 on success, -1 on error.
```

--------------------------------

### event_loop

Source: https://libevent.org/doc/event__compat_8h_source.html

Starts the event loop to handle registered events.

```APIDOC
## int event_loop(int flags)

### Description
Handles events by entering the event loop.

### Parameters
- **flags** (int) - Flags to control the behavior of the event loop.
```

--------------------------------

### event_base_loop

Source: https://libevent.org/doc/event_8h_source.html

Starts the event loop for the specified event base.

```APIDOC
## int event_base_loop(struct event_base *eb, int flags);

### Description
Runs the event loop for the given event base until no events remain or an exit is requested.

### Parameters
- **eb** (struct event_base *) - Required - The event base to run.
- **flags** (int) - Required - Loop control flags (e.g., EVLOOP_ONCE, EVLOOP_NONBLOCK).
```

--------------------------------

### event_base_dispatch

Source: https://libevent.org/doc/event_8h_source.html

Starts the event dispatching loop for a given event base.

```APIDOC
## int event_base_dispatch(struct event_base *base)

### Description
Event dispatching loop. This function runs the event loop for the provided event base.

### Parameters
- **base** (struct event_base *) - Required - The event base to dispatch.
```

--------------------------------

### evdns_init

Source: https://libevent.org/doc/dns__compat_8h_source.html

Initializes the legacy DNS subsystem.

```APIDOC
## int evdns_init(void)

### Description
Initializes the legacy DNS subsystem for use with libevent.

### Returns
- **int** - 0 on success, -1 on failure.
```

--------------------------------

### evdns_init

Source: https://libevent.org/doc/dns__compat_8h.html

Initializes the asynchronous DNS library.

```APIDOC
## int evdns_init(void)

### Description
Initialize the asynchronous DNS library.
```

--------------------------------

### event_get_fd

Source: https://libevent.org/doc/event_8h.html

Gets the socket or signal assigned to an event.

```APIDOC
## event_get_fd

### Description
Get the socket or signal assigned to an event, or -1 if the event has no socket.

### Signature
evutil_socket_t event_get_fd(const struct event *ev);
```

--------------------------------

### evdns_init()

Source: https://libevent.org/doc/dns__compat_8h.html

Initializes the asynchronous DNS library using the current event base.

```APIDOC
## evdns_init()

### Description
Initialize the asynchronous DNS library. This function initializes support for non-blocking name resolution by calling evdns_resolv_conf_parse() on UNIX and evdns_config_windows_nameservers() on Windows.

### Signature
`int evdns_init(void)`

### Returns
- 0 if successful, or -1 if an error occurred

### Note
This function is deprecated because it always uses the current event base, is easily confused by multiple calls to event_init(), and is not safe for multithreaded use. The replacement is evdns_base_new().
```

--------------------------------

### HTTP Server Initialization and Binding

Source: https://libevent.org/doc/http_8h_source.html

Functions for creating an HTTP server instance and binding it to specific addresses or sockets.

```c
EVENT2_EXPORT_SYMBOL
struct evhttp *evhttp_new(struct event_base *base);

EVENT2_EXPORT_SYMBOL
int evhttp_bind_socket(struct evhttp *http, const char *address, ev_uint16_t port);

EVENT2_EXPORT_SYMBOL
struct evhttp_bound_socket *evhttp_bind_socket_with_handle(struct evhttp *http, const char *address, ev_uint16_t port);

EVENT2_EXPORT_SYMBOL
int evhttp_accept_socket(struct evhttp *http, evutil_socket_t fd);
```

--------------------------------

### RPC System Initialization and Registration

Source: https://libevent.org/doc/rpc_8h_source.html

Functions and macros for initializing the RPC system and registering RPC services.

```c
EVENT2_EXPORT_SYMBOL
struct evrpc_base *evrpc_init(struct evhttp *server);
EVENT2_EXPORT_SYMBOL
void evrpc_free(struct evrpc_base *base);
```

```c
#define EVRPC_REGISTER(base, name, request, reply, callback, cbarg) \
 evrpc_register_generic(base, #name, \
 (void (*)(struct evrpc_req_generic *, void *))callback, cbarg, \
 (void *(*)(void *))request##_new_with_arg, NULL, \
 (void (*)(void *))request##_free, \
 (int (*)(void *, struct evbuffer *))request##_unmarshal, \
 (void *(*)(void *))reply##_new_with_arg, NULL, \
 (void (*)(void *))reply##_free, \
 (int (*)(void *))reply##_complete, \
 (void (*)(struct evbuffer *, void *))reply##_marshal)
```

```c
EVENT2_EXPORT_SYMBOL
int evrpc_register_rpc(struct evrpc_base *, struct evrpc *,
 void (*)(struct evrpc_req_generic*, void *), void *);
```

```c
#define EVRPC_UNREGISTER(base, name) evrpc_unregister_rpc((base), #name)

EVENT2_EXPORT_SYMBOL
int evrpc_unregister_rpc(struct evrpc_base *base, const char *name);
```

--------------------------------

### event_base_get_num_events()

Source: https://libevent.org/doc/event_8h.html

Gets the number of events in an event_base based on the provided flags.

```APIDOC
## int event_base_get_num_events(struct event_base *eb, unsigned int flags)

### Description
Gets the number of events in event_base, as specified in the flags. The return value is an indication of the work load.

### Parameters
- **eb** (struct event_base *) - Required - The event_base structure returned by event_base_new().
- **flags** (unsigned int) - Required - A bitwise combination of the kinds of events to aggregate counts for.

### Returns
- **int** - The number of events specified in the flags.
```

--------------------------------

### evrpc_init

Source: https://libevent.org/doc/rpc_8h_source.html

Initializes the RPC system on a given HTTP server.

```APIDOC
## evrpc_init

### Description
Initializes the RPC system on a given HTTP server.

### Signature
struct evrpc_base *evrpc_init(struct evhttp *server);
```

--------------------------------

### Manipulate evbuffer data

Source: https://libevent.org/doc/buffer_8h_source.html

Functions for prepending data or buffers to the start of an evbuffer.

```c
int evbuffer_prepend(struct evbuffer *buf, const void *data, size_t size);
int evbuffer_prepend_buffer(struct evbuffer *dst, struct evbuffer* src);
```

--------------------------------

### evdns_base_new

Source: https://libevent.org/doc/dns_8h_source.html

Initializes the asynchronous DNS library and returns a new evdns_base structure.

```APIDOC
## evdns_base_new

### Description
Initializes the asynchronous DNS library. This function must be called before performing any DNS operations.

### Signature
`struct evdns_base * evdns_base_new(struct event_base *event_base, int flags)`
```

--------------------------------

### Get event file descriptor

Source: https://libevent.org/doc/event_8h.html

Retrieves the socket or signal assigned to an event.

```c
EVENT2_EXPORT_SYMBOL evutil_socket_t event_get_fd(const struct event *ev)
```

--------------------------------

### Configure Windows nameservers

Source: https://libevent.org/doc/dns__compat_8h_source.html

Conditional compilation block for initializing nameservers on Windows platforms.

```c
#ifdef _WIN32
EVENT2_EXPORT_SYMBOL
int evdns_config_windows_nameservers(void);
#define EVDNS_CONFIG_WINDOWS_NAMESERVERS_IMPLEMENTED
#endif
```

--------------------------------

### SSL Bufferevent Flag Management

Source: https://libevent.org/doc/bufferevent__ssl_8h_source.html

Functions to get, set, or clear flags on an SSL bufferevent. These are available when OpenSSL or MbedTLS is enabled.

```c
EVENT2_EXPORT_SYMBOL
ev_uint64_t bufferevent_ssl_get_flags(struct bufferevent *bev);
EVENT2_EXPORT_SYMBOL
ev_uint64_t bufferevent_ssl_set_flags(struct bufferevent *bev, ev_uint64_t flags);
EVENT2_EXPORT_SYMBOL
ev_uint64_t bufferevent_ssl_clear_flags(struct bufferevent *bev, ev_uint64_t flags);
```

--------------------------------

### event_init

Source: https://libevent.org/doc/event__compat_8h_source.html

Initializes the Libevent library.

```APIDOC
## struct event_base * event_init(void)

### Description
Initializes the event API and returns a pointer to the event base structure.
```

--------------------------------

### Include event_compat.h dependencies

Source: https://libevent.org/doc/event__compat_8h.html

Required headers for utilizing the compatibility functions provided by event_compat.h.

```c
#include <event2/visibility.h>
#include <event2/event-config.h>
#include <event2/util.h>
```

--------------------------------

### evdns_base_resolv_conf_parse()

Source: https://libevent.org/doc/dns_8h.html

Parses a resolv.conf file to configure the DNS base.

```APIDOC
## int evdns_base_resolv_conf_parse(struct evdns_base *base, int flags, const char *const filename)

### Description
Parses a resolv.conf file. The 'flags' parameter determines what information is parsed from the resolv.conf file.

### Parameters
- **base** (struct evdns_base *) - Required - The evdns_base to which to apply this operation.
- **flags** (int) - Required - Any of DNS_OPTION_NAMESERVERS, DNS_OPTION_SEARCH, DNS_OPTION_MISC, DNS_OPTION_HOSTSFILE, DNS_OPTIONS_ALL, DNS_OPTION_NAMESERVERS_NO_DEFAULT.
- **filename** (const char *const) - Required - The path to the resolv.conf file.

### Returns
0 if successful, or positive error codes (EVDNS_ERROR_FAILED_TO_OPEN_FILE, EVDNS_ERROR_FAILED_TO_STAT_FILE, EVDNS_ERROR_FILE_TOO_LARGE, EVDNS_ERROR_OUT_OF_MEMORY, EVDNS_ERROR_SHORT_READ_FROM_FILE, EVDNS_ERROR_NO_NAMESERVERS_CONFIGURED).
```

--------------------------------

### Define DNS_OPTIONS_ALL macro

Source: https://libevent.org/doc/dns_8h.html

Macro definition for including all DNS options during configuration parsing.

```c
#define DNS_OPTIONS_ALL
```

--------------------------------

### Initialize RPC base

Source: https://libevent.org/doc/rpc_8h.html

Creates an RPC base associated with an HTTP server.

```c
struct evrpc_base *base = evrpc_init(http);
```

--------------------------------

### evhttp_bind_listener()

Source: https://libevent.org/doc/http_8h.html

The most low-level evhttp_bind/accept method: takes an evconnlistener, and returns an evhttp_bound_socket.

```APIDOC
## evhttp_bind_listener()

### Description
The most low-level evhttp_bind/accept method: takes an evconnlistener, and returns an evhttp_bound_socket. The listener will be freed when the bound socket is freed.

### Parameters
- **http** (struct evhttp *) - The evhttp object.
- **listener** (struct evconnlistener *) - The listener to bind.

### Returns
- **struct evhttp_bound_socket*** - A pointer to the bound socket.
```

--------------------------------

### Legacy Event Loop and Initialization Functions

Source: https://libevent.org/doc/event__compat_8h_source.html

Functions for initializing the event base and controlling the event loop in a legacy-compatible manner.

```c
EVENT2_EXPORT_SYMBOL
struct event_base *event_init(void);

EVENT2_EXPORT_SYMBOL
int event_dispatch(void);

EVENT2_EXPORT_SYMBOL
int event_loop(int);

EVENT2_EXPORT_SYMBOL
int event_loopexit(const struct timeval *);

EVENT2_EXPORT_SYMBOL
int event_loopbreak(void);

EVENT2_EXPORT_SYMBOL
int event_once(evutil_socket_t , short,
 void (*)(evutil_socket_t, short, void *), void *, const struct timeval *);

EVENT2_EXPORT_SYMBOL
const char *event_get_method(void);

EVENT2_EXPORT_SYMBOL
int event_priority_init(int);

EVENT2_EXPORT_SYMBOL
void event_set(struct event *, evutil_socket_t, short, void (*)(evutil_socket_t, short, void *), void *);
```

--------------------------------

### Event Base Configuration and Lifecycle

Source: https://libevent.org/doc/event_8h_source.html

Functions to set features, flags, and hints for event base creation, and managing base lifecycle.

```c
EVENT2_EXPORT_SYMBOL
int event_base_get_features(const struct event_base *base);

EVENT2_EXPORT_SYMBOL
int event_config_require_features(struct event_config *cfg, int feature);

EVENT2_EXPORT_SYMBOL
int event_config_set_flag(struct event_config *cfg, int flag);

EVENT2_EXPORT_SYMBOL
int event_config_set_num_cpus_hint(struct event_config *cfg, int cpus);

EVENT2_EXPORT_SYMBOL
int event_config_set_max_dispatch_interval(struct event_config *cfg,
 const struct timeval *max_interval, int max_callbacks,
 int min_priority);

EVENT2_EXPORT_SYMBOL
struct event_base *event_base_new_with_config(const struct event_config *cfg);

EVENT2_EXPORT_SYMBOL
void event_base_free(struct event_base *eb);

EVENT2_EXPORT_SYMBOL
void event_base_free_nofinalize(struct event_base *);
```

--------------------------------

### Require event features with fallback

Source: https://libevent.org/doc/event_8h.html

Demonstrates how to request specific event features and provide a fallback if the requested configuration is unsupported.

```c
  event_config_require_features(cfg, EV_FEATURE_ET);
  base = event_base_new_with_config(cfg);
  if (base == NULL) {
    // We can't get edge-triggered behavior here.
    event_config_require_features(cfg, 0);
    base = event_base_new_with_config(cfg);
  }
```

--------------------------------

### Define EVDNS_BASE_NAMESERVERS_NO_DEFAULT

Source: https://libevent.org/doc/dns_8h.html

Flag for evdns_base_new to prevent adding default nameservers if none are found in resolv.conf.

```c
#define EVDNS_BASE_NAMESERVERS_NO_DEFAULT 0x10000
```

--------------------------------

### Define DNS_OPTIONS_ALL

Source: https://libevent.org/doc/dns_8h.html

A bitmask combining all available DNS configuration options.

```c
#define DNS_OPTIONS_ALL  
( \
DNS_OPTION_SEARCH | \
DNS_OPTION_NAMESERVERS | \
DNS_OPTION_MISC | \
DNS_OPTION_HOSTSFILE | \
0 \
)
```

--------------------------------

### evrpc_init

Source: https://libevent.org/doc/rpc_8h_source.html

Creates a new RPC base from which RPC requests can be received.

```APIDOC
## evrpc_init

### Description
Creates a new RPC base from which RPC requests can be received.

### Signature
`struct evrpc_base * evrpc_init(struct evhttp *server)`
```

--------------------------------

### evhttp_send_reply_start

Source: https://libevent.org/doc/http_8h.html

Initiates a chunked HTTP reply, allowing the caller to stream data back to the client.

```APIDOC
## evhttp_send_reply_start

### Description
Initiate a reply that uses Transfer-Encoding chunked. This allows the caller to stream the reply back to the client and is useful when either not all of the reply data is immediately available or when sending very large replies.

### Parameters
- **req** (struct evhttp_request *) - Required - A request object
- **code** (int) - Required - The HTTP response code to send
- **reason** (const char *) - Required - A brief message to send with the response code
```

--------------------------------

### Legacy Event and Timeout Macros

Source: https://libevent.org/doc/event__compat_8h_source.html

Compatibility macros for setting up timers, signals, and timeouts using the legacy event API.

```c
#define evtimer_set(ev, cb, arg) event_set((ev), -1, 0, (cb), (arg))
#define evsignal_set(ev, x, cb, arg) \
 event_set((ev), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))

#define timeout_add(ev, tv) event_add((ev), (tv))
#define timeout_set(ev, cb, arg) event_set((ev), -1, 0, (cb), (arg))
#define timeout_del(ev) event_del(ev)
#define timeout_pending(ev, tv) event_pending((ev), EV_TIMEOUT, (tv))
#define timeout_initialized(ev) event_initialized(ev)

#define signal_add(ev, tv) event_add((ev), (tv))
#define signal_set(ev, x, cb, arg) \
 event_set((ev), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
```

--------------------------------

### bufferevent_socket_connect_hostname_hints()

Source: https://libevent.org/doc/bufferevent_8h.html

Resolves a hostname and initiates a connection using a bufferevent, with optional DNS base and address hints.

```APIDOC
## int bufferevent_socket_connect_hostname_hints(struct bufferevent *bufev, struct evdns_base *evdns_base, const struct evutil_addrinfo *hints_in, const char *hostname, int port)

### Description
Resolve the hostname and connect to it as with bufferevent_socket_connect().

### Parameters
- **bufev** (struct bufferevent *) - An existing bufferevent allocated with bufferevent_socket_new()
- **evdns_base** (struct evdns_base *) - Optionally, an evdns_base to use for resolving hostnames asynchronously. May be set to NULL for a blocking resolve.
- **hints_in** (const struct evutil_addrinfo *) - Points to an addrinfo structure that specifies criteria for selecting the socket address structures to be used
- **hostname** (const char *) - The hostname to resolve
- **port** (int) - The port to connect to on the resolved address.

### Returns
- **int** - 0 if successful, -1 on failure.
```

--------------------------------

### Listener Options (LEV_OPT_*)

Source: https://libevent.org/doc/globals_l.html

Configuration macros for listener behavior in libevent.

```APIDOC
## Listener Options

### Description
These macros define options for listener behavior, defined in listener.h.

### Constants
- LEV_OPT_BIND_IPV4_AND_IPV6
- LEV_OPT_BIND_IPV6ONLY
- LEV_OPT_CLOSE_ON_EXEC
- LEV_OPT_CLOSE_ON_FREE
- LEV_OPT_DEFERRED_ACCEPT
- LEV_OPT_DISABLED
- LEV_OPT_LEAVE_SOCKETS_BLOCKING
- LEV_OPT_REUSEABLE
- LEV_OPT_REUSEABLE_PORT
- LEV_OPT_THREADSAFE
```

--------------------------------

### HTTP Connection Creation Functions

Source: https://libevent.org/doc/http_8h_source.html

Functions for creating and managing HTTP connections.

```c
EVENT2_EXPORT_SYMBOL
struct evhttp_connection *evhttp_connection_base_bufferevent_new(
 struct event_base *base, struct evdns_base *dnsbase, struct bufferevent* bev, const char *address, ev_uint16_t port);

EVENT2_EXPORT_SYMBOL
struct evhttp_connection *evhttp_connection_base_bufferevent_unix_new(
 struct event_base *base, struct bufferevent* bev, const char *path);

EVENT2_EXPORT_SYMBOL
struct evhttp_connection *
evhttp_connection_base_bufferevent_reuse_new(struct event_base *base, struct evdns_base *dnsbase, struct bufferevent* bev);

EVENT2_EXPORT_SYMBOL
struct evhttp_connection *evhttp_connection_base_new(
 struct event_base *base, struct evdns_base *dnsbase,
 const char *address, ev_uint16_t port);
```

--------------------------------

### evwatch_prepare_new

Source: https://libevent.org/doc/watch_8h_source.html

Registers a new prepare watcher to be executed immediately before the event loop polls for I/O.

```APIDOC
## evwatch_prepare_new

### Description
Registers a new "prepare" watcher, to be called in the event loop prior to polling for events.

### Signature
struct evwatch *evwatch_prepare_new(struct event_base *base, evwatch_prepare_cb callback, void *arg);
```

--------------------------------

### event_init

Source: https://libevent.org/doc/event__compat_8h_source.html

Initializes the event library and returns a pointer to the event_base structure.

```APIDOC
## struct event_base *event_init(void)

### Description
Initializes the event library and returns a pointer to the event_base structure. This function is part of the compatibility API.

### Returns
- **struct event_base*** - A pointer to the initialized event base.
```

--------------------------------

### evhttp_make_request

Source: https://libevent.org/doc/http_8h_source.html

Initiates an HTTP request on the specified connection.

```APIDOC
int evhttp_make_request(struct evhttp_connection *evcon, struct evhttp_request *req, enum evhttp_cmd_type type, const char *uri);
```

--------------------------------

### event_config_set_num_cpus_hint()

Source: https://libevent.org/doc/event_8h.html

Records a hint for the number of CPUs in the system to assist with performance tuning.

```APIDOC
## int event_config_set_num_cpus_hint(struct event_config *cfg, int cpus)

### Description
Records a hint for the number of CPUs in the system. This is used for tuning thread pools for optimal performance.

### Parameters
- **cfg** (struct event_config *) - Required - The event configuration object.
- **cpus** (int) - Required - The number of cpus.

### Returns
- 0 on success, -1 on failure.
```

--------------------------------

### Event Base Information and Configuration

Source: https://libevent.org/doc/event_8h_source.html

Functions for querying event base status and configuring new event bases.

```c
EVENT2_EXPORT_SYMBOL
int event_base_get_num_events(struct event_base *eb, unsigned int flags);

EVENT2_EXPORT_SYMBOL
int event_base_get_max_events(struct event_base *eb, unsigned int flags, int clear);

EVENT2_EXPORT_SYMBOL
struct event_config *event_config_new(void);

EVENT2_EXPORT_SYMBOL
void event_config_free(struct event_config *cfg);

EVENT2_EXPORT_SYMBOL
int event_config_avoid_method(struct event_config *cfg, const char *method);
```

--------------------------------

### Create RPC context with EVRPC_MAKE_CTX

Source: https://libevent.org/doc/rpc_8h.html

Populates an RPC-specific context containing marshaling information. Prefer using EVRPC_GENERATE instead of this macro directly.

```c
#define EVRPC_MAKE_CTX(rpcname, reqstruct, rplystruct, pool, request, reply, cb, cbarg) \
evrpc_make_request_ctx(pool, request, reply, \
#rpcname, \
(void (*)(struct evbuffer *, void *))reqstruct##_marshal, \
(void (*)(void *))rplystruct##_clear, \
(int (*)(void *, struct evbuffer *))rplystruct##_unmarshal, \
(void (*)(struct evrpc_status *, void *, void *, void *))cb, \
cbarg)
```

--------------------------------

### Parse resolv.conf file

Source: https://libevent.org/doc/dns_8h.html

Function signature for parsing a standard resolv.conf file to configure DNS settings.

```c
EVENT2_EXPORT_SYMBOL int evdns_resolv_conf_parse(int flags, const char *const filename)
```

--------------------------------

### event_priority_init

Source: https://libevent.org/doc/event__compat_8h_source.html

Initializes event priorities.

```APIDOC
## int event_priority_init(int npriorities)

### Description
Initializes the number of event priorities.

### Parameters
- **npriorities** (int) - The number of priority levels.

### Returns
- **int** - 0 on success, -1 on error.
```

--------------------------------

### Time and Status Utilities

Source: https://libevent.org/doc/event_8h_source.html

Utility functions and macros for time tracking and event base status.

```c
EVENT2_EXPORT_SYMBOL
int event_gettime_monotonic(struct event_base *base, struct timeval *tp);
```

```c
#define EVENT_BASE_COUNT_ACTIVE 1U
#define EVENT_BASE_COUNT_VIRTUAL 2U
#define EVENT_BASE_COUNT_ADDED 4U
```

--------------------------------

### Define Compatibility Macros

Source: https://libevent.org/doc/bufferevent__compat_8h_source.html

Maps legacy callback types to current bufferevent callback definitions.

```c
#define evbuffercb bufferevent_data_cb
#define everrorcb bufferevent_event_cb
```

--------------------------------

### evdns_nameserver_add

Source: https://libevent.org/doc/dns__compat_8h.html

Add a nameserver by address.

```APIDOC
## int evdns_nameserver_add(unsigned long int address)

### Description
Add a nameserver.
```

--------------------------------

### evdns_base_load_hosts()

Source: https://libevent.org/doc/dns_8h.html

Load an /etc/hosts-style file into the DNS base.

```APIDOC
## int evdns_base_load_hosts(struct evdns_base *base, const char *hosts_fname)

### Description
Load an /etc/hosts-style file from 'hosts_fname' into 'base'. If hosts_fname is NULL, add minimal entries for localhost. Note that only evdns_getaddrinfo uses the /etc/hosts entries.

### Parameters
- **base** (struct evdns_base *) - The evdns_base to examine.
- **hosts_fname** (const char *) - The path to the hosts file.

### Returns
Return 0 on success, negative on failure.
```

--------------------------------

### event_base_new_with_config

Source: https://libevent.org/doc/event_8h_source.html

Creates a new event base using the provided configuration object.

```APIDOC
## struct event_base *event_base_new_with_config(const struct event_config *cfg);

### Description
Initializes and returns a new event_base object based on the settings defined in the provided event_config structure.

### Parameters
- **cfg** (const struct event_config *) - Required - The configuration object containing desired features and flags.
```

--------------------------------

### evconnlistener_new_bind

Source: https://libevent.org/doc/listener_8h_source.html

Creates a new connection listener that binds to a specific address and port.

```APIDOC
## evconnlistener_new_bind

### Description
Allocates and returns a new evconnlistener object that binds to the specified address and starts listening for connections.

### Signature
struct evconnlistener *evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, const struct sockaddr *sa, int socklen);
```

--------------------------------

### Include watch.h header

Source: https://libevent.org/doc/watch_8h.html

Include this header to access watcher preparation and checking functionality.

```c
#include <event2/visibility.h>
```

--------------------------------

### event_base_init_common_timeout()

Source: https://libevent.org/doc/event_8h.html

Prepare an event_base to use a large number of timeouts with the same duration.

```APIDOC
## const struct timeval * event_base_init_common_timeout(struct event_base *base, const struct timeval *duration)

### Description
Prepare an event_base to use a large number of timeouts with the same duration. This optimization improves performance when managing thousands of events with identical timeout durations.

### Parameters
- **base** (struct event_base *) - Required - The event_base to optimize.
- **duration** (const struct timeval *) - Required - The common duration to optimize for.

### Returns
- **const struct timeval *** - Returns a pointer to an opaque timeout value to be used in event_add().
```

--------------------------------

### evutil_vsnprintf

Source: https://libevent.org/doc/util_8h_source.html

A portable implementation of vsnprintf for formatted string output.

```APIDOC
## int evutil_vsnprintf(char *buf, size_t buflen, const char *format, va_list ap)

### Description
Formats a string into a buffer with a specified length, similar to the standard vsnprintf.

### Parameters
- **buf** (char*) - The destination buffer.
- **buflen** (size_t) - The maximum size of the buffer.
- **format** (const char*) - The format string.
- **ap** (va_list) - The variable argument list.
```

--------------------------------

### evutil_inet_pton()

Source: https://libevent.org/doc/util_8h.html

Converts a network address from text form to binary form, serving as a cross-platform replacement for inet_pton.

```APIDOC
## evutil_inet_pton()

### Description
Replacement for inet_pton for platforms which lack it. src must not be NULL.

### Signature
int evutil_inet_pton(int af, const char * src, void * dst)
```

--------------------------------

### evrpc_make_request

Source: https://libevent.org/doc/rpc_8h_source.html

Initiates an RPC request using the provided context wrapper.

```APIDOC
## evrpc_make_request

### Description
Makes an RPC request based on the provided context.

### Signature
`int evrpc_make_request(struct evrpc_request_wrapper *ctx)`
```

--------------------------------

### HTTP Connection Configuration

Source: https://libevent.org/doc/http_8h_source.html

Functions for configuring HTTP connection behavior and flags.

```c
EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_family(struct evhttp_connection *evcon,
 int family);

EVENT2_EXPORT_SYMBOL
int evhttp_connection_set_flags(struct evhttp_connection *evcon,
 int flags);

EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_ext_method_cmp(struct evhttp_connection *evcon,
 evhttp_ext_method_cb cmp);

EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
 ev_ssize_t new_max_headers_size);

EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
 ev_ssize_t new_max_body_size);

EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_local_address(struct evhttp_connection *evcon,
 const char *address);

EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_local_port(struct evhttp_connection *evcon,
```

--------------------------------

### evconnlistener_new

Source: https://libevent.org/doc/listener_8h_source.html

Allocates a new evconnlistener object to listen for incoming TCP connections on a given file descriptor.

```APIDOC
## evconnlistener_new

### Description
Allocates a new evconnlistener object to listen for incoming TCP connections on a given file descriptor.

### Signature
`struct evconnlistener * evconnlistener_new(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, evutil_socket_t fd)`
```

--------------------------------

### evdns_base_config_windows_nameservers

Source: https://libevent.org/doc/dns_8h.html

Configures nameservers using Windows platform settings.

```APIDOC
## evdns_base_config_windows_nameservers

### Description
Obtain nameserver information using the Windows API. This function attempts to configure a set of nameservers based on platform settings on a win32 host, preferentially using GetNetworkParams or the registry.

### Signature
int evdns_base_config_windows_nameservers(struct evdns_base *base)

### Returns
- 0 if successful
- -1 if an error occurred
```

--------------------------------

### Logging and Fatal Callbacks

Source: https://libevent.org/doc/event_8h_source.html

Macros and functions for configuring custom logging and fatal error handling.

```c
#define EVENT_LOG_DEBUG 0
#define EVENT_LOG_MSG 1
#define EVENT_LOG_WARN 2
#define EVENT_LOG_ERR 3

#define _EVENT_LOG_DEBUG EVENT_LOG_DEBUG
#define _EVENT_LOG_MSG EVENT_LOG_MSG
#define _EVENT_LOG_WARN EVENT_LOG_WARN
#define _EVENT_LOG_ERR EVENT_LOG_ERR

typedef void (*event_log_cb)(int severity, const char *msg);

EVENT2_EXPORT_SYMBOL
void event_set_log_callback(event_log_cb cb);

typedef void (*event_fatal_cb)(int err);

EVENT2_EXPORT_SYMBOL
void event_set_fatal_callback(event_fatal_cb cb);

#define EVENT_DBG_ALL 0xffffffffu
#define EVENT_DBG_NONE 0

EVENT2_EXPORT_SYMBOL
void event_enable_debug_logging(ev_uint32_t which);
```

--------------------------------

### evutil_getaddrinfo

Source: https://libevent.org/doc/util_8h_source.html

Clones the getaddrinfo functionality for systems that lack it.

```APIDOC
## int evutil_getaddrinfo(const char *nodename, const char *servname, const struct evutil_addrinfo *hints_in, struct evutil_addrinfo **res)

### Description
This function provides a cross-platform implementation of getaddrinfo for systems that do not natively support it.

### Parameters
- **nodename** (const char *) - The node name or numeric host address.
- **servname** (const char *) - The service name or port number.
- **hints_in** (const struct evutil_addrinfo *) - Optional hints to filter the results.
- **res** (struct evutil_addrinfo **) - Pointer to store the resulting address information list.
```

--------------------------------

### signal_set Macro

Source: https://libevent.org/doc/event__compat_8h.html

Sets up a signal event with EV_SIGNAL and EV_PERSIST flags.

```c
#define signal_set(ev, x, cb, arg) event_set((ev), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
```

--------------------------------

### evsignal_set Macro Definition

Source: https://libevent.org/doc/event__compat_8h.html

Prepares a signal event structure with persistence enabled.

```c
#define evsignal_set(ev, x, cb, arg) event_set((ev), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
```

--------------------------------

### evhttp_accept_socket_with_handle()

Source: https://libevent.org/doc/http_8h.html

Binds an existing socket file descriptor to an evhttp object and returns a handle for future reference.

```APIDOC
## evhttp_accept_socket_with_handle()

### Description
Like evhttp_accept_socket(), but returns a handle for referencing the socket. The returned pointer is not valid after the http object is freed.

### Parameters
- **http** (struct evhttp *) - Required - A pointer to an evhttp object.
- **fd** (evutil_socket_t) - Required - A socket fd that is ready for accepting connections.

### Returns
- Handle for the socket on success, NULL on failure.
```

--------------------------------

### event_set

Source: https://libevent.org/doc/event__compat_8h_source.html

Prepares an event structure.

```APIDOC
## void event_set(struct event *ev, evutil_socket_t fd, short events, void(*callback)(evutil_socket_t, short, void *), void *arg)

### Description
Initializes an event structure for use with Libevent.

### Parameters
- **ev** (struct event *) - The event structure to initialize.
- **fd** (evutil_socket_t) - The file descriptor to associate with the event.
- **events** (short) - The event types to monitor.
- **callback** (function pointer) - The callback function.
- **arg** (void *) - User-defined argument.
```

--------------------------------

### evdns_nameserver_add

Source: https://libevent.org/doc/dns__compat_8h_source.html

Adds a nameserver to the legacy DNS configuration.

```APIDOC
## int evdns_nameserver_add(unsigned long int address)

### Description
Adds a nameserver by its IP address in network byte order.

### Parameters
- **address** (unsigned long int) - The IP address of the nameserver.
```

--------------------------------

### Connection Listener Lifecycle Management

Source: https://libevent.org/doc/listener_8h_source.html

Functions for creating, binding, and managing the lifecycle of an evconnlistener object.

```c
EVENT2_EXPORT_SYMBOL
struct evconnlistener *evconnlistener_new(struct event_base *base,
 evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
 evutil_socket_t fd);
EVENT2_EXPORT_SYMBOL
struct evconnlistener *evconnlistener_new_bind(struct event_base *base,
 evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
 const struct sockaddr *sa, int socklen);
EVENT2_EXPORT_SYMBOL
void evconnlistener_free(struct evconnlistener *lev);
EVENT2_EXPORT_SYMBOL
int evconnlistener_enable(struct evconnlistener *lev);
EVENT2_EXPORT_SYMBOL
int evconnlistener_disable(struct evconnlistener *lev);
EVENT2_EXPORT_SYMBOL
struct event_base *evconnlistener_get_base(struct evconnlistener *lev);
EVENT2_EXPORT_SYMBOL
evutil_socket_t evconnlistener_get_fd(struct evconnlistener *lev);
EVENT2_EXPORT_SYMBOL
void evconnlistener_set_cb(struct evconnlistener *lev,
```

--------------------------------

### Create connected sockets with evutil_socketpair

Source: https://libevent.org/doc/util_8h.html

Creates a pair of connected sockets, abstracting platform-specific socketpair implementations.

```c
EVENT2_EXPORT_SYMBOL int evutil_socketpair (int domain, int type, int protocol, evutil_socket_t sv[2])
```

--------------------------------

### Create a New Bufferevent

Source: https://libevent.org/doc/bufferevent__compat_8h_source.html

Initializes a new bufferevent object for a given file descriptor with associated callbacks.

```c
EVENT2_EXPORT_SYMBOL
struct bufferevent *bufferevent_new(evutil_socket_t fd,
 evbuffercb readcb, evbuffercb writecb, everrorcb errorcb, void *cbarg);
```

--------------------------------

### evconnlistener_new_bind

Source: https://libevent.org/doc/listener_8h_source.html

Allocates a new evconnlistener object to listen for incoming TCP connections on a given address.

```APIDOC
## evconnlistener_new_bind

### Description
Allocates a new evconnlistener object to listen for incoming TCP connections on a given address.

### Signature
`struct evconnlistener * evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, const struct sockaddr *sa, int socklen)`
```

--------------------------------

### event_init()

Source: https://libevent.org/doc/event__compat_8h.html

Initializes the event API and sets the global current base. This function is deprecated and unsafe for multithreaded use.

```APIDOC
## event_init()

### Description
Initializes the event API. This function sets the global current base that is used for events that have no base associated with them.

### Signature
`struct event_base * event_init(void)`

### Note
This function is deprecated because it replaces the "current" event_base and is not safe for multithreaded use. Use event_base_new() instead.
```

--------------------------------

### EVRPC_MAKE_REQUEST

Source: https://libevent.org/doc/rpc_8h.html

Macro used by the client to launch an RPC and send it to the server.

```APIDOC
## EVRPC_MAKE_REQUEST

### Description
Launches an RPC and sends it to the server. This macro is used by the client to initiate communication.

### Parameters
- **name** (string) - The name of the RPC.
- **pool** (evrpc_pool) - The evrpc_pool containing connection objects.
- **request** (struct) - Pointer to the RPC request structure containing data to be sent.
- **reply** (struct) - Pointer to the RPC reply structure to be filled upon success.
- **cb** (function) - Callback to invoke when the request is answered.
- **cbarg** (void*) - Additional argument passed to the client callback.

### Returns
- **int** - 0 on success, -1 on failure.
```

--------------------------------

### bufferevent_socket_connect_hostname

Source: https://libevent.org/doc/bufferevent_8h_source.html

Initiates a connection to a hostname.

```APIDOC
## bufferevent_socket_connect_hostname

### Description
Initiates a connection to a hostname, performing DNS resolution if necessary.

### Signature
int bufferevent_socket_connect_hostname(struct bufferevent *bufev, struct evdns_base *evdns_base, int family, const char *hostname, int port);

### Parameters
- **bufev** (struct bufferevent *) - Required - The bufferevent to connect.
- **evdns_base** (struct evdns_base *) - Required - The DNS base for resolution.
- **family** (int) - Required - The address family (e.g., AF_INET).
- **hostname** (const char *) - Required - The hostname to connect to.
- **port** (int) - Required - The port number.
```

--------------------------------

### Connection Listener Configuration Flags

Source: https://libevent.org/doc/listener_8h_source.html

Macros used to configure the behavior of the connection listener, such as socket blocking, reuse, and thread safety.

```c
#define LEV_OPT_LEAVE_SOCKETS_BLOCKING (1u<<0)
#define LEV_OPT_CLOSE_ON_FREE (1u<<1)
#define LEV_OPT_CLOSE_ON_EXEC (1u<<2)
#define LEV_OPT_REUSEABLE (1u<<3)
#define LEV_OPT_THREADSAFE (1u<<4)
#define LEV_OPT_DISABLED (1u<<5)
#define LEV_OPT_DEFERRED_ACCEPT (1u<<6)
#define LEV_OPT_REUSEABLE_PORT (1u<<7)
#define LEV_OPT_BIND_IPV6ONLY (1u<<8)
#define LEV_OPT_BIND_IPV4_AND_IPV6 (1u<<9)
```

--------------------------------

### HTTP Request Methods

Source: https://libevent.org/doc/http_8h_source.html

Enumeration of supported HTTP request methods.

```c
enum evhttp_cmd_type {
EVHTTP_REQ_GET = 1 << 0,
EVHTTP_REQ_POST = 1 << 1,
EVHTTP_REQ_HEAD = 1 << 2,
EVHTTP_REQ_PUT = 1 << 3,
EVHTTP_REQ_DELETE = 1 << 4,
EVHTTP_REQ_OPTIONS = 1 << 5,
EVHTTP_REQ_TRACE = 1 << 6,
EVHTTP_REQ_CONNECT = 1 << 7,
EVHTTP_REQ_PATCH = 1 << 8,
EVHTTP_REQ_PROPFIND= 1 << 9,
EVHTTP_REQ_PROPPATCH=1 << 10,
EVHTTP_REQ_MKCOL = 1 << 11,
EVHTTP_REQ_LOCK = 1 << 12,
EVHTTP_REQ_UNLOCK = 1 << 13,
EVHTTP_REQ_COPY = 1 << 14,
EVHTTP_REQ_MOVE = 1 << 15,
};
```

--------------------------------

### Miscellaneous Utilities

Source: https://libevent.org/doc/util_8h_source.html

Additional utility functions for string conversion, time retrieval, and formatting.

```c
int evutil_date_rfc1123(char *date, const size_t datelen, const struct tm *tm);
size_t evutil_strlcpy(char *dst, const char *src, size_t siz);
size_t evutil_strlcat(char *dst, const char *src, size_t siz);
ev_int64_t evutil_strtoll(const char *s, char **endptr, int base);
int evutil_gettimeofday(struct timeval *tv, struct timezone *tz);
int evutil_snprintf(char *buf, size_t buflen, const char *format, ...);
```

--------------------------------

### Define LEV_OPT_BIND_IPV4_AND_IPV6

Source: https://libevent.org/doc/listener_8h.html

Flag to explicitly request a listener to support both IPv4 and IPv6 modes.

```c
#define LEV_OPT_BIND_IPV4_AND_IPV6 (1u<<9)
```

--------------------------------

### Define System-Specific Types

Source: https://libevent.org/doc/util_8h_source.html

Macros for defining ssize_t, off_t, and socket length types.

```c
#ifdef EVENT__ssize_t
#define ev_ssize_t EVENT__ssize_t
#else
#define ev_ssize_t ssize_t
#endif

#ifdef _WIN32
#define ev_off_t ev_int64_t
#elif EVENT__SIZEOF_OFF_T == 8
#define ev_off_t ev_int64_t
#elif EVENT__SIZEOF_OFF_T == 4
#define ev_off_t ev_int32_t
#elif defined(EVENT_IN_DOXYGEN_)
#define ev_off_t ...
#else
#define ev_off_t off_t
#endif

#ifdef _WIN32
#define ev_socklen_t int
#elif defined(EVENT__socklen_t)
#define ev_socklen_t EVENT__socklen_t
#else
#define ev_socklen_t socklen_t
#endif
```

--------------------------------

### ev_token_bucket_cfg_new

Source: https://libevent.org/doc/bufferevent_8h_source.html

Creates a new token bucket configuration for rate limiting.

```APIDOC
## struct ev_token_bucket_cfg *ev_token_bucket_cfg_new(size_t read_rate, size_t read_burst, size_t write_rate, size_t write_burst, const struct timeval *tick_len)

### Description
Allocates and returns a new token bucket configuration structure used for rate limiting bufferevents.

### Parameters
- **read_rate** (size_t) - The number of bytes to allow reading per tick.
- **read_burst** (size_t) - The maximum number of bytes to allow in a single read burst.
- **write_rate** (size_t) - The number of bytes to allow writing per tick.
- **write_burst** (size_t) - The maximum number of bytes to allow in a single write burst.
- **tick_len** (const struct timeval *) - The duration of a single tick.
```

--------------------------------

### evdns_base_nameserver_add

Source: https://libevent.org/doc/dns_8h_source.html

Adds a nameserver to the DNS base configuration.

```APIDOC
## evdns_base_nameserver_add

### Description
Add a nameserver to the specified DNS base.

### Signature
`int evdns_base_nameserver_add(struct evdns_base *base, unsigned long int address)`
```

--------------------------------

### Launch an RPC Request with EVRPC_MAKE_REQUEST

Source: https://libevent.org/doc/rpc_8h.html

Used by the client to send an RPC request to the server. Returns 0 on success and -1 on failure.

```c
#define EVRPC_MAKE_REQUEST(name, pool, request, reply, cb, cbarg) evrpc_send_request_##name((pool), (request), (reply), (cb), (cbarg))
```

--------------------------------

### evdns_resolv_conf_parse()

Source: https://libevent.org/doc/dns__compat_8h.html

Parses a resolv.conf file to configure DNS settings. This function is deprecated as it does not allow specifying an evdns_base.

```APIDOC
## int evdns_resolv_conf_parse(int flags, const char *const filename)

### Description
Parses a resolv.conf file based on the provided flags. Note that certain directives like sortlist, rotate, and others are not supported.

### Parameters
- **flags** (int) - Configuration flags (e.g., DNS_OPTION_NAMESERVERS, DNS_OPTION_SEARCH, DNS_OPTION_MISC, DNS_OPTIONS_ALL).
- **filename** (const char *const) - The path to the resolv.conf file.

### Returns
- **int** - 0 if successful, or a positive error code (1-6) if an error occurred.
```

--------------------------------

### evconnlistener_enable / evconnlistener_disable

Source: https://libevent.org/doc/listener_8h_source.html

Enables or disables the connection listener.

```APIDOC
## evconnlistener_enable / evconnlistener_disable

### Description
Enables or disables the listener to stop or resume accepting new connections.

### Signature
int evconnlistener_enable(struct evconnlistener *lev);
int evconnlistener_disable(struct evconnlistener *lev);
```

--------------------------------

### evhttp_new

Source: https://libevent.org/doc/http_8h_source.html

Creates a new HTTP server object associated with the provided event base.

```APIDOC
## evhttp_new

### Description
Creates a new HTTP server object. The server will use the provided event_base for event notification.

### Parameters
- **base** (struct event_base*) - Required - The event base to associate with the HTTP server.

### Response
- **evhttp*** - A pointer to the newly created evhttp object.
```

--------------------------------

### ev_token_bucket_cfg_free

Source: https://libevent.org/doc/bufferevent_8h.html

Frees all storage held in a token bucket configuration.

```APIDOC
## void ev_token_bucket_cfg_free(struct ev_token_bucket_cfg *cfg)

### Description
Free all storage held in 'cfg'. Note: 'cfg' is not currently reference-counted; it is not safe to free it until no bufferevent is using it.
```

--------------------------------

### RPC Context Management

Source: https://libevent.org/doc/rpc_8h_source.html

Functions and macros for creating and managing RPC request contexts.

```c
EVENT2_EXPORT_SYMBOL
struct evrpc_request_wrapper *evrpc_make_request_ctx(
 struct evrpc_pool *pool, void *request, void *reply,
 const char *rpcname,
 void (*req_marshal)(struct evbuffer*, void *),
 void (*rpl_clear)(void *),
 int (*rpl_unmarshal)(void *, struct evbuffer *),
 void (*cb)(struct evrpc_status *, void *, void *, void *),
 void *cbarg);
```

```c
#define EVRPC_MAKE_CTX(rpcname, reqstruct, rplystruct, \
 pool, request, reply, cb, cbarg) \
 evrpc_make_request_ctx(pool, request, reply, \
 #rpcname, \
 (void (*)(struct evbuffer *, void *))reqstruct##_marshal, \
 (void (*)(void *))rplystruct##_clear, \
 (int (*)(void *, struct evbuffer *))rplystruct##_unmarshal, \
 (void (*)(struct evrpc_status *, void *, void *, void *))cb, \
 cbarg)
```

--------------------------------

### Signal Compatibility Macros

Source: https://libevent.org/doc/event__compat_8h_source.html

Legacy macros for signal event operations.

```c
#define signal_del(ev) event_del(ev)
#define signal_pending(ev, tv) event_pending((ev), EV_SIGNAL, (tv))
#define signal_initialized(ev) event_initialized(ev)
```

--------------------------------

### RPC Request Wrapper Configuration

Source: https://libevent.org/doc/rpc_8h_source.html

Functions to configure the pool and callback for an RPC request wrapper.

```c
EVENT2_EXPORT_SYMBOL
struct evrpc_pool* evrpc_request_get_pool(struct evrpc_request_wrapper *ctx);
```

```c
EVENT2_EXPORT_SYMBOL
void evrpc_request_set_pool(struct evrpc_request_wrapper *ctx,
 struct evrpc_pool *pool);
```

```c
EVENT2_EXPORT_SYMBOL
void evrpc_request_set_cb(struct evrpc_request_wrapper *ctx,
 void (*cb)(struct evrpc_status*, void *request, void *reply, void *arg),
 void *cb_arg);
```
Tokens:
Raw