Adding upstream version 3.8.1.upstream/3.8.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 493 insertions, 0 deletions

diff --git a/contrib/librdns/rdns.h b/contrib/librdns/rdns.h
new file mode 100644
index 0000000..c0da5ed
--- /dev/null
+++ b/contrib/librdns/rdns.h
@@ -0,0 +1,493 @@
+/*
+ * Copyright (c) 2013-2014, Vsevolod Stakhov
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *	 * Redistributions of source code must retain the above copyright
+ *	   notice, this list of conditions and the following disclaimer.
+ *	 * Redistributions in binary form must reproduce the above copyright
+ *	   notice, this list of conditions and the following disclaimer in the
+ *	   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef RDNS_H
+#define RDNS_H
+
+#include <sys/types.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct rdns_reply;
+struct rdns_request;
+struct rdns_io_channel;
+
+typedef void (*dns_callback_type) (struct rdns_reply *reply, void *arg);
+
+enum rdns_request_type {
+	RDNS_REQUEST_INVALID = -1,
+	RDNS_REQUEST_A = 1,
+	RDNS_REQUEST_NS = 2,
+	RDNS_REQUEST_CNAME = 5,
+	RDNS_REQUEST_SOA = 6,
+	RDNS_REQUEST_PTR = 12,
+	RDNS_REQUEST_MX = 15,
+	RDNS_REQUEST_TXT = 16,
+	RDNS_REQUEST_SRV = 33,
+	RDNS_REQUEST_SPF = 99,
+	RDNS_REQUEST_AAAA = 28,
+	RDNS_REQUEST_TLSA = 52,
+	RDNS_REQUEST_ANY = 255
+};
+
+union rdns_reply_element_un {
+	struct {
+		struct in_addr addr;
+	} a;
+	struct {
+		struct in6_addr addr;
+	} aaa;
+	struct {
+		char *name;
+	} ptr;
+	struct {
+		char *name;
+	} ns;
+	struct {
+		char *name;
+		uint16_t priority;
+	} mx;
+	struct {
+		char *data;
+	} txt;
+	struct {
+		uint16_t priority;
+		uint16_t weight;
+		uint16_t port;
+		char *target;
+	} srv;
+	struct {
+		char *mname;
+		char *admin;
+		uint32_t serial;
+		int32_t refresh;
+		int32_t retry;
+		int32_t expire;
+		uint32_t minimum;
+	} soa;
+	struct {
+		uint8_t usage;
+		uint8_t selector;
+		uint8_t match_type;
+		uint16_t datalen;
+		uint8_t *data;
+	} tlsa;
+	struct {
+		char *name;
+	} cname;
+};
+
+struct rdns_reply_entry {
+	union rdns_reply_element_un content;
+	enum rdns_request_type type;
+	int32_t ttl;
+	struct rdns_reply_entry *prev, *next;
+};
+
+
+enum dns_rcode {
+	RDNS_RC_INVALID = -1,
+	RDNS_RC_NOERROR	= 0,
+	RDNS_RC_FORMERR	= 1,
+	RDNS_RC_SERVFAIL	= 2,
+	RDNS_RC_NXDOMAIN	= 3,
+	RDNS_RC_NOTIMP	= 4,
+	RDNS_RC_REFUSED	= 5,
+	RDNS_RC_YXDOMAIN	= 6,
+	RDNS_RC_YXRRSET	= 7,
+	RDNS_RC_NXRRSET	= 8,
+	RDNS_RC_NOTAUTH	= 9,
+	RDNS_RC_NOTZONE	= 10,
+	RDNS_RC_TIMEOUT = 11,
+	RDNS_RC_NETERR = 12,
+	RDNS_RC_NOREC = 13
+};
+
+enum dns_reply_flags {
+	RDNS_AUTH = (1u << 0u),
+	RDNS_TRUNCATED = (1u << 1u)
+};
+
+struct rdns_reply {
+	struct rdns_request *request;
+	struct rdns_resolver *resolver;
+	struct rdns_reply_entry *entries;
+	const char *requested_name;
+	enum dns_rcode code;
+	uint8_t flags; /* see enum dns_reply_flags */
+};
+
+typedef void (*rdns_periodic_callback)(void *user_data);
+
+struct rdns_async_context {
+	void *data;
+	void* (*add_read)(void *priv_data, int fd, void *user_data);
+	void (*del_read)(void *priv_data, void *ev_data);
+	void* (*add_write)(void *priv_data, int fd, void *user_data);
+	void (*del_write)(void *priv_data, void *ev_data);
+	void* (*add_timer)(void *priv_data, double after, void *user_data);
+	void (*repeat_timer)(void *priv_data, void *ev_data);
+	void (*del_timer)(void *priv_data, void *ev_data);
+	void* (*add_periodic)(void *priv_data, double after,
+		rdns_periodic_callback cb, void *user_data);
+	void (*del_periodic)(void *priv_data, void *ev_data);
+	void (*cleanup)(void *priv_data);
+};
+
+struct rdns_upstream_elt {
+	void *server;
+	void *lib_data;
+};
+
+struct rdns_upstream_context {
+	void *data;
+	struct rdns_upstream_elt* (*select)(const char *name,
+			size_t len, void *ups_data);
+	struct rdns_upstream_elt* (*select_retransmit)(const char *name, size_t len,
+												   struct rdns_upstream_elt* prev_elt,
+												   void *ups_data);
+	unsigned int (*count)(void *ups_data);
+	void (*ok)(struct rdns_upstream_elt *elt, void *ups_data);
+	void (*fail)(struct rdns_upstream_elt *elt, void *ups_data, const char *reason);
+};
+
+/**
+ * Type of rdns plugin
+ */
+enum rdns_plugin_type {
+	RDNS_PLUGIN_CURVE = 0
+};
+
+typedef ssize_t (*rdns_network_send_callback) (struct rdns_request *req, void *plugin_data,
+											   struct sockaddr *saddr, socklen_t slen);
+typedef ssize_t (*rdns_network_recv_callback) (struct rdns_io_channel *ioc, void *buf,
+											   size_t len, void *plugin_data,
+											   struct rdns_request **req_out,
+											   struct sockaddr *saddr, socklen_t slen);
+typedef void (*rdns_network_finish_callback) (struct rdns_request *req, void *plugin_data);
+typedef void (*rdns_plugin_dtor_callback) (struct rdns_resolver *resolver, void *plugin_data);
+
+struct rdns_plugin {
+	enum rdns_plugin_type type;
+	union {
+		struct {
+			rdns_network_send_callback send_cb;
+			rdns_network_recv_callback recv_cb;
+			rdns_network_finish_callback finish_cb;
+		} curve_plugin;
+	} cb;
+	rdns_plugin_dtor_callback dtor;
+	void *data;
+};
+
+/*
+ * RDNS logger types
+ */
+/*
+ * These types are somehow compatible with glib
+ */
+enum rdns_log_level {
+	  RDNS_LOG_ERROR = 1 << 3,
+	  RDNS_LOG_WARNING = 1 << 4,
+	  RDNS_LOG_INFO = 1 << 6,
+	  RDNS_LOG_DEBUG = 1 << 7
+};
+typedef void (*rdns_log_function) (
+									void *log_data, //!< opaque data pointer
+									enum rdns_log_level level, //!< level of message
+									const char *function, //!< calling function
+									const char *format, //!< format
+									va_list args //!< set of arguments
+									);
+
+struct rdns_request_name {
+	char *name;
+	enum rdns_request_type type;
+	unsigned int len;
+};
+
+#define MAX_FAKE_NAME 1000
+
+/*
+ * RDNS API
+ */
+
+enum rdns_resolver_flags {
+	RDNS_RESOLVER_DEFAULT,
+	RDNS_RESOLVER_NOIDN = (1u << 0u),
+};
+
+/**
+ * Create DNS resolver structure
+ */
+struct rdns_resolver *rdns_resolver_new (int flags);
+
+/**
+ * Bind resolver to specified async context
+ * @param ctx
+ */
+void rdns_resolver_async_bind (struct rdns_resolver *resolver,
+		struct rdns_async_context *ctx);
+
+/**
+ * Enable stub dnssec resolver
+ * @param resolver
+ */
+void rdns_resolver_set_dnssec (struct rdns_resolver *resolver, bool enabled);
+
+/**
+ * Add new DNS server definition to the resolver
+ * @param resolver resolver object
+ * @param name name of DNS server (should be ipv4 or ipv6 address)
+ * @param priority priority (can be 0 for fair round-robin)
+ * @param io_cnt a number of sockets that are simultaneously opened to this server
+ * @return opaque pointer that could be used to select upstream
+ */
+void* rdns_resolver_add_server (struct rdns_resolver *resolver,
+		const char *name, unsigned int port,
+		int priority, unsigned int io_cnt);
+
+
+/**
+ * Load nameservers definition from resolv.conf file
+ * @param resolver resolver object
+ * @param path path to resolv.conf file (/etc/resolv.conf typically)
+ * @return true if resolv.conf has been parsed
+ */
+bool rdns_resolver_parse_resolv_conf (struct rdns_resolver *resolver,
+		const char *path);
+
+typedef bool (*rdns_resolv_conf_cb) (struct rdns_resolver *resolver,
+		const char *name, unsigned int port,
+		int priority, unsigned int io_cnt, void *ud);
+/**
+ * Parse nameservers calling the specified callback for each nameserver
+ * @param resolve resolver object
+ * @param path path to resolv.conf file (/etc/resolv.conf typically)
+ * @param cb callback to call
+ * @param ud userdata for callback
+ * @return true if resolv.conf has been parsed
+ */
+bool rdns_resolver_parse_resolv_conf_cb (struct rdns_resolver *resolver,
+		const char *path, rdns_resolv_conf_cb cb, void *ud);
+
+/**
+ * Set an external logger function to log messages from the resolver
+ * @param resolver resolver object
+ * @param logger logger callback
+ * @param log_data opaque data
+ */
+void rdns_resolver_set_logger (struct rdns_resolver *resolver,
+		rdns_log_function logger, void *log_data);
+
+/**
+ * Set log level for an internal logger (stderr one)
+ * @param resolver resolver object
+ * @param level desired log level
+ */
+void rdns_resolver_set_log_level (struct rdns_resolver *resolver,
+		enum rdns_log_level level);
+
+/**
+ * Set upstream library for selecting DNS upstreams
+ * @param resolver resolver object
+ * @param ups_ctx upstream functions
+ * @param ups_data opaque data
+ */
+void rdns_resolver_set_upstream_lib (struct rdns_resolver *resolver,
+		struct rdns_upstream_context *ups_ctx,
+		void *ups_data);
+
+/**
+ * Set maximum number of dns requests to be sent to a socket to be refreshed
+ * @param resolver resolver object
+ * @param max_ioc_uses unsigned count of socket usage limit
+ * @param check_time specifies how often to check for sockets and refresh them
+ */
+void rdns_resolver_set_max_io_uses (struct rdns_resolver *resolver,
+		uint64_t max_ioc_uses, double check_time);
+
+/**
+ * Register new plugin for rdns resolver
+ * @param resolver
+ * @param plugin
+ */
+void rdns_resolver_register_plugin (struct rdns_resolver *resolver,
+		struct rdns_plugin *plugin);
+
+/**
+ * Add a fake reply for a specified name
+ * @param resolver
+ * @param type
+ * @param name (must not be larger than MAX_FAKE_NAME)
+ * @param reply
+ */
+void rdns_resolver_set_fake_reply (struct rdns_resolver *resolver,
+								   const char *name,
+								   enum rdns_request_type type,
+								   enum dns_rcode rcode,
+								   struct rdns_reply_entry *reply);
+
+/**
+ * Init DNS resolver
+ * @param resolver
+ * @return
+ */
+bool rdns_resolver_init (struct rdns_resolver *resolver);
+
+/**
+ * Decrease refcount for a resolver and free it if refcount is 0
+ * @param resolver
+ */
+void rdns_resolver_release (struct rdns_resolver *resolver);
+
+/**
+ * Make a DNS request
+ * @param resolver resolver object
+ * @param cb callback to call on resolve completing
+ * @param ud user data for callback
+ * @param timeout timeout in seconds
+ * @param repeats how much time to retransmit query
+ * @param queries how much RR queries to send
+ * @param ... -> queries in format: <query_type>[,type_argument[,type_argument...]]
+ * @return opaque request object or NULL
+ */
+struct rdns_request* rdns_make_request_full (
+		struct rdns_resolver *resolver,
+		dns_callback_type cb,
+		void *cbdata,
+		double timeout,
+		unsigned int repeats,
+		unsigned int queries,
+		...
+		);
+
+/**
+ * Get textual presentation of DNS error code
+ */
+const char *rdns_strerror (enum dns_rcode rcode);
+
+/**
+ * Get textual presentation of DNS request type
+ */
+const char *rdns_strtype (enum rdns_request_type type);
+
+/**
+ * Parse string and return request type
+ * @param str
+ * @return
+ */
+enum rdns_request_type rdns_type_fromstr (const char *str);
+
+/**
+ * Returns string representing request type
+ * @param rcode
+ * @return
+ */
+const char *
+rdns_str_from_type (enum rdns_request_type rcode);
+
+/**
+ * Parse string and return error code
+ * @param str
+ * @return
+ */
+enum dns_rcode rdns_rcode_fromstr (const char *str);
+
+/**
+ * Increase refcount for a request
+ * @param req
+ * @return
+ */
+struct rdns_request* rdns_request_retain (struct rdns_request *req);
+
+/**
+ * Decrease refcount for a request and free it if refcount is 0
+ * @param req
+ */
+void rdns_request_release (struct rdns_request *req);
+
+/**
+ * Check whether a request contains `type` request
+ * @param req request object
+ * @param type check for a specified type
+ * @return true if `type` has been requested
+ */
+bool rdns_request_has_type (struct rdns_request *req, enum rdns_request_type type);
+
+/**
+ * Return requested name for a request
+ * @param req request object
+ * @return requested name as it was passed to `rdns_make_request`
+ */
+const struct rdns_request_name* rdns_request_get_name (struct rdns_request *req,
+		unsigned int *count);
+
+/**
+ * Return a DNS server name associated with the request
+ * @param req request object
+ * @return name of a DNS server
+ */
+const char* rdns_request_get_server (struct rdns_request *req);
+
+
+/**
+ * Return PTR string for a request (ipv4 or ipv6) addresses
+ * @param str string representation of IP address
+ * @return name to resolve or NULL if `str` is not an IP address; caller must free result when it is unused
+ */
+char * rdns_generate_ptr_from_str (const char *str);
+
+/**
+ * Format DNS name of the packet punycoding if needed
+ * @param req request
+ * @param name name string
+ * @param namelen length of name
+ */
+bool rdns_format_dns_name (struct rdns_resolver *resolver,
+		const char *name, size_t namelen,
+		char **out, size_t *outlen);
+
+/*
+ * Private functions used by async libraries as callbacks
+ */
+
+void rdns_process_read (int fd, void *arg);
+void rdns_process_timer (void *arg);
+void rdns_process_write (int fd, void *arg);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif