ABI
Tracker

(Libevent)

Headers diff: 2.1.12 vs current

buffer_compat.h (2.1.12)		buffer_compat.h (current)

skipping to change at line 34 ¶		skipping to change at line 34 ¶
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/		*/

#ifndef EVENT2_BUFFER_COMPAT_H_INCLUDED_		#ifndef EVENT2_BUFFER_COMPAT_H_INCLUDED_
#define EVENT2_BUFFER_COMPAT_H_INCLUDED_		#define EVENT2_BUFFER_COMPAT_H_INCLUDED_

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

/** @file event2/buffer_compat.h		/** @file event2/buffer_compat.h

Obsolete and deprecated versions of the functions in buffer.h: provi ded		@brief Obsolete and deprecated versions of the functions in buffer.h : provided
only for backward compatibility.		only for backward compatibility.
*/		*/

/**		/**
Obsolete alias for evbuffer_readln(buffer, NULL, EVBUFFER_EOL_ANY).		Obsolete alias for evbuffer_readln(buffer, NULL, EVBUFFER_EOL_ANY).

@deprecated This function is deprecated because its behavior is not corr ect		@deprecated This function is deprecated because its behavior is not corr ect
for almost any protocol, and also because it's wholly subsumed by		for almost any protocol, and also because it's wholly subsumed by
evbuffer_readln().		evbuffer_readln().


End of changes. 1 change blocks.
1 lines changed or deleted		1 lines changed or added

bufferevent.h (2.1.12)		bufferevent.h (current)

skipping to change at line 33 ¶		skipping to change at line 33 ¶
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/		*/
#ifndef EVENT2_BUFFEREVENT_H_INCLUDED_		#ifndef EVENT2_BUFFEREVENT_H_INCLUDED_
#define EVENT2_BUFFEREVENT_H_INCLUDED_		#define EVENT2_BUFFEREVENT_H_INCLUDED_

/**		/**
@file event2/bufferevent.h		@file event2/bufferevent.h

Functions for buffering data for network sending or receiving. Buffereve		@brief Functions for buffering data for network sending or receiving.
nts
are higher level than evbuffers: each has an underlying evbuffer for read		Bufferevents are higher level than evbuffers: each has an underlying evbu
ing		ffer for reading
and one for writing, and callbacks that are invoked under certain		and one for writing, and callbacks that are invoked under certain
circumstances.		circumstances.

A bufferevent provides input and output buffers that get filled and		A bufferevent provides input and output buffers that get filled and
drained automatically. The user of a bufferevent no longer deals		drained automatically. The user of a bufferevent no longer deals
directly with the I/O, but instead is reading from input and writing		directly with the I/O, but instead is reading from input and writing
to output buffers.		to output buffers.

Once initialized, the bufferevent structure can be used repeatedly		Once initialized, the bufferevent structure can be used repeatedly
with bufferevent_enable() and bufferevent_disable().		with bufferevent_enable() and bufferevent_disable().

skipping to change at line 212 ¶		skipping to change at line 213 ¶
and configure the bufferevent so that a BEV_EVENT_CONNECTED event will b e		and configure the bufferevent so that a BEV_EVENT_CONNECTED event will b e
yielded when it is done connecting.		yielded when it is done connecting.

@param bufev an existing bufferevent allocated with		@param bufev an existing bufferevent allocated with
bufferevent_socket_new().		bufferevent_socket_new().
@param addr the address we should connect to		@param addr the address we should connect to
@param socklen The length of the address		@param socklen The length of the address
@return 0 on success, -1 on failure.		@return 0 on success, -1 on failure.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int bufferevent_socket_connect(struct bufferevent , const struct sockaddr , int);		int bufferevent_socket_connect(struct bufferevent bufev, const struct sock addr addr, int socklen);

struct evdns_base;		struct evdns_base;
/**		/**
Resolve the hostname 'hostname' and connect to it as with		Resolve the hostname 'hostname' and connect to it as with
bufferevent_socket_connect().		bufferevent_socket_connect().

@param bufev An existing bufferevent allocated with bufferevent_socket_n ew()		@param bufev An existing bufferevent allocated with bufferevent_socket_n ew()
@param evdns_base Optionally, an evdns_base to use for resolving hostnam es		@param evdns_base Optionally, an evdns_base to use for resolving hostnam es
asynchronously. May be set to NULL for a blocking resolve.		asynchronously. May be set to NULL for a blocking resolve.
@param family A preferred address family to resolve addresses to, or		@param family A preferred address family to resolve addresses to, or
AF_UNSPEC for no preference. Only AF_INET, AF_INET6, and AF_UNSPEC a re		AF_UNSPEC for no preference. Only AF_INET, AF_INET6, and AF_UNSPEC a re
supported.		supported.
@param hostname The hostname to resolve; see below for notes on recogniz ed		@param hostname The hostname to resolve; see below for notes on recogniz ed
formats		formats
@param port The port to connect to on the resolved address.		@param port The port to connect to on the resolved address.
@return 0 if successful, -1 on failure.		@return 0 if successful, -1 on failure.

		@see bufferevent_socket_connect_hostname_hints()
		*/
		EVENT2_EXPORT_SYMBOL
		int bufferevent_socket_connect_hostname(struct bufferevent *bufev,
		struct evdns_base evdns_base, int family, const char hostname, int po
		rt);

		/**
		Resolve the hostname 'hostname' and connect to it as with
		bufferevent_socket_connect().

		@param bufev An existing bufferevent allocated with bufferevent_socket_n
		ew()
		@param evdns_base Optionally, an evdns_base to use for resolving hostnam
		es
		asynchronously. May be set to NULL for a blocking resolve.
		@param hints_in points to an addrinfo structure that specifies criteria
		for
		selecting the socket address structures to be used
		@param hostname The hostname to resolve; see below for notes on recogniz
		ed
		formats
		@param port The port to connect to on the resolved address.
		@return 0 if successful, -1 on failure.

Recognized hostname formats are:		Recognized hostname formats are:

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

Performance note: If you do not provide an evdns_base, this function		Performance note: If you do not provide an evdns_base, this function
may block while it waits for a DNS response. This is probably no t		may block while it waits for a DNS response. This is probably no t
what you want.		what you want.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int bufferevent_socket_connect_hostname(struct bufferevent *,		int bufferevent_socket_connect_hostname_hints(struct bufferevent *bufev,
struct evdns_base , int, const char , int);		struct evdns_base evdns_base, const struct evutil_addrinfo hints_in,
		const char *hostname, int port);

/**		/**
Return the error code for the last failed DNS lookup attempt made by		Return the error code for the last failed DNS lookup attempt made by
bufferevent_socket_connect_hostname().		bufferevent_socket_connect_hostname().

@param bev The bufferevent object.		@param bev The bufferevent object.
@return DNS error code.		@return DNS error code.
@see evutil_gai_strerror()		@see evutil_gai_strerror()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL

skipping to change at line 889 ¶		skipping to change at line 910 ¶
/** Remove 'bev' from its current rate-limit group (if any). */		/** Remove 'bev' from its current rate-limit group (if any). */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int bufferevent_remove_from_rate_limit_group(struct bufferevent *bev);		int bufferevent_remove_from_rate_limit_group(struct bufferevent *bev);

/**		/**
Set the size limit for single read operation.		Set the size limit for single read operation.

Set to 0 for a reasonable default.		Set to 0 for a reasonable default.

Return 0 on success and -1 on failure.		Return 0 on success and -1 on failure.

		@see evbuffer_set_max_read()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int bufferevent_set_max_single_read(struct bufferevent *bev, size_t size);		int bufferevent_set_max_single_read(struct bufferevent *bev, size_t size);

/**		/**
Set the size limit for single write operation.		Set the size limit for single write operation.

Set to 0 for a reasonable default.		Set to 0 for a reasonable default.

Return 0 on success and -1 on failure.		Return 0 on success and -1 on failure.

End of changes. 5 change blocks.
7 lines changed or deleted		35 lines changed or added

bufferevent_ssl.h (2.1.12)		bufferevent_ssl.h (current)

skipping to change at line 31 ¶		skipping to change at line 31 ¶
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/		*/
#ifndef EVENT2_BUFFEREVENT_SSL_H_INCLUDED_		#ifndef EVENT2_BUFFEREVENT_SSL_H_INCLUDED_
#define EVENT2_BUFFEREVENT_SSL_H_INCLUDED_		#define EVENT2_BUFFEREVENT_SSL_H_INCLUDED_

/** @file event2/bufferevent_ssl.h		/** @file event2/bufferevent_ssl.h

OpenSSL support for bufferevents.		@brief OpenSSL support for bufferevents.
*/		*/
#include <event2/visibility.h>		#include <event2/visibility.h>
#include <event2/event-config.h>		#include <event2/event-config.h>
#include <event2/bufferevent.h>		#include <event2/bufferevent.h>
#include <event2/util.h>		#include <event2/util.h>

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

/* This is what openssl's SSL objects are underneath. */
struct ssl_st;

/**		/**
The state of an SSL object to be used when creating a new		The state of an SSL object to be used when creating a new
SSL bufferevent.		SSL bufferevent.
*/		*/
enum bufferevent_ssl_state {		enum bufferevent_ssl_state {
BUFFEREVENT_SSL_OPEN = 0,		BUFFEREVENT_SSL_OPEN = 0,
BUFFEREVENT_SSL_CONNECTING = 1,		BUFFEREVENT_SSL_CONNECTING = 1,
BUFFEREVENT_SSL_ACCEPTING = 2		BUFFEREVENT_SSL_ACCEPTING = 2
};		};

		/** Control how to report dirty SSL shutdowns.

		If the peer (or the network, or an attacker) closes the TCP
		connection before closing the SSL channel, and the protocol is SSL >= v
		3,
		this is a "dirty" shutdown. If BUFFEREVENT_SSL_DIRTY_SHUTDOWN is not s
		et
		(default), this is reported as BEV_EVENT_ERROR.

		If instead BUFFEREVENT_SSL_DIRTY_SHUTDOWN is set, a dirty shutdown is
		reported as BEV_EVENT_EOF.

		(Note that if the protocol is < SSLv3, you will always receive
		BEV_EVENT_EOF, since SSL 2 and earlier cannot distinguish a secure
		connection close from a dirty one. This is one reason (among many)
		not to use SSL 2.)
		*/
		#define BUFFEREVENT_SSL_DIRTY_SHUTDOWN 1
		/** Control writes in the SSL bufferevents.

		By default SSL bufferevent will peek bytes from the buffer as the arriv
		ed.
		with respect to the segment boundaries in the buffer.
		However, by ignoring these segment boundaries number of packets to send
		can be decreased.

		This flags will ignore the segment boundaries.

		Useful in conjunction with http layer.
		*/
		#define BUFFEREVENT_SSL_BATCH_WRITE 2

		#if defined(EVENT__HAVE_OPENSSL) \|\| defined(EVENT__HAVE_MBEDTLS)
		/**
		* Get flags of the SSL bufferevent.
		*
		* @see BUFFEREVENT_SSL_*
		* @return flags or SIZE_MAX in case of error (if bufferevent is not SSL).
		*/
		EVENT2_EXPORT_SYMBOL
		ev_uint64_t bufferevent_ssl_get_flags(struct bufferevent *bev);
		/** Change the flags that are set for an ssl bufferevent by adding more.
		*
		* @param bev the ssl bufferevent.
		* @param flags One or more BUFFEREVENT_SSL_* options
		* @return old flags success, EV_UINT64_MAX on failure.
		*/
		EVENT2_EXPORT_SYMBOL
		ev_uint64_t bufferevent_ssl_set_flags(struct bufferevent *bev, ev_uint64_t
		flags);
		/** Change the flags that are set for an ssl bufferevent by removing some.
		*
		* @param bev the bufferevent.
		* @param flags One or more BUFFEREVENT_SSL_* options
		* @return old flags success, EV_UINT64_MAX on failure.
		*/
		EVENT2_EXPORT_SYMBOL
		ev_uint64_t bufferevent_ssl_clear_flags(struct bufferevent *bev, ev_uint64_
		t flags);

		#endif /* defined(EVENT__HAVE_OPENSSL) \|\| defined(EVENT__HAVE_MBEDTLS) */

#if defined(EVENT__HAVE_OPENSSL) \|\| defined(EVENT_IN_DOXYGEN_)		#if defined(EVENT__HAVE_OPENSSL) \|\| defined(EVENT_IN_DOXYGEN_)
		/* This is what openssl's SSL objects are underneath. */
		struct ssl_st;

/**		/**
Create a new SSL bufferevent to send its data over another bufferevent.		Create a new SSL bufferevent to send its data over another bufferevent.

@param base An event_base to use to detect reading and writing. It		@param base An event_base to use to detect reading and writing. It
must also be the base for the underlying bufferevent.		must also be the base for the underlying bufferevent.
@param underlying A socket to use for this SSL		@param underlying A socket to use for this SSL
@param ssl A SSL* object from openssl.		@param ssl A SSL* object from openssl.
@param state The current state of the SSL connection		@param state The current state of the SSL connection
@param options One or more bufferevent_options		@param options One or more bufferevent_options
@return A new bufferevent on success, or NULL on failure		@return A new bufferevent on success, or NULL on failure

skipping to change at line 93 ¶		skipping to change at line 150 ¶
@return A new bufferevent on success, or NULL on failure.		@return A new bufferevent on success, or NULL on failure.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct bufferevent *		struct bufferevent *
bufferevent_openssl_socket_new(struct event_base *base,		bufferevent_openssl_socket_new(struct event_base *base,
evutil_socket_t fd,		evutil_socket_t fd,
struct ssl_st *ssl,		struct ssl_st *ssl,
enum bufferevent_ssl_state state,		enum bufferevent_ssl_state state,
int options);		int options);

/** Control how to report dirty SSL shutdowns.		/**
		* Get value of the BUFFEREVENT_SSL_DIRTY_SHUTDOWN flag.
If the peer (or the network, or an attacker) closes the TCP		*
connection before closing the SSL channel, and the protocol is SSL >= v		* @see BUFFEREVENT_SSL_DIRTY_SHUTDOWN
3,		* @deprecated This function is deprecated, use bufferevent_ssl_get_flags()
this is a "dirty" shutdown. If allow_dirty_shutdown is 0 (default),		instead.
this is reported as BEV_EVENT_ERROR.		* @see bufferevent_ssl_get_flags()
		*/
If instead allow_dirty_shutdown=1, a dirty shutdown is reported as
BEV_EVENT_EOF.

(Note that if the protocol is < SSLv3, you will always receive
BEV_EVENT_EOF, since SSL 2 and earlier cannot distinguish a secure
connection close from a dirty one. This is one reason (among many)
not to use SSL 2.)
*/

EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int bufferevent_openssl_get_allow_dirty_shutdown(struct bufferevent *bev);		int bufferevent_openssl_get_allow_dirty_shutdown(struct bufferevent *bev);
		/**
		* Set value of the BUFFEREVENT_SSL_DIRTY_SHUTDOWN flag.
		*
		* @see BUFFEREVENT_SSL_DIRTY_SHUTDOWN
		* @deprecated This function is deprecated, use bufferevent_ssl_set_flags()
		instead.
		* @see bufferevent_ssl_set_flags()
		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void bufferevent_openssl_set_allow_dirty_shutdown(struct bufferevent *bev,		void bufferevent_openssl_set_allow_dirty_shutdown(struct bufferevent *bev,
int allow_dirty_shutdown);		int allow_dirty_shutdown);

/** Return the underlying openssl SSL * object for an SSL bufferevent. */		/** Return the underlying openssl SSL * object for an SSL bufferevent. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct ssl_st *		struct ssl_st *
bufferevent_openssl_get_ssl(struct bufferevent *bufev);		bufferevent_openssl_get_ssl(struct bufferevent *bufev);

/** Tells a bufferevent to begin SSL renegotiation. */		/** Tells a bufferevent to begin SSL renegotiation. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int bufferevent_ssl_renegotiate(struct bufferevent *bev);		int bufferevent_ssl_renegotiate(struct bufferevent *bev);

/** Return the most recent OpenSSL error reported on an SSL bufferevent. */		/** Return the most recent OpenSSL error reported on an SSL bufferevent. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
unsigned long bufferevent_get_openssl_error(struct bufferevent *bev);		unsigned long bufferevent_get_openssl_error(struct bufferevent *bev);

#endif		#endif
		#if defined(EVENT__HAVE_MBEDTLS) \|\| defined(EVENT_IN_DOXYGEN_)
		struct mbedtls_ssl_context;
		/**
		Create a new SSL bufferevent to send its data over another bufferevent.

		@param base An event_base to use to detect reading and writing. It
		must also be the base for the underlying bufferevent.
		@param underlying A socket to use for this SSL
		@param ssl A SSL* object from openssl.
		@param state The current state of the SSL connection
		@param options One or more bufferevent_options
		@return A new bufferevent on success, or NULL on failure
		*/
		EVENT2_EXPORT_SYMBOL
		struct bufferevent *
		bufferevent_mbedtls_filter_new(struct event_base *base,
		struct bufferevent *underlying,
		struct mbedtls_ssl_context *ssl,
		enum bufferevent_ssl_state state,
		int options);

		/**
		Create a new SSL bufferevent to send its data over an SSL * on a socket.

		@param base An event_base to use to detect reading and writing
		@param fd A socket to use for this SSL
		@param ssl A SSL* object from mbedtls.
		@param state The current state of the SSL connection
		@param options One or more bufferevent_options
		@return A new bufferevent on success, or NULL on failure.
		*/
		EVENT2_EXPORT_SYMBOL
		struct bufferevent *
		bufferevent_mbedtls_socket_new(struct event_base *base,
		evutil_socket_t fd,
		struct mbedtls_ssl_context *ssl,
		enum bufferevent_ssl_state state,
		int options);

		/**
		* Get value of the BUFFEREVENT_SSL_DIRTY_SHUTDOWN flag.
		*
		* @see BUFFEREVENT_SSL_DIRTY_SHUTDOWN
		* @deprecated This function is deprecated, use bufferevent_ssl_get_flags()
		instead.
		* @see bufferevent_ssl_get_flags()
		*/
		EVENT2_EXPORT_SYMBOL
		int bufferevent_mbedtls_get_allow_dirty_shutdown(struct bufferevent *bev);
		/**
		* Set value of the BUFFEREVENT_SSL_DIRTY_SHUTDOWN flag.
		*
		* @see BUFFEREVENT_SSL_DIRTY_SHUTDOWN
		* @deprecated This function is deprecated, use bufferevent_ssl_set_flags()
		instead.
		* @see bufferevent_ssl_set_flags()
		*/
		EVENT2_EXPORT_SYMBOL
		void bufferevent_mbedtls_set_allow_dirty_shutdown(struct bufferevent *bev,
		int allow_dirty_shutdown);

		/** Return the underlying mbedtls SSL * object for an SSL bufferevent. */
		EVENT2_EXPORT_SYMBOL
		struct mbedtls_ssl_context *
		bufferevent_mbedtls_get_ssl(struct bufferevent *bufev);

		/** Tells a bufferevent to begin SSL renegotiation. */
		EVENT2_EXPORT_SYMBOL
		int bufferevent_mbedtls_renegotiate(struct bufferevent *bev);

		/** Return the most recent OpenSSL error reported on an SSL bufferevent. */
		EVENT2_EXPORT_SYMBOL
		unsigned long bufferevent_get_mbedtls_error(struct bufferevent *bev);

		#endif

#ifdef __cplusplus		#ifdef __cplusplus
}		}
#endif		#endif

#endif /* EVENT2_BUFFEREVENT_SSL_H_INCLUDED_ */		#endif /* EVENT2_BUFFEREVENT_SSL_H_INCLUDED_ */

End of changes. 7 change blocks.
21 lines changed or deleted		157 lines changed or added

bufferevent_struct.h (2.1.12)		bufferevent_struct.h (current)

skipping to change at line 90 ¶		skipping to change at line 90 ¶
struct event ev_read;		struct event ev_read;
/** A write event that triggers when a timeout has happened or a soc ket		/** A write event that triggers when a timeout has happened or a soc ket
is ready to write data. Only used by some subtypes of		is ready to write data. Only used by some subtypes of
bufferevent. */		bufferevent. */
struct event ev_write;		struct event ev_write;

/** An input buffer. Only the bufferevent is allowed to add data to		/** An input buffer. Only the bufferevent is allowed to add data to
this buffer, though the user is allowed to drain it. */		this buffer, though the user is allowed to drain it. */
struct evbuffer *input;		struct evbuffer *input;

/** An input buffer. Only the bufferevent is allowed to drain data		/** An output buffer. Only the bufferevent is allowed to drain data
from this buffer, though the user is allowed to add it. */		from this buffer, though the user is allowed to add it. */
struct evbuffer *output;		struct evbuffer *output;

struct event_watermark wm_read;		struct event_watermark wm_read;
struct event_watermark wm_write;		struct event_watermark wm_write;

bufferevent_data_cb readcb;		bufferevent_data_cb readcb;
bufferevent_data_cb writecb;		bufferevent_data_cb writecb;
/* This should be called 'eventcb', but renaming it would break		/* This should be called 'eventcb', but renaming it would break
* backward compatibility */		* backward compatibility */

End of changes. 1 change blocks.
1 lines changed or deleted		1 lines changed or added

dns.h (2.1.12)		dns.h (current)

skipping to change at line 52 ¶		skipping to change at line 52 ¶
*		*
* You may wish to replace the word "Parts" with something else depending o n		* You may wish to replace the word "Parts" with something else depending o n
* the amount of original code.		* the amount of original code.
*		*
* (Derivative works does not include programs which link against, run or i nclude		* (Derivative works does not include programs which link against, run or i nclude
* the source verbatim in their source distributions)		* the source verbatim in their source distributions)
*/		*/

/** @file event2/dns.h		/** @file event2/dns.h
*		*
		* @brief Provides a few APIs to use for resolving DNS names, and a facilit
		y
		* for implementing simple DNS servers.
		*
* Welcome, gentle reader		* Welcome, gentle reader
*		*
* Async DNS lookups are really a whole lot harder than they should be,		* Async DNS lookups are really a whole lot harder than they should be,
* mostly stemming from the fact that the libc resolver has never been		* mostly stemming from the fact that the libc resolver has never been
* very good at them. Before you use this library you should see if libc		* very good at them. Before you use this library you should see if libc
* can do the job for you with the modern async call getaddrinfo_a		* can do the job for you with the modern async call getaddrinfo_a
* (see http://www.imperialviolet.org/page25.html#e498). Otherwise,		* (see http://www.imperialviolet.org/page25.html#e498). Otherwise,
* please continue.		* please continue.
*		*
* The library keeps track of the state of nameservers and will avoid		* The library keeps track of the state of nameservers and will avoid
* them when they go down. Otherwise it will round robin between them.		* them when they go down. Otherwise it will round robin between them.
*		*
* Quick start guide:		* Quick start guide:
		* @code
* #include "evdns.h"		* #include "evdns.h"
* void callback(int result, char type, int count, int ttl,		* void callback(int result, char type, int count, int ttl,
* void addresses, void arg);		* void addresses, void arg);
* evdns_resolv_conf_parse(DNS_OPTIONS_ALL, "/etc/resolv.conf");		* evdns_resolv_conf_parse(DNS_OPTIONS_ALL, "/etc/resolv.conf");
* evdns_resolve("www.hostname.com", 0, callback, NULL);		* evdns_resolve("www.hostname.com", 0, callback, NULL);
*		*@endcode
* When the lookup is complete the callback function is called. The		* When the lookup is complete the callback function is called. The
* first argument will be one of the DNS_ERR_* defines in evdns.h.		* first argument will be one of the DNS_ERR_* defines in evdns.h.
* Hopefully it will be DNS_ERR_NONE, in which case type will be		* Hopefully it will be DNS_ERR_NONE, in which case type will be
* DNS_IPv4_A, count will be the number of IP addresses, ttl is the time		* DNS_IPv4_A, count will be the number of IP addresses, ttl is the time
* which the data can be cached for (in seconds), addresses will point		* which the data can be cached for (in seconds), addresses will point
* to an array of uint32_t's and arg will be whatever you passed to		* to an array of uint32_t's and arg will be whatever you passed to
* evdns_resolve.		* evdns_resolve.
*		*
* Searching:		* Searching:
*		*

skipping to change at line 109 ¶		skipping to change at line 113 ¶
*		*
* The order of searches depends on the number of dots in the name. If the		* The order of searches depends on the number of dots in the name. If the
* number is greater than the ndots setting then the names is first tried		* number is greater than the ndots setting then the names is first tried
* globally. Otherwise each search domain is appended in turn.		* globally. Otherwise each search domain is appended in turn.
*		*
* The ndots setting can either be set from a resolv.conf, or by calling		* The ndots setting can either be set from a resolv.conf, or by calling
* evdns_search_ndots_set.		* evdns_search_ndots_set.
*		*
* For example, with ndots set to 1 (the default) and a search domain list of		* For example, with ndots set to 1 (the default) and a search domain list of
* ["myhome.net"]:		* ["myhome.net"]:
		*
		* <pre>
* Query: www		* Query: www
* Order: www.myhome.net, www.		* Order: www.myhome.net, www.
*		*
* Query: www.abc		* Query: www.abc
* Order: www.abc., www.abc.myhome.net		* Order: www.abc., www.abc.myhome.net
*		* </pre>
* Internals:		* Internals:
*		*
* Requests are kept in two queues. The first is the inflight queue. In		* Requests are kept in two queues. The first is the inflight queue. In
* this queue requests have an allocated transaction id and nameserver.		* this queue requests have an allocated transaction id and nameserver.
* They will soon be transmitted if they haven't already been.		* They will soon be transmitted if they haven't already been.
*		*
* The second is the waiting queue. The size of the inflight ring is		* The second is the waiting queue. The size of the inflight ring is
* limited and all other requests wait in waiting queue for space. This		* limited and all other requests wait in waiting queue for space. This
* bounds the number of concurrent requests so that we don't flood the		* bounds the number of concurrent requests so that we don't flood the
* nameserver. Several algorithms require a full walk of the inflight		* nameserver. Several algorithms require a full walk of the inflight

skipping to change at line 180 ¶		skipping to change at line 186 ¶
#define DNS_ERR_CANCEL 69		#define DNS_ERR_CANCEL 69
/** There were no answers and no error condition in the DNS packet.		/** There were no answers and no error condition in the DNS packet.
* This can happen when you ask for an address that exists, but a record		* This can happen when you ask for an address that exists, but a record
* type that doesn't. */		* type that doesn't. */
#define DNS_ERR_NODATA 70		#define DNS_ERR_NODATA 70

#define DNS_IPv4_A 1		#define DNS_IPv4_A 1
#define DNS_PTR 2		#define DNS_PTR 2
#define DNS_IPv6_AAAA 3		#define DNS_IPv6_AAAA 3

#define DNS_QUERY_NO_SEARCH 1		/** Disable searching for the query. */
		#define DNS_QUERY_NO_SEARCH 0x01
		/** Use TCP connections ("virtual circuits") for queries rather than UDP da
		tagrams. */
		#define DNS_QUERY_USEVC 0x02
		/** Ignore trancation flag in responses (don't fallback to TCP connections)
		. */
		#define DNS_QUERY_IGNTC 0x04

/* Allow searching */		/* Allow searching */
#define DNS_OPTION_SEARCH 1		#define DNS_OPTION_SEARCH 1
/* Parse "nameserver" and add default if no such section */		/* Parse "nameserver" and add default if no such section */
#define DNS_OPTION_NAMESERVERS 2		#define DNS_OPTION_NAMESERVERS 2
/* Parse additional options like:		/* Parse additional options like:
* - timeout:		* - timeout:
* - getaddrinfo-allow-skew:		* - getaddrinfo-allow-skew:
* - max-timeouts:		* - max-timeouts:
* - max-inflight:		* - max-inflight:
* - attempts:		* - attempts:
* - randomize-case:		* - randomize-case:
* - initial-probe-timeout:		* - initial-probe-timeout:
		* - max-probe-timeout:
		* - probe-backoff-factor:
		* - tcp-idle-timeout:
		* - edns-udp-size:
		* - use-vc
		* - ignore-tc
*/		*/
#define DNS_OPTION_MISC 4		#define DNS_OPTION_MISC 4
/* Load hosts file (i.e. "/etc/hosts") */		/* Load hosts file (i.e. "/etc/hosts") */
#define DNS_OPTION_HOSTSFILE 8		#define DNS_OPTION_HOSTSFILE 8
/**		/**
* All above:		* All above:
* - DNS_OPTION_SEARCH		* - DNS_OPTION_SEARCH
* - DNS_OPTION_NAMESERVERS		* - DNS_OPTION_NAMESERVERS
* - DNS_OPTION_MISC		* - DNS_OPTION_MISC
* - DNS_OPTION_HOSTSFILE		* - DNS_OPTION_HOSTSFILE

skipping to change at line 252 ¶		skipping to change at line 269 ¶
#define EVDNS_BASE_NAMESERVERS_NO_DEFAULT 0x10000		#define EVDNS_BASE_NAMESERVERS_NO_DEFAULT 0x10000

/**		/**
Initialize the asynchronous DNS library.		Initialize the asynchronous DNS library.

This function initializes support for non-blocking name resolution by		This function initializes support for non-blocking name resolution by
calling evdns_resolv_conf_parse() on UNIX and		calling evdns_resolv_conf_parse() on UNIX and
evdns_config_windows_nameservers() on Windows.		evdns_config_windows_nameservers() on Windows.

@param event_base the event base to associate the dns client with		@param event_base the event base to associate the dns client with
@param flags any of EVDNS_BASE_INITIALIZE_NAMESERVERS\|		@param initialize_nameservers any of EVDNS_BASE_INITIALIZE_NAMESERVERS\|
EVDNS_BASE_DISABLE_WHEN_INACTIVE\|EVDNS_BASE_NAMESERVERS_NO_DEFAULT		EVDNS_BASE_DISABLE_WHEN_INACTIVE\|EVDNS_BASE_NAMESERVERS_NO_DEFAULT
@return evdns_base object if successful, or NULL if an error occurred.		@return evdns_base object if successful, or NULL if an error occurred.
@see evdns_base_free()		@see evdns_base_free()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evdns_base * evdns_base_new(struct event_base *event_base, int initi alize_nameservers);		struct evdns_base * evdns_base_new(struct event_base *event_base, int initi alize_nameservers);

/**		/**
Shut down the asynchronous DNS resolver and terminate all active requests .		Shut down the asynchronous DNS resolver and terminate all active requests .

If the 'fail_requests' option is enabled, all active requests will return		If the 'fail_requests' option is enabled, all active requests will return
an empty result with the error flag set to DNS_ERR_SHUTDOWN. Otherwise,		an empty result with the error flag set to DNS_ERR_SHUTDOWN. Otherwise,
the requests will be silently discarded.		the requests will be silently discarded.

@param evdns_base the evdns base to free		@param base the evdns base to free
@param fail_requests if zero, active requests will be aborted; if non-zer o,		@param fail_requests if zero, active requests will be aborted; if non-zer o,
active requests will return DNS_ERR_SHUTDOWN.		active requests will return DNS_ERR_SHUTDOWN.
@see evdns_base_new()		@see evdns_base_new()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evdns_base_free(struct evdns_base *base, int fail_requests);		void evdns_base_free(struct evdns_base *base, int fail_requests);

/**		/**
Remove all hosts entries that have been loaded into the event_base via		Remove all hosts entries that have been loaded into the event_base via
evdns_base_load_hosts or via event_base_resolv_conf_parse.		evdns_base_load_hosts or via event_base_resolv_conf_parse.

@param evdns_base the evdns base to remove outdated host addresses from		@param base the evdns base to remove outdated host addresses from
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evdns_base_clear_host_addresses(struct evdns_base *base);		void evdns_base_clear_host_addresses(struct evdns_base *base);

/**		/**
Convert a DNS error code to a string.		Convert a DNS error code to a string.

@param err the DNS error code		@param err the DNS error code
@return a string containing an explanation of the error code		@return a string containing an explanation of the error code
*/		*/

skipping to change at line 384 ¶		skipping to change at line 401 ¶
evdns_base_nameserver_sockaddr_add(struct evdns_base *base,		evdns_base_nameserver_sockaddr_add(struct evdns_base *base,
const struct sockaddr *sa, ev_socklen_t len, unsigned flags);		const struct sockaddr *sa, ev_socklen_t len, unsigned flags);

struct evdns_request;		struct evdns_request;

/**		/**
Lookup an A record for a given name.		Lookup an A record for a given name.

@param base the evdns_base to which to apply this operation		@param base the evdns_base to which to apply this operation
@param name a DNS hostname		@param name a DNS hostname
@param flags either 0, or DNS_QUERY_NO_SEARCH to disable searching for th is query.		@param flags either 0, or combination of DNS_QUERY_* flags.
@param callback a callback function to invoke when the request is complet ed		@param callback a callback function to invoke when the request is complet ed
@param ptr an argument to pass to the callback function		@param ptr an argument to pass to the callback function
@return an evdns_request object if successful, or NULL if an error occurr ed.		@return an evdns_request object if successful, or NULL if an error occurr ed.
@see evdns_resolve_ipv6(), evdns_resolve_reverse(), evdns_resolve_reverse _ipv6(), evdns_cancel_request()		@see evdns_resolve_ipv6(), evdns_resolve_reverse(), evdns_resolve_reverse _ipv6(), evdns_cancel_request()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evdns_request evdns_base_resolve_ipv4(struct evdns_base base, cons t char name, int flags, evdns_callback_type callback, void ptr);		struct evdns_request evdns_base_resolve_ipv4(struct evdns_base base, cons t char name, int flags, evdns_callback_type callback, void ptr);

/**		/**
Lookup an AAAA record for a given name.		Lookup an AAAA record for a given name.

@param base the evdns_base to which to apply this operation		@param base the evdns_base to which to apply this operation
@param name a DNS hostname		@param name a DNS hostname
@param flags either 0, or DNS_QUERY_NO_SEARCH to disable searching for th is query.		@param flags either 0, or combination of DNS_QUERY_* flags.
@param callback a callback function to invoke when the request is complet ed		@param callback a callback function to invoke when the request is complet ed
@param ptr an argument to pass to the callback function		@param ptr an argument to pass to the callback function
@return an evdns_request object if successful, or NULL if an error occurr ed.		@return an evdns_request object if successful, or NULL if an error occurr ed.
@see evdns_resolve_ipv4(), evdns_resolve_reverse(), evdns_resolve_reverse _ipv6(), evdns_cancel_request()		@see evdns_resolve_ipv4(), evdns_resolve_reverse(), evdns_resolve_reverse _ipv6(), evdns_cancel_request()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evdns_request evdns_base_resolve_ipv6(struct evdns_base base, cons t char name, int flags, evdns_callback_type callback, void ptr);		struct evdns_request evdns_base_resolve_ipv6(struct evdns_base base, cons t char name, int flags, evdns_callback_type callback, void ptr);

struct in_addr;		struct in_addr;
struct in6_addr;		struct in6_addr;

/**		/**
Lookup a PTR record for a given IP address.		Lookup a PTR record for a given IP address.

@param base the evdns_base to which to apply this operation		@param base the evdns_base to which to apply this operation
@param in an IPv4 address		@param in an IPv4 address
@param flags either 0, or DNS_QUERY_NO_SEARCH to disable searching for th is query.		@param flags either 0, or combination of DNS_QUERY_* flags.
@param callback a callback function to invoke when the request is complet ed		@param callback a callback function to invoke when the request is complet ed
@param ptr an argument to pass to the callback function		@param ptr an argument to pass to the callback function
@return an evdns_request object if successful, or NULL if an error occurr ed.		@return an evdns_request object if successful, or NULL if an error occurr ed.
@see evdns_resolve_reverse_ipv6(), evdns_cancel_request()		@see evdns_resolve_reverse_ipv6(), evdns_cancel_request()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evdns_request evdns_base_resolve_reverse(struct evdns_base base, c onst struct in_addr in, int flags, evdns_callback_type callback, void ptr );		struct evdns_request evdns_base_resolve_reverse(struct evdns_base base, c onst struct in_addr in, int flags, evdns_callback_type callback, void ptr );

/**		/**
Lookup a PTR record for a given IPv6 address.		Lookup a PTR record for a given IPv6 address.

@param base the evdns_base to which to apply this operation		@param base the evdns_base to which to apply this operation
@param in an IPv6 address		@param in an IPv6 address
@param flags either 0, or DNS_QUERY_NO_SEARCH to disable searching for th is query.		@param flags either 0, or combination of DNS_QUERY_* flags.
@param callback a callback function to invoke when the request is complet ed		@param callback a callback function to invoke when the request is complet ed
@param ptr an argument to pass to the callback function		@param ptr an argument to pass to the callback function
@return an evdns_request object if successful, or NULL if an error occurr ed.		@return an evdns_request object if successful, or NULL if an error occurr ed.
@see evdns_resolve_reverse_ipv6(), evdns_cancel_request()		@see evdns_resolve_reverse_ipv6(), evdns_cancel_request()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evdns_request evdns_base_resolve_reverse_ipv6(struct evdns_base ba se, const struct in6_addr in, int flags, evdns_callback_type callback, voi d ptr);		struct evdns_request evdns_base_resolve_reverse_ipv6(struct evdns_base ba se, const struct in6_addr in, int flags, evdns_callback_type callback, voi d ptr);

/**		/**
Cancels a pending DNS resolution request.		Cancels a pending DNS resolution request.

skipping to change at line 454 ¶		skipping to change at line 471 ¶
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evdns_cancel_request(struct evdns_base base, struct evdns_request re q);		void evdns_cancel_request(struct evdns_base base, struct evdns_request re q);

/**		/**
Set the value of a configuration option.		Set the value of a configuration option.

The currently available configuration options are:		The currently available configuration options are:

ndots, timeout, max-timeouts, max-inflight, attempts, randomize-case,		ndots, timeout, max-timeouts, max-inflight, attempts, randomize-case,
bind-to, initial-probe-timeout, getaddrinfo-allow-skew,		bind-to, initial-probe-timeout, max-probe-timeout, probe-backoff-factor
so-rcvbuf, so-sndbuf.		,
		getaddrinfo-allow-skew, so-rcvbuf, so-sndbuf, tcp-idle-timeout, use-vc,
		ignore-tc, edns-udp-size.

		- probe-backoff-factor
		Backoff factor of probe timeout

		- max-probe-timeout
		Maximum timeout between two probe packets will change initial-probe-tim
		eout
		when this value is smaller

In versions before Libevent 2.0.3-alpha, the option name needed to end wi th		In versions before Libevent 2.0.3-alpha, the option name needed to end wi th
a colon.		a colon.

		In case of options without values (use-vc, ingore-tc) val should be an em
		pty
		string or NULL.

@param base the evdns_base to which to apply this operation		@param base the evdns_base to which to apply this operation
@param option the name of the configuration option to be modified		@param option the name of the configuration option to be modified
@param val the value to be set		@param val the value to be set
@return 0 if successful, or -1 if an error occurred		@return 0 if successful, or -1 if an error occurred
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evdns_base_set_option(struct evdns_base base, const char option, cons t char *val);		int evdns_base_set_option(struct evdns_base base, const char option, cons t char *val);

/**		/**
Parse a resolv.conf file.		Parse a resolv.conf file.

skipping to change at line 634 ¶		skipping to change at line 662 ¶

#define EVDNS_QTYPE_AXFR 252		#define EVDNS_QTYPE_AXFR 252
#define EVDNS_QTYPE_ALL 255		#define EVDNS_QTYPE_ALL 255

#define EVDNS_CLASS_INET 1		#define EVDNS_CLASS_INET 1

/* flags that can be set in answers; as part of the err parameter */		/* flags that can be set in answers; as part of the err parameter */
#define EVDNS_FLAGS_AA 0x400		#define EVDNS_FLAGS_AA 0x400
#define EVDNS_FLAGS_RD 0x080		#define EVDNS_FLAGS_RD 0x080

/** Create a new DNS server port.		/** Create a new UDP DNS server port.

@param base The event base to handle events for the server port.		@param base The event base to handle events for the server port.
@param socket A UDP socket to accept DNS requests.		@param socket A UDP socket to accept DNS requests.
@param flags Always 0 for now.		@param flags Always 0 for now.
@param callback A function to invoke whenever we get a DNS request		@param callback A function to invoke whenever we get a DNS request
on the socket.		on the socket.
@param user_data Data to pass to the callback.		@param user_data Data to pass to the callback.
@return an evdns_server_port structure for this server port or NULL if		@return an evdns_server_port structure for this server port or NULL if
an error occurred.		an error occurred.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evdns_server_port evdns_add_server_port_with_base(struct event_base base, evutil_socket_t socket, int flags, evdns_request_callback_fn_type c allback, void *user_data);		struct evdns_server_port evdns_add_server_port_with_base(struct event_base base, evutil_socket_t socket, int flags, evdns_request_callback_fn_type c allback, void *user_data);

		struct evconnlistener;

		/** Create a new TCP DNS server port.

		@param base The event base to handle events for the server port.
		@param listener A TCP listener to accept DNS requests.
		@param flags Always 0 for now.
		@param callback A function to invoke whenever we get a DNS request
		on the socket.
		@param user_data Data to pass to the callback.
		@return an evdns_server_port structure for this server port or NULL if
		an error occurred.
		*/
		EVENT2_EXPORT_SYMBOL
		struct evdns_server_port *evdns_add_server_port_with_listener(
		struct event_base base, struct evconnlistener listener, int flags,
		evdns_request_callback_fn_type callback, void *user_data);

/** Close down a DNS server port, and free associated structures. */		/** Close down a DNS server port, and free associated structures. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evdns_close_server_port(struct evdns_server_port *port);		void evdns_close_server_port(struct evdns_server_port *port);

		/**
		* List of configurable evdns_server_port options.
		*
		* @see evdns_server_port_set_option()
		*/
		enum evdns_server_option {
		/**
		* Maximum number of simultaneous tcp connections (clients)
		* that server can hold. Can be set only for TCP DNS servers.
		*/
		EVDNS_SOPT_TCP_MAX_CLIENTS,
		/**
		* Idle timeout (in seconds) of incoming TCP connections.
		* If client doesn't send any requests via the connection
		* during this period connection is closed by the server.
		* Can be set only for TCP DNS servers.
		*/
		EVDNS_SOPT_TCP_IDLE_TIMEOUT,
		};

		/**
		Configure DNS server.

		@param port the evdns_server_port to which to apply this operation
		@param option @see evdns_server_option for the list of possible options
		@param val value of the option
		@return 0 if successful, or -1 if an error occurred
		*/
		EVENT2_EXPORT_SYMBOL
		int evdns_server_port_set_option(struct evdns_server_port *port, enum evdns
		_server_option option, size_t value);

/** Sets some flags in a reply we're building.		/** Sets some flags in a reply we're building.
Allows setting of the AA or RD flags		Allows setting of the AA or RD flags
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evdns_server_request_set_flags(struct evdns_server_request *req, int f lags);		void evdns_server_request_set_flags(struct evdns_server_request *req, int f lags);

/* Functions to add an answer to an in-progress DNS reply.		/* Functions to add an answer to an in-progress DNS reply.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evdns_server_request_add_reply(struct evdns_server_request req, int se ction, const char name, int type, int dns_class, int ttl, int datalen, int is_name, const char *data);		int evdns_server_request_add_reply(struct evdns_server_request req, int se ction, const char name, int type, int dns_class, int ttl, int datalen, int is_name, const char *data);

End of changes. 19 change blocks.
13 lines changed or deleted		98 lines changed or added

event_struct.h (2.1.12)		event_struct.h (current)

skipping to change at line 129 ¶		skipping to change at line 129 ¶
void *evcb_arg;		void *evcb_arg;
};		};

struct event_base;		struct event_base;
struct event {		struct event {
struct event_callback ev_evcallback;		struct event_callback ev_evcallback;

/* for managing timeouts */		/* for managing timeouts */
union {		union {
TAILQ_ENTRY(event) ev_next_with_common_timeout;		TAILQ_ENTRY(event) ev_next_with_common_timeout;
int min_heap_idx;		size_t min_heap_idx;
} ev_timeout_pos;		} ev_timeout_pos;
evutil_socket_t ev_fd;		evutil_socket_t ev_fd;

		short ev_events;
		short ev_res; /* result passed to event callback */

struct event_base *ev_base;		struct event_base *ev_base;

union {		union {
/* used for io events */		/* used for io events */
struct {		struct {
LIST_ENTRY (event) ev_io_next;		LIST_ENTRY (event) ev_io_next;
struct timeval ev_timeout;		struct timeval ev_timeout;
} ev_io;		} ev_io;

/* used by signal events */		/* used by signal events */
struct {		struct {
LIST_ENTRY (event) ev_signal_next;		LIST_ENTRY (event) ev_signal_next;
short ev_ncalls;		short ev_ncalls;
/* Allows deletes in callback */		/* Allows deletes in callback */
short *ev_pncalls;		short *ev_pncalls;
} ev_signal;		} ev_signal;
} ev_;		} ev_;

short ev_events;
short ev_res; /* result passed to event callback */
struct timeval ev_timeout;		struct timeval ev_timeout;
};		};

TAILQ_HEAD (event_list, event);		TAILQ_HEAD (event_list, event);

#ifdef EVENT_DEFINED_TQENTRY_		#ifdef EVENT_DEFINED_TQENTRY_
#undef TAILQ_ENTRY		#undef TAILQ_ENTRY
#endif		#endif

#ifdef EVENT_DEFINED_TQHEAD_		#ifdef EVENT_DEFINED_TQHEAD_

End of changes. 3 change blocks.
3 lines changed or deleted		4 lines changed or added

http.h (2.1.12)		http.h (current)

skipping to change at line 46 ¶		skipping to change at line 46 ¶
#endif		#endif

/* In case we haven't included the right headers yet. */		/* In case we haven't included the right headers yet. */
struct evbuffer;		struct evbuffer;
struct event_base;		struct event_base;
struct bufferevent;		struct bufferevent;
struct evhttp_connection;		struct evhttp_connection;

/** @file event2/http.h		/** @file event2/http.h
*		*
* Basic support for HTTP serving.		* @brief Basic support for HTTP serving.
*		*
* As Libevent is a library for dealing with event notification and most		* As Libevent is a library for dealing with event notification and most
* interesting applications are networked today, I have often found the		* interesting applications are networked today, I have often found the
* need to write HTTP code. The following prototypes and definitions provi de		* need to write HTTP code. The following prototypes and definitions provi de
* an application with a minimal interface for making HTTP requests and for		* an application with a minimal interface for making HTTP requests and for
* creating a very simple HTTP server.		* creating a very simple HTTP server.
*/		*/

/* Response codes */		/* Response codes */
#define HTTP_OK 200 /*< request completed ok /		#define HTTP_OK 200 /*< request completed ok /

skipping to change at line 76 ¶		skipping to change at line 76 ¶
#define HTTP_INTERNAL 500 /*< internal error /		#define HTTP_INTERNAL 500 /*< internal error /
#define HTTP_NOTIMPLEMENTED 501 /*< not implemented /		#define HTTP_NOTIMPLEMENTED 501 /*< not implemented /
#define HTTP_SERVUNAVAIL 503 /*< the server is not available /		#define HTTP_SERVUNAVAIL 503 /*< the server is not available /

struct evhttp;		struct evhttp;
struct evhttp_request;		struct evhttp_request;
struct evkeyvalq;		struct evkeyvalq;
struct evhttp_bound_socket;		struct evhttp_bound_socket;
struct evconnlistener;		struct evconnlistener;
struct evdns_base;		struct evdns_base;
		struct evhttp_ext_method;

/**		/**
* Create a new HTTP server.		* Create a new HTTP server.
*		*
* @param base (optional) the event base to receive the HTTP events		* @param base (optional) the event base to receive the HTTP events
* @return a pointer to a newly initialized evhttp server structure or NULL		* @return a pointer to a newly initialized evhttp server structure or NULL
* on error		* on error
* @see evhttp_free()		* @see evhttp_free()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL

skipping to change at line 226 ¶		skipping to change at line 227 ¶
void evhttp_free(struct evhttp* http);		void evhttp_free(struct evhttp* http);

/** XXX Document. */		/** XXX Document. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_max_headers_size(struct evhttp* http, ev_ssize_t max_header s_size);		void evhttp_set_max_headers_size(struct evhttp* http, ev_ssize_t max_header s_size);
/** XXX Document. */		/** XXX Document. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_max_body_size(struct evhttp* http, ev_ssize_t max_body_size );		void evhttp_set_max_body_size(struct evhttp* http, ev_ssize_t max_body_size );

/**		/**
		* Set the maximum number of simultaneous connections for this server.
		* A value of zero or less disables the limit.
		*
		* @param http the http server on which to set the max connection limit
		* @param max_connections the maximum number of simultaneous connections or
		0
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_set_max_connections(struct evhttp* http, int max_connections);

		/**
		* Get the current number of connections.
		*
		* @return The current number of connections for this server.
		*/
		EVENT2_EXPORT_SYMBOL
		int evhttp_get_connection_count(struct evhttp* http);

		/**
Set the value to use for the Content-Type header when none was provided. If		Set the value to use for the Content-Type header when none was provided. If
the content type string is NULL, the Content-Type header will not be		the content type string is NULL, the Content-Type header will not be
automatically added.		automatically added.

@param http the http server on which to set the default content type		@param http the http server on which to set the default content type
@param content_type the value for the Content-Type header		@param content_type the value for the Content-Type header
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_default_content_type(struct evhttp *http,		void evhttp_set_default_content_type(struct evhttp *http,
const char *content_type);		const char *content_type);

skipping to change at line 249 ¶		skipping to change at line 268 ¶
server, and passed to user callbacks.		server, and passed to user callbacks.

If not supported they will generate a "405 Method not allowed" response.		If not supported they will generate a "405 Method not allowed" response.

By default this includes the following methods: GET, POST, HEAD, PUT, DEL ETE		By default this includes the following methods: GET, POST, HEAD, PUT, DEL ETE

@param http the http server on which to set the methods		@param http the http server on which to set the methods
@param methods bit mask constructed from evhttp_cmd_type values		@param methods bit mask constructed from evhttp_cmd_type values
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_allowed_methods(struct evhttp* http, ev_uint16_t methods);		void evhttp_set_allowed_methods(struct evhttp* http, ev_uint32_t methods);

		typedef int (evhttp_ext_method_cb)(struct evhttp_ext_method );
		/**
		Sets the callback function which allows HTTP extended methods
		to be supported by this server.

		The callback should :
		- if method field is NULL : set method field according to type field
		- else : set type and flags fields according to method string
		- return 0 for success (known method / type)
		- return -1 for error (unknown method / type)

		evhttp_set_allowed_methods still needs to be called.

		@param http the http server on which to add support to the methods
		@param cmp the extended method callback
		@see evhttp_ext_method
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_set_ext_method_cmp(struct evhttp *http, evhttp_ext_method_cb cm
		p);

/**		/**
Set a callback for a specified URI		Set a callback for a specified URI

@param http the http sever on which to set the callback		@param http the http sever on which to set the callback
@param path the path for which to invoke the callback		@param path the path for which to invoke the callback
@param cb the callback function that gets invoked on requesting path		@param cb the callback function that gets invoked on requesting path
@param cb_arg an additional context argument for the callback		@param cb_arg an additional context argument for the callback
@return 0 on success, -1 if the callback existed already, -2 on failure		@return 0 on success, -1 if the callback existed already, -2 on failure
*/		*/

skipping to change at line 302 ¶		skipping to change at line 341 ¶

@param http the evhttp server object for which to set the callback		@param http the evhttp server object for which to set the callback
@param cb the callback to invoke for incoming connections		@param cb the callback to invoke for incoming connections
@param arg an context argument for the callback		@param arg an context argument for the callback
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_bevcb(struct evhttp *http,		void evhttp_set_bevcb(struct evhttp *http,
struct bufferevent (cb)(struct event_base , void ), void *arg);		struct bufferevent (cb)(struct event_base , void ), void *arg);

/**		/**
		Set a callback which allows the user to note or throttle incoming reques
		ts.

		The requests are not populated with HTTP level information. They
		are just associated to a connection.

		If the callback returns -1, the associated connection is terminated
		and the request is closed.

		@param http the evhttp server object for which to set the callback
		@param cb the callback to invoke for incoming connections
		@param arg an context argument for the callback
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_set_newreqcb(struct evhttp *http,
		int (cb)(struct evhttp_request, void ), void arg);

		/**
		Set a callback to output for any error pages sent for requests of a give
		n
		evhttp object.

		You can use this to override the default error pages sent, allowing such
		things as multi-lingual support or customization to match other pages.

		The callback should use the supplied buffer to output the text for an
		error page. If the callback returns a negative value or doesn't output
		anything to the buffer, the default error page will be sent instead. The
		buffer will be automatically be sent when the callback returns, so the
		callback shouldn't do so itself.

		Microsoft Internet Explorer may display its own error pages if ones sent
		by
		an HTTP server are smaller than certain sizes, depending on the status c
		ode.
		To reliably suppress this feature an error page should be at least 512
		bytes in size.

		@param http the evhttp server object for which to set the callback
		@param cb the callback to invoke to format error pages
		@param arg an context argument for the callback
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_set_errorcb(struct evhttp *http,
		int (cb)(struct evhttp_request req, struct evbuffer *buffer, int erro
		r, const char reason, void cbarg),
		void *cbarg);

		/**
Adds a virtual host to the http server.		Adds a virtual host to the http server.

A virtual host is a newly initialized evhttp object that has request		A virtual host is a newly initialized evhttp object that has request
callbacks set on it via evhttp_set_cb() or evhttp_set_gencb(). It		callbacks set on it via evhttp_set_cb() or evhttp_set_gencb(). It
most not have any listing sockets associated with it.		most not have any listing sockets associated with it.

If the virtual host has not been removed by the time that evhttp_free()		If the virtual host has not been removed by the time that evhttp_free()
is called on the main http server, it will be automatically freed, too.		is called on the main http server, it will be automatically freed, too.

It is possible to have hierarchical vhosts. For example: A vhost		It is possible to have hierarchical vhosts. For example: A vhost

skipping to change at line 363 ¶		skipping to change at line 446 ¶
@param alias the alias to remove		@param alias the alias to remove
@see evhttp_add_server_alias()		@see evhttp_add_server_alias()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evhttp_remove_server_alias(struct evhttp http, const char alias);		int evhttp_remove_server_alias(struct evhttp http, const char alias);

/**		/**
* Set the timeout for an HTTP request.		* Set the timeout for an HTTP request.
*		*
* @param http an evhttp object		* @param http an evhttp object
* @param timeout_in_secs the timeout, in seconds		* @param timeout the timeout, in seconds
		* @see evhttp_set_timeout_tv()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_timeout(struct evhttp *http, int timeout_in_secs);		void evhttp_set_timeout(struct evhttp *http, int timeout);

/**		/**
* Set the timeout for an HTTP request.		* Set read and write timeout for an HTTP request.
*		*
* @param http an evhttp object		* @param http an evhttp object
* @param tv the timeout, or NULL		* @param tv the timeout, or NULL
		*
		* For more precise control:
		* @see evhttp_set_read_timeout_tv()
		* @see evhttp_set_write_timeout_tv()
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_set_timeout_tv(struct evhttp http, const struct timeval tv);		void evhttp_set_timeout_tv(struct evhttp http, const struct timeval tv);

		/**
		* Set read timeout for an HTTP request.
		*
		* @param http an evhttp object
		* @param tv the timeout, or NULL
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_set_read_timeout_tv(struct evhttp http, const struct timeval
		tv);

		/**
		* Set write timeout for an HTTP request.
		*
		* @param http an evhttp object
		* @param tv the timeout, or NULL
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_set_write_timeout_tv(struct evhttp http, const struct timeval
		tv);

/* Read all the clients body, and only after this respond with an error if the		/* Read all the clients body, and only after this respond with an error if the
* clients body exceed max_body_size */		* clients body exceed max_body_size */
#define EVHTTP_SERVER_LINGERING_CLOSE 0x0001		#define EVHTTP_SERVER_LINGERING_CLOSE 0x0001
/**		/**
* Set connection flags for HTTP server.		* Set connection flags for HTTP server.
*		*
* @see EVHTTP_SERVER_*		* @see EVHTTP_SERVER_*
* @return 0 on success, otherwise non zero (for example if flag doesn't		* @return 0 on success, otherwise non zero (for example if flag doesn't
* supported).		* supported).
*/		*/

skipping to change at line 467 ¶		skipping to change at line 573 ¶
Send another data chunk as part of an ongoing chunked reply.		Send another data chunk as part of an ongoing chunked reply.

The reply chunk consists of the data in databuf. After calling		The reply chunk consists of the data in databuf. After calling
evhttp_send_reply_chunk() databuf will be empty, but the buffer is		evhttp_send_reply_chunk() databuf will be empty, but the buffer is
still owned by the caller and needs to be deallocated by the caller		still owned by the caller and needs to be deallocated by the caller
if necessary.		if necessary.

@param req a request object		@param req a request object
@param databuf the data chunk to send as part of the reply.		@param databuf the data chunk to send as part of the reply.
@param cb callback funcion		@param cb callback funcion
@param call back's argument.		@param arg call back's argument.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_send_reply_chunk_with_cb(struct evhttp_request , struct evbuff er ,		void evhttp_send_reply_chunk_with_cb(struct evhttp_request req, struct evb uffer databuf,
void (cb)(struct evhttp_connection , void ), void arg);		void (cb)(struct evhttp_connection , void ), void arg);

/**		/**
Complete a chunked reply, freeing the request as appropriate.		Complete a chunked reply, freeing the request as appropriate.

@param req a request object		@param req a request object
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_send_reply_end(struct evhttp_request *req);		void evhttp_send_reply_end(struct evhttp_request *req);

/*		/*
* Interfaces for making requests		* Interfaces for making requests
*/		*/

/** The different request types supported by evhttp. These are as specifie d		/** The different request types supported by evhttp. These are as specifie d
* in RFC2616, except for PATCH which is specified by RFC5789.		* in RFC2616, except for:
		* - PATCH which is specified by RFC5789
		* - PROPFIND, PROPPATCH, MKCOL, LOCK, UNLOCK, COPY, MOVE
		* which are specified by RFC4918
*		*
* By default, only some of these methods are accepted and passed to user		* By default, only some of these methods are accepted and passed to user
* callbacks; use evhttp_set_allowed_methods() to change which methods		* callbacks; use evhttp_set_allowed_methods() to change which methods
* are allowed.		* are allowed.
*/		*/
enum evhttp_cmd_type {		enum evhttp_cmd_type {
EVHTTP_REQ_GET = 1 << 0,		EVHTTP_REQ_GET = 1 << 0,
EVHTTP_REQ_POST = 1 << 1,		EVHTTP_REQ_POST = 1 << 1,
EVHTTP_REQ_HEAD = 1 << 2,		EVHTTP_REQ_HEAD = 1 << 2,
EVHTTP_REQ_PUT = 1 << 3,		EVHTTP_REQ_PUT = 1 << 3,
EVHTTP_REQ_DELETE = 1 << 4,		EVHTTP_REQ_DELETE = 1 << 4,
EVHTTP_REQ_OPTIONS = 1 << 5,		EVHTTP_REQ_OPTIONS = 1 << 5,
EVHTTP_REQ_TRACE = 1 << 6,		EVHTTP_REQ_TRACE = 1 << 6,
EVHTTP_REQ_CONNECT = 1 << 7,		EVHTTP_REQ_CONNECT = 1 << 7,
EVHTTP_REQ_PATCH = 1 << 8		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,
		};

		#define EVHTTP_REQ_MAX EVHTTP_REQ_MOVE

		/**
		* @brief stucture that is passed to (and modified by) the
		* extended method callback function
		*
		* @see evhttp_set_ext_method_cmp
		* @see evhttp_connection_set_ext_method_cmp
		*/
		struct evhttp_ext_method {
		const char *method;
		ev_uint32_t type; /* @see enum evhttp_cmd_type */
		ev_uint16_t flags; /* Available flag : EVHTTP_METHOD_HAS_BODY *
		/
};		};

		#define EVHTTP_METHOD_HAS_BODY 0x0001

/** a request object can represent either a request or a reply */		/** a request object can represent either a request or a reply */
enum evhttp_request_kind { EVHTTP_REQUEST, EVHTTP_RESPONSE };		enum evhttp_request_kind { EVHTTP_REQUEST, EVHTTP_RESPONSE };

/**		/**
* Create and return a connection object that can be used to for making HTT P		* Create and return a connection object that can be used to for making HTT P
* requests. The connection object tries to resolve address and establish the		* requests. The connection object tries to resolve address and establish the
* connection when it is given an http request object.		* connection when it is given an http request object.
*		*
		* Connection also has default timeouts for the following events:
		* - connect HTTP_CONNECT_TIMEOUT, which is 45 seconds
		* - read HTTP_READ_TIMEOUT which is 50 seconds
		* - write HTTP_WRITE_TIMEOUT, which is 50 seconds
		*
* @param base the event_base to use for handling the connection		* @param base the event_base to use for handling the connection
* @param dnsbase the dns_base to use for resolving host names; if not		* @param dnsbase the dns_base to use for resolving host names; if not
* specified host name resolution will block.		* specified host name resolution will block.
* @param bev a bufferevent to use for connecting to the server; if NULL, a		* @param bev a bufferevent to use for connecting to the server; if NULL, a
* socket-based bufferevent will be created. This buffrevent will be f reed		* socket-based bufferevent will be created. This buffrevent will be f reed
* when the connection closes. It must have no fd set on it.		* when the connection closes. It must have no fd set on it.
* @param address the address to which to connect		* @param address the address to which to connect
* @param port the port to connect to		* @param port the port to connect to
* @return an evhttp_connection object that can be used for making requests or		* @return an evhttp_connection object that can be used for making requests or
* NULL on error		* NULL on error

skipping to change at line 690 ¶		skipping to change at line 828 ¶
* evhttp_request_free() is explicitly called by the user.		* evhttp_request_free() is explicitly called by the user.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_request_own(struct evhttp_request *req);		void evhttp_request_own(struct evhttp_request *req);

/** Returns 1 if the request is owned by the user */		/** Returns 1 if the request is owned by the user */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evhttp_request_is_owned(struct evhttp_request *req);		int evhttp_request_is_owned(struct evhttp_request *req);

/**		/**
		* Sets extended method cmp callback for this http connection.
		*
		* @see evhttp_set_ext_method_cmp
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_connection_set_ext_method_cmp(struct evhttp_connection *evcon,
		evhttp_ext_method_cb cmp);

		/**
* Returns the connection object associated with the request or NULL		* Returns the connection object associated with the request or NULL
*		*
* The user needs to either free the request explicitly or call		* The user needs to either free the request explicitly or call
* evhttp_send_reply_end().		* evhttp_send_reply_end().
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evhttp_connection evhttp_request_get_connection(struct evhttp_reque st req);		struct evhttp_connection evhttp_request_get_connection(struct evhttp_reque st req);

/**		/**
* Returns the underlying event_base for this connection		* Returns the underlying event_base for this connection

skipping to change at line 724 ¶		skipping to change at line 871 ¶
void evhttp_connection_free(struct evhttp_connection *evcon);		void evhttp_connection_free(struct evhttp_connection *evcon);

/** Disowns a given connection object		/** Disowns a given connection object
*		*
* Can be used to tell libevent to free the connection object after		* Can be used to tell libevent to free the connection object after
* the last request has completed or failed.		* the last request has completed or failed.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_free_on_completion(struct evhttp_connection *evcon);		void evhttp_connection_free_on_completion(struct evhttp_connection *evcon);

/** sets the ip address from which http connections are made */		/** Sets the IP address from which http connections are made
		*
		* Note this resets internal bufferevent fd, so any options that had been
		* installed will be flushed.
		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_local_address(struct evhttp_connection *evcon,		void evhttp_connection_set_local_address(struct evhttp_connection *evcon,
const char *address);		const char *address);

/** sets the local port from which http connections are made */		/** sets the local port from which http connections are made */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_local_port(struct evhttp_connection *evcon,		void evhttp_connection_set_local_port(struct evhttp_connection *evcon,
ev_uint16_t port);		ev_uint16_t port);

/** Sets the timeout in seconds for events related to this connection */		/**
		* Sets the timeout for this connection.
		*
		* @see evhttp_connection_set_timeout_tv()
		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_timeout(struct evhttp_connection *evcon,		void evhttp_connection_set_timeout(struct evhttp_connection *evcon,
int timeout_in_secs);		int timeout);

/** Sets the timeout for events related to this connection. Takes a struct		/**
* timeval. */		* Sets the timeout for this connection for the following events:
		* - read, if tv==NULL then it uses default timeout (HTTP_READ_TIMEOUT)
		* - write, if tv==NULL then it uses default timeout (HTTP_WRITE_TIMEOUT)
		*
		* But it does not adjust timeout for the "connect" (for historical reasons
		).
		*
		* @param tv the timeout, or NULL
		*
		* For more precise control:
		* @see evhttp_connection_set_connect_timeout_tv()
		* @see evhttp_connection_set_read_timeout_tv()
		* @see evhttp_connection_set_write_timeout_tv()
		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_timeout_tv(struct evhttp_connection *evcon,		void evhttp_connection_set_timeout_tv(struct evhttp_connection *evcon,
const struct timeval *tv);		const struct timeval *tv);

/** Sets the delay before retrying requests on this connection. This is onl		/**
y		* Sets the connect timeout for this connection
* used if evhttp_connection_set_retries is used to make the number of retr		*
ies		* @param tv the timeout, or NULL
* at least one. Each retry after the first is twice as long as the one bef		*/
ore		EVENT2_EXPORT_SYMBOL
* it. */		void evhttp_connection_set_connect_timeout_tv(struct evhttp_connection *evc
		on,
		const struct timeval *tv);

		/**
		* Sets the read timeout for this connection
		*
		* @param tv the timeout, or NULL
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_connection_set_read_timeout_tv(struct evhttp_connection *evcon,
		const struct timeval *tv);

		/**
		* Sets the write timeout for this connection
		*
		* @param tv the timeout, or NULL
		*/
		EVENT2_EXPORT_SYMBOL
		void evhttp_connection_set_write_timeout_tv(struct evhttp_connection *evcon
		,
		const struct timeval *tv);

		/**
		* Sets the delay before retrying requests on this connection.
		*
		* This is only used if evhttp_connection_set_retries is used to make the
		* number of retries at least one. Each retry after the first is twice as l
		ong
		* as the one before it.
		*
		* Default delay is HTTP_INITIAL_RETRY_TIMEOUT, which is 2 seconds.
		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_initial_retry_tv(struct evhttp_connection *evcon ,		void evhttp_connection_set_initial_retry_tv(struct evhttp_connection *evcon ,
const struct timeval *tv);		const struct timeval *tv);

/** Sets the retry limit for this connection - -1 repeats indefinitely */		/** Sets the retry limit for this connection - -1 repeats indefinitely */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_retries(struct evhttp_connection *evcon,		void evhttp_connection_set_retries(struct evhttp_connection *evcon,
int retry_max);		int retry_max);

/** Set a callback for connection close. */		/** Set a callback for connection close. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_set_closecb(struct evhttp_connection *evcon,		void evhttp_connection_set_closecb(struct evhttp_connection *evcon,
void ()(struct evhttp_connection , void ), void );		void ()(struct evhttp_connection , void ), void );

/** Get the remote address and port associated with this connection. */		/** Get the remote address and port associated with this connection. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evhttp_connection_get_peer(struct evhttp_connection *evcon,		void evhttp_connection_get_peer(struct evhttp_connection *evcon,
char *address, ev_uint16_t port);		const char *address, ev_uint16_t port);

/** Get the remote address associated with this connection.		/** Get the remote address associated with this connection.
* extracted from getpeername() OR from nameserver.		* extracted from getpeername() OR from nameserver.
*		*
* @return NULL if getpeername() return non success,		* @return NULL if getpeername() return non success,
* or connection is not connected,		* or connection is not connected,
* otherwise it return pointer to struct sockaddr_storage */		* otherwise it return pointer to struct sockaddr_storage */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
const struct sockaddr*		const struct sockaddr*
evhttp_connection_get_addr(struct evhttp_connection *evcon);		evhttp_connection_get_addr(struct evhttp_connection *evcon);

skipping to change at line 988 ¶		skipping to change at line 1187 ¶
@deprecated This function is deprecated as of Libevent 2.0.9. Use		@deprecated This function is deprecated as of Libevent 2.0.9. Use
evhttp_uri_parse and evhttp_parse_query_str instead.		evhttp_uri_parse and evhttp_parse_query_str instead.

@param uri the request URI		@param uri the request URI
@param headers the head of the evkeyval queue		@param headers the head of the evkeyval queue
@return 0 on success, -1 on failure		@return 0 on success, -1 on failure
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evhttp_parse_query(const char uri, struct evkeyvalq headers);		int evhttp_parse_query(const char uri, struct evkeyvalq headers);

		/** @see evhttp_parse_query_str_flags() */
		EVENT2_EXPORT_SYMBOL
		int evhttp_parse_query_str(const char uri, struct evkeyvalq headers);

		/** Tolerate queries that are not standard conformant.
		*
		* Here are some examples:
		*
		* - test=123&test2
		* with with this flag test2 will be present in the output headers
		*
		* - test=123&&test2=1
		* will parse the query with this flag
		*
		* - test=123&=456&test2=1
		* will parse the queyr with this flag, however there won't be empty key
		* present
		*/
		#define EVHTTP_URI_QUERY_NONCONFORMANT 0x01
		/** Prefer last value over the first from query args
		*
		* Example: test=123&test=456
		* Without: test=123
		* With : test=456
		*/
		#define EVHTTP_URI_QUERY_LAST_VAL 0x02

/**		/**
Helper function to parse out arguments from the query portion of an		Helper function to parse out arguments from the query portion of an
HTTP URI.		HTTP URI.

Parsing a query string like		Parsing a query string like

q=test&s=some+thing		q=test&s=some+thing

will result in two entries in the key value queue.		will result in two entries in the key value queue.

The first entry is: key="q", value="test"		The first entry is: key="q", value="test"
The second entry is: key="s", value="some thing"		The second entry is: key="s", value="some thing"

@param query_parse the query portion of the URI		@param uri the query portion of the URI
@param headers the head of the evkeyval queue		@param headers the head of the evkeyval queue
		@param flags one or more of EVHTTP_URI_QUERY_*
@return 0 on success, -1 on failure		@return 0 on success, -1 on failure
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evhttp_parse_query_str(const char uri, struct evkeyvalq headers);		int evhttp_parse_query_str_flags(const char uri, struct evkeyvalq headers , unsigned flags);

/**		/**
* Escape HTML character entities in a string.		* Escape HTML character entities in a string.
*		*
* Replaces <, >, ", ' and & with <, >, ",		* Replaces <, >, ", ' and & with <, >, ",
* ' and & correspondingly.		* ' and & correspondingly.
*		*
* The returned string needs to be freed by the caller.		* The returned string needs to be freed by the caller.
*		*
* @param html an unescaped HTML string		* @param html an unescaped HTML string

skipping to change at line 1156 ¶		skipping to change at line 1383 ¶
* are not conformant URIs. If you need to support these URIs, you can		* are not conformant URIs. If you need to support these URIs, you can
* do so by passing this flag to evhttp_uri_parse_with_flags.		* do so by passing this flag to evhttp_uri_parse_with_flags.
*		*
* Currently, these changes are:		* Currently, these changes are:
* <ul>		* <ul>
* <li> Nonconformant URIs are allowed to contain otherwise unreasonable		* <li> Nonconformant URIs are allowed to contain otherwise unreasonable
* characters in their path, query, and fragment components.		* characters in their path, query, and fragment components.
* </ul>		* </ul>
*/		*/
#define EVHTTP_URI_NONCONFORMANT 0x01		#define EVHTTP_URI_NONCONFORMANT 0x01
		/**
		* Strip brackets from the IPv6 address and only for evhttp_uri_get_host(),
		* evhttp_uri_join() returns the host with brackets.
		*
		* Thus you can use host part of the evhttp_uri for getaddrinfo().
		*
		* @see also _EVHTTP_URI_HOST_HAS_BRACKETS
		*/
		#define EVHTTP_URI_HOST_STRIP_BRACKETS 0x04

/** Alias for evhttp_uri_parse_with_flags(source_uri, 0) */		/** Alias for evhttp_uri_parse_with_flags(source_uri, 0) */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evhttp_uri evhttp_uri_parse(const char source_uri);		struct evhttp_uri evhttp_uri_parse(const char source_uri);

/**		/**
* Free all memory allocated for a parsed uri. Only use this for URIs		* Free all memory allocated for a parsed uri. Only use this for URIs
* generated by evhttp_uri_parse.		* generated by evhttp_uri_parse.
*		*
* @param uri container with parsed data		* @param uri container with parsed data

End of changes. 28 change blocks.
24 lines changed or deleted		271 lines changed or added

listener.h (2.1.12)		listener.h (current)

skipping to change at line 41 ¶		skipping to change at line 41 ¶

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

#include <event2/event.h>		#include <event2/event.h>

struct sockaddr;		struct sockaddr;
struct evconnlistener;		struct evconnlistener;

/**		/**@file event2/listener.h
A callback that we invoke when a listener has a new connection.
		@brief A callback that we invoke when a listener has a new connection.

@param listener The evconnlistener		@param listener The evconnlistener
@param fd The new file descriptor		@param fd The new file descriptor
@param addr The source address of the connection		@param addr The source address of the connection
@param socklen The length of addr		@param socklen The length of addr
@param user_arg the pointer passed to evconnlistener_new()		@param user_arg the pointer passed to evconnlistener_new()
*/		*/
typedef void (evconnlistener_cb)(struct evconnlistener , evutil_socket_t, struct sockaddr , int socklen, void );		typedef void (evconnlistener_cb)(struct evconnlistener , evutil_socket_t, struct sockaddr , int socklen, void );

/**		/**

skipping to change at line 146 ¶		skipping to change at line 147 ¶
on a given address.		on a given address.

@param base The event base to associate the listener with.		@param base The event base to associate the listener with.
@param cb A callback to be invoked when a new connection arrives. If the		@param cb A callback to be invoked when a new connection arrives. If the
callback is NULL, the listener will be treated as disabled until the		callback is NULL, the listener will be treated as disabled until the
callback is set.		callback is set.
@param ptr A user-supplied pointer to give to the callback.		@param ptr A user-supplied pointer to give to the callback.
@param flags Any number of LEV_OPT_* flags		@param flags Any number of LEV_OPT_* flags
@param backlog Passed to the listen() call to determine the length of th e		@param backlog Passed to the listen() call to determine the length of th e
acceptable connection backlog. Set to -1 for a reasonable default.		acceptable connection backlog. Set to -1 for a reasonable default.
@param addr The address to listen for connections on.		@param sa The address to listen for connections on.
@param socklen The length of the address.		@param socklen The length of the address.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
struct evconnlistener evconnlistener_new_bind(struct event_base base,		struct evconnlistener evconnlistener_new_bind(struct event_base base,
evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,		evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
const struct sockaddr *sa, int socklen);		const struct sockaddr *sa, int socklen);
/**		/**
Disable and deallocate an evconnlistener.		Disable and deallocate an evconnlistener.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL

End of changes. 2 change blocks.
3 lines changed or deleted		4 lines changed or added

rpc_compat.h (2.1.12)		rpc_compat.h (current)

skipping to change at line 32 ¶		skipping to change at line 32 ¶
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/		*/
#ifndef EVENT2_RPC_COMPAT_H_INCLUDED_		#ifndef EVENT2_RPC_COMPAT_H_INCLUDED_
#define EVENT2_RPC_COMPAT_H_INCLUDED_		#define EVENT2_RPC_COMPAT_H_INCLUDED_

/** @file event2/rpc_compat.h		/** @file event2/rpc_compat.h

Deprecated versions of the functions in rpc.h: provided only for		@brief Deprecated versions of the functions in rpc.h: provided only for
backwards compatibility.		backwards compatibility.

*/		*/

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

/** backwards compatible accessors that work only with gcc */		/** backwards compatible accessors that work only with gcc */
#if defined(__GNUC__) && !defined(__STRICT_ANSI__)		#if defined(__GNUC__) && !defined(__STRICT_ANSI__)

End of changes. 1 change blocks.
1 lines changed or deleted		1 lines changed or added

tag.h (2.1.12)		tag.h (current)

skipping to change at line 32 ¶		skipping to change at line 32 ¶
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/		*/
#ifndef EVENT2_TAG_H_INCLUDED_		#ifndef EVENT2_TAG_H_INCLUDED_
#define EVENT2_TAG_H_INCLUDED_		#define EVENT2_TAG_H_INCLUDED_

/** @file event2/tag.h		/** @file event2/tag.h

Helper functions for reading and writing tagged data onto buffers.		@brief Helper functions for reading and writing tagged data onto buffers.

*/		*/

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

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

#include <event2/event-config.h>		#include <event2/event-config.h>

End of changes. 1 change blocks.
1 lines changed or deleted		1 lines changed or added

thread.h (2.1.12)		thread.h (current)

skipping to change at line 31 ¶		skipping to change at line 31 ¶
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/		*/
#ifndef EVENT2_THREAD_H_INCLUDED_		#ifndef EVENT2_THREAD_H_INCLUDED_
#define EVENT2_THREAD_H_INCLUDED_		#define EVENT2_THREAD_H_INCLUDED_

/** @file event2/thread.h		/** @file event2/thread.h

Functions for multi-threaded applications using Libevent.		@brief Functions for multi-threaded applications using Libevent.

When using a multi-threaded application in which multiple threads		When using a multi-threaded application in which multiple threads
add and delete events from a single event base, Libevent needs to		add and delete events from a single event base, Libevent needs to
lock its data structures.		lock its data structures.

Like the memory-management function hooks, all of the threading functions		Like the memory-management function hooks, all of the threading functions
_must_ be set up before an event_base is created if you want the base to		_must_ be set up before an event_base is created if you want the base to
use them.		use them.

Most programs will either be using Windows threads or Posix threads. You		Most programs will either be using Windows threads or Posix threads. You
can configure Libevent to use one of these event_use_windows_threads() or		can configure Libevent to use one of these evthread_use_windows_threads()
event_use_pthreads() respectively. If you're using another threading		or
		evthread_use_pthreads() respectively. If you're using another threading
library, you'll need to configure threading functions manually using		library, you'll need to configure threading functions manually using
evthread_set_lock_callbacks() and evthread_set_condition_callbacks().		evthread_set_lock_callbacks() and evthread_set_condition_callbacks().

*/		*/

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

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

skipping to change at line 187 ¶		skipping to change at line 187 ¶
* probably shouldn't call this function; instead, use		* probably shouldn't call this function; instead, use
* evthread_use_windows_threads() or evthread_use_pthreads() if you can.		* evthread_use_windows_threads() or evthread_use_pthreads() if you can.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evthread_set_condition_callbacks(		int evthread_set_condition_callbacks(
const struct evthread_condition_callbacks *);		const struct evthread_condition_callbacks *);

/**		/**
Sets the function for determining the thread id.		Sets the function for determining the thread id.

@param base the event base for which to set the id function
@param id_fn the identify function Libevent should invoke to		@param id_fn the identify function Libevent should invoke to
determine the identity of a thread.		determine the identity of a thread.
*/		*/
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
void evthread_set_id_callback(		void evthread_set_id_callback(
unsigned long (*id_fn)(void));		unsigned long (*id_fn)(void));

#if (defined(_WIN32) && !defined(EVENT__DISABLE_THREAD_SUPPORT)) \|\| defined (EVENT_IN_DOXYGEN_)		#if (defined(_WIN32) && !defined(EVENT__DISABLE_THREAD_SUPPORT)) \|\| defined (EVENT_IN_DOXYGEN_)
/** Sets up Libevent for use with Windows builtin locking and thread ID		/** Sets up Libevent for use with Windows builtin locking and thread ID
functions. Unavailable if Libevent is not built for Windows.		functions. Unavailable if Libevent is not built for Windows.

skipping to change at line 216 ¶		skipping to change at line 215 ¶
#endif		#endif

#if defined(EVENT__HAVE_PTHREADS) \|\| defined(EVENT_IN_DOXYGEN_)		#if defined(EVENT__HAVE_PTHREADS) \|\| defined(EVENT_IN_DOXYGEN_)
/** Sets up Libevent for use with Pthreads locking and thread ID functions.		/** Sets up Libevent for use with Pthreads locking and thread ID functions.
Unavailable if Libevent is not build for use with pthreads. Requires		Unavailable if Libevent is not build for use with pthreads. Requires
libraries to link against Libevent_pthreads as well as Libevent.		libraries to link against Libevent_pthreads as well as Libevent.

@return 0 on success, -1 on failure. */		@return 0 on success, -1 on failure. */
EVENT2_EXPORT_SYMBOL		EVENT2_EXPORT_SYMBOL
int evthread_use_pthreads(void);		int evthread_use_pthreads(void);

		/* Enables posix mutex priority inheritance
		* (if pthread_mutexattr_setprotocol() is supported). */
		#define EVTHREAD_PTHREAD_PRIO_INHERIT 0x01

		/**
		* Sets up Libevent for use with Pthreads locking and thread ID functions.
		* Use evthread_use_pthreads_with_flags() to use Pthreads locking, taking t
		he
		* specified flags under consideration.
		*
		* @param flags the flags to apply when setting up Pthreads locking. @see E
		VTHREAD_PTHREAD_*
		* @return 0 on success, -1 on failure.
		**/
		EVENT2_EXPORT_SYMBOL
		int evthread_use_pthreads_with_flags(int flags);

/** Defined if Libevent was built with support for evthread_use_pthreads() */		/** Defined if Libevent was built with support for evthread_use_pthreads() */
#define EVTHREAD_USE_PTHREADS_IMPLEMENTED 1		#define EVTHREAD_USE_PTHREADS_IMPLEMENTED 1

#endif		#endif

/** Enable debugging wrappers around the current lock callbacks. If Libeve nt		/** Enable debugging wrappers around the current lock callbacks. If Libeve nt
* makes one of several common locking errors, exit with an assertion failu re.		* makes one of several common locking errors, exit with an assertion failu re.
*		*
* If you're going to call this function, you must do so before any locks a re		* If you're going to call this function, you must do so before any locks a re
* allocated.		* allocated.

End of changes. 4 change blocks.
4 lines changed or deleted		22 lines changed or added

This html diff was produced by rfcdiff 1.41.The latest version is available from http://tools.ietf.org/tools/rfcdiff/

ABITracker

(Libevent)

Headers diff: 2.1.12 vs current

ABI
Tracker