/**
 *
 * \file general.c
 * @brief getdns_general and related support functions
 *
 * The getdns_general function is called by most of the other public entry
 * points to the library.  Private support functions are also included in this
 * file where they are directly logically related to the getdns_general implementation.
 */

/*
 * Copyright (c) 2013, NLnet Labs, Verisign, Inc.
 * 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.
 * * Neither the names of the copyright holders nor the
 *   names of its contributors may be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 Verisign, Inc. 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.
 */

#include <stdio.h>
#include <string.h>
#include "config.h"
#include "general.h"
#ifdef HAVE_LIBUNBOUND
#include <unbound.h>
#endif
#ifdef HAVE_UNBOUND_EVENT_API
#include "ub_loop.h"
#endif
#include "gldns/wire2str.h"
#include "context.h"
#include "types-internal.h"
#include "util-internal.h"
#include "dnssec.h"
#include "stub.h"
#include "dict.h"
#include "mdns.h"
#include "debug.h"
#include "anchor.h"

void _getdns_call_user_callback(getdns_dns_req *dnsreq, getdns_dict *response)
{
	_getdns_context_clear_outbound_request(dnsreq);

#if defined(REQ_DEBUG) && REQ_DEBUG
	debug_req(__FUNC__, *dnsreq->netreqs);
#endif
	if (dnsreq->user_callback) {
		dnsreq->context->processing = 1;
		dnsreq->user_callback(dnsreq->context,
		    ( ! response                ? GETDNS_CALLBACK_ERROR
		    : dnsreq->request_timed_out ? GETDNS_CALLBACK_TIMEOUT
		                                : GETDNS_CALLBACK_COMPLETE ),
		    response, dnsreq->user_pointer, dnsreq->trans_id);
		dnsreq->context->processing = 0;
	}
	_getdns_dns_req_free(dnsreq);
}

static int
no_answer(getdns_dns_req *dns_req)
{
	getdns_network_req **netreq_p, *netreq;

	for (netreq_p = dns_req->netreqs; (netreq = *netreq_p); netreq_p++) {
		_getdns_rrset_spc answer;

		if (netreq->response_len > 0 &&
		    GLDNS_ANCOUNT(netreq->response) > 0 &&
		    _getdns_rrset_answer(&answer, netreq->response
		                                , netreq->response_len))
			return 0;
	}
	return 1;
}

void
_getdns_check_dns_req_complete(getdns_dns_req *dns_req)
{
	getdns_network_req **netreq_p, *netreq;
	int results_found = 0, timed_out = 1, r;
	uint64_t now_ms  = 0;
	
	for (netreq_p = dns_req->netreqs; (netreq = *netreq_p); netreq_p++)
		if (!_getdns_netreq_finished(netreq))
			return;
		else {
			if (netreq->state != NET_REQ_TIMED_OUT)
				timed_out = 0;
			if (netreq->response_len > 0)
				results_found = 1;
		}

	if (timed_out) {
		_getdns_context_request_timed_out(dns_req);
		return;
	}

	/* Do we have to check more suffixes on nxdomain/nodata?
	 */
	if (dns_req->is_dns_request == 1 &&
	    dns_req->suffix_appended && /* Something was appended */
	    dns_req->suffix_len > 1 &&  /* Next suffix available */
	    no_answer(dns_req)) {
		/* Remove suffix from name */
		dns_req->name_len -= dns_req->suffix_len - 1;
		dns_req->name[dns_req->name_len - 1] = 0;
		do {
			dns_req->suffix += dns_req->suffix_len;
			dns_req->suffix_len = *dns_req->suffix++;
			if (dns_req->suffix_len + dns_req->name_len - 1 < 
			    sizeof(dns_req->name)) {
				memcpy(dns_req->name + dns_req->name_len - 1,
				    dns_req->suffix, dns_req->suffix_len);
				dns_req->name_len += dns_req->suffix_len - 1;
				dns_req->suffix_appended = 1;
				break;
			}
		} while (dns_req->suffix_len > 1 && *dns_req->suffix);
		if (dns_req->append_name == GETDNS_APPEND_NAME_ALWAYS ||
		    dns_req->append_name ==
		    GETDNS_APPEND_NAME_TO_SINGLE_LABEL_FIRST ||
		    (dns_req->suffix_len > 1 && *dns_req->suffix)) {
			for ( netreq_p = dns_req->netreqs
			    ; (netreq = *netreq_p)
			    ; netreq_p++ ) {
				_getdns_netreq_reinit(netreq);
				if ((r = _getdns_submit_netreq(netreq, &now_ms))) {
					if (r == DNS_REQ_FINISHED)
						return;
					_getdns_netreq_change_state(netreq, NET_REQ_ERRORED);
				}
			}
			_getdns_check_dns_req_complete(dns_req);
			return;
		}
	} else if (
	    dns_req->is_dns_request == 1 &&
	    ( dns_req->append_name ==
	      GETDNS_APPEND_NAME_ONLY_TO_SINGLE_LABEL_AFTER_FAILURE ||
	      dns_req->append_name ==
	      GETDNS_APPEND_NAME_ONLY_TO_MULTIPLE_LABEL_NAME_AFTER_FAILURE
	    ) &&
	    !dns_req->suffix_appended &&
	    dns_req->suffix_len > 1 &&
	    no_answer(dns_req)) {
		/* Initial suffix append */
		for (
		    ; dns_req->suffix_len > 1 && *dns_req->suffix
		    ; dns_req->suffix += dns_req->suffix_len
		    , dns_req->suffix_len = *dns_req->suffix++) {

			if (dns_req->suffix_len + dns_req->name_len - 1 < 
			    sizeof(dns_req->name)) {
				memcpy(dns_req->name + dns_req->name_len - 1,
				    dns_req->suffix, dns_req->suffix_len);
				dns_req->name_len += dns_req->suffix_len - 1;
				dns_req->suffix_appended = 1;
				break;
			}
		}
		if (dns_req->suffix_appended) {
			for ( netreq_p = dns_req->netreqs
			    ; (netreq = *netreq_p)
			    ; netreq_p++ ) {
				_getdns_netreq_reinit(netreq);
				if ((r = _getdns_submit_netreq(netreq, &now_ms))) {
					if (r == DNS_REQ_FINISHED)
						return;
					_getdns_netreq_change_state(netreq, NET_REQ_ERRORED);
				}
			}
			_getdns_check_dns_req_complete(dns_req);
			return;
		}
	}
#if defined(REQ_DEBUG) && REQ_DEBUG
	if (dns_req->internal_cb)
		debug_req("CB Internal", *dns_req->netreqs);
	else if (results_found)
		debug_req("CB Complete", *dns_req->netreqs);
	else
		debug_req("CB Error   ", *dns_req->netreqs);
#endif
	if (dns_req->internal_cb) {
		_getdns_context_clear_outbound_request(dns_req);
		dns_req->internal_cb(dns_req);
	} else if (! results_found)
		_getdns_call_user_callback(dns_req, NULL);
	else if (
	    dns_req->is_dns_request == 1 &&
	    (dns_req->dnssec_return_validation_chain
#ifdef DNSSEC_ROADBLOCK_AVOIDANCE
	    || (   dns_req->dnssec_roadblock_avoidance 
	       && !dns_req->avoid_dnssec_roadblocks)
#endif

#ifdef STUB_NATIVE_DNSSEC
	    || (    dns_req->context->resolution_type == GETDNS_RESOLUTION_STUB
	        && !dns_req->avoid_dnssec_roadblocks
	        && (dns_req->dnssec_return_status ||
	            dns_req->dnssec_return_only_secure ||
	            dns_req->dnssec ||
	            dns_req->dnssec_return_all_statuses
	           ))
#endif
	    || (   dns_req->context->resolution_type == GETDNS_RESOLUTION_RECURSING
	       && (dns_req->dnssec_return_status ||
	           dns_req->dnssec_return_only_secure ||
	           dns_req->dnssec ||
	           dns_req->dnssec_return_all_statuses)
	       && _getdns_bogus(dns_req))
	    )) {
		/* Reschedule timeout for this DNS request
		 */
		if (dns_req->timeout.timeout_cb && dns_req->timeout.ev)
			GETDNS_CLEAR_EVENT(dns_req->loop, &dns_req->timeout);

		GETDNS_SCHEDULE_EVENT(dns_req->loop, -1,
		    _getdns_ms_until_expiry2(dns_req->expires, &now_ms),
		    getdns_eventloop_event_init(&dns_req->timeout, dns_req,
		    NULL, NULL, (getdns_eventloop_callback)
		    _getdns_validation_chain_timeout));

#if defined(REQ_DEBUG) && REQ_DEBUG
		debug_req("getting validation chain for ", *dns_req->netreqs);
#endif
		_getdns_get_validation_chain(dns_req);
	} else
		_getdns_call_user_callback(
		    dns_req, _getdns_create_getdns_response(dns_req));
}

#ifdef HAVE_LIBUNBOUND
#ifdef HAVE_UNBOUND_EVENT_API
#if UNBOUND_VERSION_MAJOR > 1 || (UNBOUND_VERSION_MAJOR == 1 && UNBOUND_VERSION_MINOR >= 8)
static void
ub_resolve_event_callback(void* arg, int rcode, void *pkt, int pkt_len,
    int sec, char* why_bogus, int was_ratelimited)
{
	(void) was_ratelimited; /* unused parameter */
#else
static void
ub_resolve_event_callback(void* arg, int rcode, void *pkt, int pkt_len,
    int sec, char* why_bogus)
{
#endif
	getdns_network_req *netreq = (getdns_network_req *) arg;
	getdns_dns_req *dns_req = netreq->owner;

	_getdns_netreq_change_state(netreq, NET_REQ_FINISHED);
	/* parse */
	if (getdns_apply_network_result(
	    netreq, rcode, pkt, pkt_len, sec, why_bogus)) {
		_getdns_call_user_callback(dns_req, NULL);
		return;
	}
	_getdns_check_dns_req_complete(dns_req);

} /* ub_resolve_event_callback */
#endif

static void
ub_resolve_callback(void* arg, int err, struct ub_result* ub_res)
{
	getdns_network_req *netreq = (getdns_network_req *) arg;
	getdns_dns_req *dns_req = netreq->owner;

	_getdns_netreq_change_state(netreq, NET_REQ_FINISHED);
	if (err != 0) {
		_getdns_call_user_callback(dns_req, NULL);
		return;
	}
	/* parse */
	if (getdns_apply_network_result(netreq, ub_res->rcode,
	    ub_res->answer_packet, ub_res->answer_len,
	    (ub_res->secure ? 2 : ub_res->bogus ? 1 : 0), ub_res->why_bogus)) {
		ub_resolve_free(ub_res);
		_getdns_call_user_callback(dns_req, NULL);
		return;
	}
	ub_resolve_free(ub_res);

	_getdns_check_dns_req_complete(dns_req);

} /* ub_resolve_callback */
#endif


void _getdns_check_expired_pending_netreqs(
    getdns_context *context, uint64_t *now_ms)
{
	getdns_network_req *first;

	assert(context);

	while (context->pending_netreqs.count) {
		first = (getdns_network_req *)
		    _getdns_rbtree_first(&context->pending_netreqs);

		if (_getdns_ms_until_expiry2(first->owner->expires, now_ms) > 0)
			break;

		(void) _getdns_rbtree_delete(&context->pending_netreqs, first);
		_getdns_netreq_change_state(first, NET_REQ_TIMED_OUT);
		_getdns_check_dns_req_complete(first->owner);
	}
	first = context->pending_netreqs.count ? (getdns_network_req *)
	    _getdns_rbtree_first(&context->pending_netreqs) : NULL;

	if (first == context->first_pending_netreq ||
	    (first && context->first_pending_netreq &&
	     first->owner->expires == context->first_pending_netreq->owner->expires))
		return; /* Nothing changed */

	if (context->first_pending_netreq)
		GETDNS_CLEAR_EVENT(  context->extension
		                  , &context->pending_timeout_event);

	if ((context->first_pending_netreq = first))
		GETDNS_SCHEDULE_EVENT( context->extension, -1,
		    _getdns_ms_until_expiry2(first->owner->expires, now_ms),
		    &context->pending_timeout_event);
}

void
_getdns_netreq_change_state(
    getdns_network_req *netreq, network_req_state new_state)
{
	getdns_context *context;
	uint64_t now_ms;
	getdns_network_req *prev;

	if (!netreq)
		return;

	if (netreq->owner->is_dns_request == 0) {
		netreq->state = new_state;
		return;
	}

	context = netreq->owner->context;

	if (netreq->state != NET_REQ_IN_FLIGHT) {
		if (new_state == NET_REQ_IN_FLIGHT)
			context->netreqs_in_flight += 1;
		netreq->state = new_state;
		return;
	}
	if (new_state == NET_REQ_IN_FLIGHT) /* No change */
		return;
	netreq->state = new_state;
	context->netreqs_in_flight -= 1;

	now_ms = 0;
	prev = NULL;
	while (context->pending_netreqs.count > 0 &&
	    (  context->limit_outstanding_queries > context->netreqs_in_flight
	    || context->limit_outstanding_queries == 0 ))  {

		getdns_network_req *first = (getdns_network_req *)
		    _getdns_rbtree_first(&context->pending_netreqs);
		
		/* To prevent loops due to _getdns_submit_netreq re-inserting
		 * because of errno == EMFILE
		 */
		if (first == prev)
			break;
		else
			prev = first;

		(void) _getdns_rbtree_delete(&context->pending_netreqs, first);
		(void) _getdns_submit_netreq(first, &now_ms);
	}
}

int
_getdns_submit_netreq(getdns_network_req *netreq, uint64_t *now_ms)
{
	getdns_return_t r;
	getdns_dns_req *dns_req = netreq->owner;
	getdns_context *context = dns_req->context;
	char name[1024];
	int dnsreq_freed = 0;
#ifdef HAVE_LIBUNBOUND
	int ub_resolve_r;
#endif

	if (context->limit_outstanding_queries > 0 &&
	    context->netreqs_in_flight >= context->limit_outstanding_queries) {

		netreq->node.key = netreq;
		if (_getdns_rbtree_insert(
		    &context->pending_netreqs, &netreq->node)) {
			
			_getdns_check_expired_pending_netreqs(context, now_ms);
			return GETDNS_RETURN_GOOD;
		}
	}
	_getdns_netreq_change_state(netreq, NET_REQ_IN_FLIGHT);

	debug_req("Submitting ", netreq);

#ifdef STUB_NATIVE_DNSSEC
# ifdef DNSSEC_ROADBLOCK_AVOIDANCE

	if ((context->resolution_type == GETDNS_RESOLUTION_RECURSING
	    && !dns_req->dnssec_roadblock_avoidance)
	    ||  dns_req->avoid_dnssec_roadblocks) {
# else
	if ( context->resolution_type == GETDNS_RESOLUTION_RECURSING) {
# endif
#else
	if ( context->resolution_type == GETDNS_RESOLUTION_RECURSING
	    || dns_req->dnssec_return_status
	    || dns_req->dnssec_return_only_secure
	    || dns_req->dnssec
	    || dns_req->dnssec_return_all_statuses
	    || dns_req->dnssec_return_validation_chain) {
#endif
		/* schedule the timeout */
		if (! dns_req->timeout.timeout_cb) {
			dns_req->timeout.userarg    = dns_req;
			dns_req->timeout.read_cb    = NULL;
			dns_req->timeout.write_cb   = NULL;
			dns_req->timeout.timeout_cb =
			    (getdns_eventloop_callback)
			    _getdns_context_request_timed_out;
			dns_req->timeout.ev         = NULL;
			if ((r = dns_req->loop->vmt->schedule(dns_req->loop, -1,
			    _getdns_ms_until_expiry2(dns_req->expires, now_ms),
			    &dns_req->timeout)))
				return r;
		}
		(void) gldns_wire2str_dname_buf(dns_req->name,
		    dns_req->name_len, name, sizeof(name));

#ifdef HAVE_LIBUNBOUND
		dns_req->freed = &dnsreq_freed;
#ifdef HAVE_UNBOUND_EVENT_API
		if (_getdns_ub_loop_enabled(&context->ub_loop))
			ub_resolve_r = ub_resolve_event(context->unbound_ctx,
			    name, netreq->request_type, dns_req->request_class,
			    netreq, ub_resolve_event_callback, &(netreq->unbound_id));
		else
#endif
			ub_resolve_r = ub_resolve_async(context->unbound_ctx,
			    name, netreq->request_type, dns_req->request_class,
			    netreq, ub_resolve_callback, &(netreq->unbound_id));
		if (dnsreq_freed)
			return DNS_REQ_FINISHED;
		dns_req->freed = NULL;
		return ub_resolve_r ? GETDNS_RETURN_GENERIC_ERROR : GETDNS_RETURN_GOOD;
#else
		return GETDNS_RETURN_NOT_IMPLEMENTED;
#endif
	}
	/* Submit with stub resolver */
	dns_req->freed = &dnsreq_freed;
	r = _getdns_submit_stub_request(netreq, now_ms);
	if (dnsreq_freed)
		return DNS_REQ_FINISHED;
	dns_req->freed = NULL;
	return r;
}


/**
 * structure used by validate_extensions() to check extension formats
 */
typedef struct getdns_extension_format
{
	char *extstring;
	getdns_data_type exttype;
	int implemented;
} getdns_extension_format;

static int
extformatcmp(const void *a, const void *b)
{
	return strcmp(((getdns_extension_format *) a)->extstring,
	    ((getdns_extension_format *) b)->extstring);
}

/*---------------------------------------- validate_extensions */
static getdns_return_t
validate_extensions(const getdns_dict * extensions)
{
	/**
	  * this is a comprehensive list of extensions and their data types
	  * used by validate_extensions()
	  * The list has to be in sorted order for bsearch lookup in function
	  * validate_extensions.
	  */
	static getdns_extension_format extformats[] = {
		{"add_opt_parameters"            , t_dict, 1},
		{"add_warning_for_bad_dns"       , t_int , 1},
		{"dnssec"                        , t_int , 1},
		{"dnssec_return_all_statuses"    , t_int , 1},
		{"dnssec_return_full_validation_chain", t_int , 1},
		{"dnssec_return_only_secure"     , t_int , 1},
		{"dnssec_return_status"          , t_int , 1},
		{"dnssec_return_validation_chain", t_int , 1},
		{"dnssec_roadblock_avoidance"    , t_int ,
#if defined(DNSSEC_ROADBLOCK_AVOIDANCE) && defined(HAVE_LIBUNBOUND)
							   1},
#else
							   0},
#endif
		{"edns_cookies"                  , t_int ,
#ifdef EDNS_COOKIES
							   1},
#else
							   0},
#endif
		{"header"                        , t_dict, 1},
		{"return_api_information"        , t_int , 1},
		{"return_both_v4_and_v6"         , t_int , 1},
		{"return_call_reporting"         , t_int , 1},
		{"specify_class"                 , t_int , 1},
	};

	struct getdns_dict_item *item;
	getdns_extension_format *extformat;

	if (extensions)
		RBTREE_FOR(item, struct getdns_dict_item *,
		    &(extensions->root)) {

			getdns_extension_format key;
			key.extstring = (char *) item->node.key;
			extformat = bsearch(&key, extformats,
			    sizeof(extformats) /
			    sizeof(getdns_extension_format),
			    sizeof(getdns_extension_format), extformatcmp);
			if (!extformat)
				return GETDNS_RETURN_NO_SUCH_EXTENSION;

			if (!extformat->implemented)
				return GETDNS_RETURN_NOT_IMPLEMENTED;

			if (item->i.dtype != extformat->exttype)
				return GETDNS_RETURN_EXTENSION_MISFORMAT;
		}
	return GETDNS_RETURN_GOOD;
}				/* _getdns_validate_extensions */


static getdns_return_t
getdns_general_ns(getdns_context *context, getdns_eventloop *loop,
    const char *name, uint16_t request_type, const getdns_dict *extensions,
    void *userarg, getdns_network_req **return_netreq_p,
    getdns_callback_t callbackfn, internal_cb_t internal_cb, int usenamespaces)
{
	int r = GETDNS_RETURN_GOOD;
	getdns_network_req *netreq, **netreq_p;
	getdns_dns_req *req;
	getdns_dict *localnames_response;
	size_t i;
	uint64_t now_ms = 0;

	if (!context || !name || (!callbackfn && !internal_cb))
		return GETDNS_RETURN_INVALID_PARAMETER;
	
	if ((r = _getdns_validate_dname(name)))
		return r;

	if (extensions && (r = validate_extensions(extensions)))
		return r;

	/* create the request */
	if (!(req = _getdns_dns_req_new(
	    context, loop, name, request_type, extensions, &now_ms)))
		return GETDNS_RETURN_MEMORY_ERROR;

	req->user_pointer = userarg;
	req->user_callback = callbackfn;
	req->internal_cb = internal_cb;
	req->is_sync_request = loop == &context->sync_eventloop.loop;

	if (return_netreq_p)
		*return_netreq_p = req->netreqs[0];

	_getdns_context_track_outbound_request(req);

	if (req->dnssec_extension_set) {
		if (context->trust_anchors_source == GETDNS_TASRC_FAILED
		&&  _getdns_ms_until_expiry2(
		    context->trust_anchors_backoff_expiry, &now_ms) == 0) {
			context->trust_anchors_source = GETDNS_TASRC_NONE;
		}
		if (context->trust_anchors_source == GETDNS_TASRC_XML_UPDATE)
			_getdns_start_fetching_ta(context, loop, &now_ms);

		else if (context->trust_anchors_source == GETDNS_TASRC_NONE) {
			_getdns_context_equip_with_anchor(context, &now_ms);
			if (context->trust_anchors_source == GETDNS_TASRC_NONE) {
				_getdns_start_fetching_ta(context, loop, &now_ms);
			}
		}
	}
	if (!usenamespaces) {
		if (context->trust_anchors_source == GETDNS_TASRC_FETCHING
		    && context->resolution_type == GETDNS_RESOLUTION_RECURSING
		    && context->resolution_type != context->resolution_type_set) {
			req->waiting_for_ta = 1;
			req->ta_notify = context->ta_notify;
			context->ta_notify = req;
			return GETDNS_RETURN_GOOD;
		}
		if ((r = _getdns_context_prepare_for_resolution(context)))
			; /* pass */

		/* issue all network requests */
		else for ( netreq_p = req->netreqs
		    ; !r && (netreq = *netreq_p)
		    ; netreq_p++) {
			if ((r = _getdns_submit_netreq(netreq, &now_ms))) {
				if (r == DNS_REQ_FINISHED) {
					if (return_netreq_p)
						*return_netreq_p = NULL;
					return GETDNS_RETURN_GOOD;
				}
				_getdns_netreq_change_state(netreq, NET_REQ_ERRORED);
			}
		}

	} else for (i = 0; i < context->namespace_count; i++) {
		if (context->namespaces[i] == GETDNS_NAMESPACE_LOCALNAMES) {

			if (!(r = _getdns_context_local_namespace_resolve(
			    req, &localnames_response))) {
				req->is_dns_request = 0;
				_getdns_call_user_callback
				    ( req, localnames_response);
				if (return_netreq_p)
					*return_netreq_p = NULL;
				break;
			}
#ifdef HAVE_MDNS_SUPPORT
		} else if (context->namespaces[i] == GETDNS_NAMESPACE_MDNS) {
			/* Check whether the name belongs in the MDNS space */
			if (!(r = _getdns_mdns_namespace_check(req)))
			{
				req->is_dns_request = 0;
				// Submit the query to the MDNS transport.
				for (netreq_p = req->netreqs
					; !r && (netreq = *netreq_p)
					; netreq_p++) {
					if ((r = _getdns_submit_mdns_request(netreq))) {
						if (r == DNS_REQ_FINISHED) {
							if (return_netreq_p)
								*return_netreq_p = NULL;
							return GETDNS_RETURN_GOOD;
						}
						_getdns_netreq_change_state(netreq, NET_REQ_ERRORED);
					}
				}
				/* Stop processing more namespaces, since there was a match */
				break;
			}
#endif /* HAVE_MDNS_SUPPORT */
		} else if (context->namespaces[i] == GETDNS_NAMESPACE_DNS) {
			if (context->trust_anchors_source == GETDNS_TASRC_FETCHING
			    && context->resolution_type == GETDNS_RESOLUTION_RECURSING
			    && context->resolution_type != context->resolution_type_set) {
				req->waiting_for_ta = 1;
				req->ta_notify = context->ta_notify;
				context->ta_notify = req;
				return GETDNS_RETURN_GOOD;
			}
			if ((r =  _getdns_context_prepare_for_resolution(context)))
				break;

			/* TODO: We will get a good return code here even if
			   the name is not found (NXDOMAIN). We should consider
			   if this means we go onto the next namespace instead
			   of returning */
			r = GETDNS_RETURN_GOOD;
			for ( netreq_p = req->netreqs
			    ; !r && (netreq = *netreq_p)
			    ; netreq_p++) {
				if ((r = _getdns_submit_netreq(netreq, &now_ms))) {
					if (r == DNS_REQ_FINISHED) {
						if (return_netreq_p)
							*return_netreq_p = NULL;
						return GETDNS_RETURN_GOOD;
					}
					_getdns_netreq_change_state(netreq, NET_REQ_ERRORED);
				}
			}
			break;
		} else
			r = GETDNS_RETURN_BAD_CONTEXT;
	}
	if (r > 0) { /* i.e. r != GETDNS_RETURN_GOOD && r != DNS_REQ_FINISHED */
		/* clean up the request */
		_getdns_context_clear_outbound_request(req);
		_getdns_dns_req_free(req);
		if (return_netreq_p)
			*return_netreq_p = NULL;
		return r;
	}
	return GETDNS_RETURN_GOOD;
}				/* getdns_general_ns */

getdns_return_t
_getdns_general_loop(getdns_context *context, getdns_eventloop *loop,
    const char *name, uint16_t request_type, const getdns_dict *extensions,
    void *userarg, getdns_network_req **netreq_p,
    getdns_callback_t callback, internal_cb_t internal_cb)
{
	return getdns_general_ns(context, loop,
	    name, request_type, extensions,
	    userarg, netreq_p, callback, internal_cb, 0);

}				/* getdns_general_loop */

getdns_return_t
_getdns_address_loop(getdns_context *context, getdns_eventloop *loop,
    const char *name, const getdns_dict *extensions, void *userarg,
    getdns_transaction_t *transaction_id, getdns_callback_t callback)
{
	getdns_dict *my_extensions = NULL;
	getdns_return_t r;
	uint32_t value;
	getdns_network_req *netreq = NULL;

	if (!extensions) {
		if (!(my_extensions=getdns_dict_create_with_context(context)))
			return GETDNS_RETURN_MEMORY_ERROR;
	} else if (
	    getdns_dict_get_int(extensions, "return_both_v4_and_v6", &value)
	    && (r = _getdns_dict_copy(extensions, &my_extensions)))
		return r;

	if (my_extensions && (r = getdns_dict_set_int(
	    my_extensions, "return_both_v4_and_v6", GETDNS_EXTENSION_TRUE)))
		return r;

	r = getdns_general_ns(context, loop,
	    name, GETDNS_RRTYPE_AAAA, my_extensions ? my_extensions : extensions,
	    userarg, &netreq, callback, NULL, 1);
	if (netreq && transaction_id)
		*transaction_id = netreq->owner->trans_id;

	if (my_extensions)
		getdns_dict_destroy(my_extensions);

	return r;
} /* getdns_address_loop */

getdns_return_t
_getdns_hostname_loop(getdns_context *context, getdns_eventloop *loop,
    const getdns_dict *address, const getdns_dict *extensions, void *userarg,
    getdns_transaction_t *transaction_id, getdns_callback_t callback)
{
	struct getdns_bindata *address_data;
	struct getdns_bindata *address_type;
	uint16_t req_type;
	char name[1024];
	getdns_return_t retval;
	getdns_network_req *netreq= NULL;

	if ((retval =
		getdns_dict_get_bindata(address, "address_data",
		    &address_data)) != GETDNS_RETURN_GOOD)
		return retval;
	if ((retval =
		getdns_dict_get_bindata(address, "address_type",
		    &address_type)) != GETDNS_RETURN_GOOD)
		return retval;
	if ((strncmp(GETDNS_STR_IPV4, (char *) address_type->data,
		    ( strlen(GETDNS_STR_IPV4) < address_type->size
		    ? strlen(GETDNS_STR_IPV4) : address_type->size )) == 0
	        && address_data->size == 4)
	    || (strncmp(GETDNS_STR_IPV6, (char *) address_type->data,
		    ( strlen(GETDNS_STR_IPV6) < address_type->size
		    ? strlen(GETDNS_STR_IPV6) : address_type->size )) == 0
		&& address_data->size == 16))
		req_type = GETDNS_RRTYPE_PTR;
	else
		return GETDNS_RETURN_INVALID_PARAMETER;

	switch (address_data->size) {
	case 4:
		(void)snprintf(name, sizeof(name),
		    "%d.%d.%d.%d.in-addr.arpa.",
		    (int)((uint8_t *)address_data->data)[3],
		    (int)((uint8_t *)address_data->data)[2],
		    (int)((uint8_t *)address_data->data)[1],
		    (int)((uint8_t *)address_data->data)[0]);
		break;
	case 16:
		(void)snprintf(name, sizeof(name),
		    "%x.%x.%x.%x.%x.%x.%x.%x."
		    "%x.%x.%x.%x.%x.%x.%x.%x."
		    "%x.%x.%x.%x.%x.%x.%x.%x."
		    "%x.%x.%x.%x.%x.%x.%x.%x.ip6.arpa.",
		    (int)(((uint8_t *)address_data->data)[15] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[15] >> 4),
		    (int)(((uint8_t *)address_data->data)[14] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[14] >> 4),
		    (int)(((uint8_t *)address_data->data)[13] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[13] >> 4),
		    (int)(((uint8_t *)address_data->data)[12] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[12] >> 4),
		    (int)(((uint8_t *)address_data->data)[11] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[11] >> 4),
		    (int)(((uint8_t *)address_data->data)[10] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[10] >> 4),
		    (int)(((uint8_t *)address_data->data)[9] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[9] >> 4),
		    (int)(((uint8_t *)address_data->data)[8] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[8] >> 4),
		    (int)(((uint8_t *)address_data->data)[7] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[7] >> 4),
		    (int)(((uint8_t *)address_data->data)[6] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[6] >> 4),
		    (int)(((uint8_t *)address_data->data)[5] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[5] >> 4),
		    (int)(((uint8_t *)address_data->data)[4] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[4] >> 4),
		    (int)(((uint8_t *)address_data->data)[3] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[3] >> 4),
		    (int)(((uint8_t *)address_data->data)[2] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[2] >> 4),
		    (int)(((uint8_t *)address_data->data)[1] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[1] >> 4),
		    (int)(((uint8_t *)address_data->data)[0] & 0x0F),
		    (int)(((uint8_t *)address_data->data)[0] >> 4));
		break;
	default:
		return GETDNS_RETURN_INVALID_PARAMETER;
	}
	retval = _getdns_general_loop(context, loop, name, req_type,
	    extensions, userarg, &netreq, callback, NULL);
	if (netreq && transaction_id)
		*transaction_id = netreq->owner->trans_id;
	return retval;
}				/* getdns_hostname_loop */

getdns_return_t
_getdns_service_loop(getdns_context *context, getdns_eventloop *loop,
    const char *name, const getdns_dict *extensions, void *userarg,
    getdns_transaction_t * transaction_id, getdns_callback_t callback)
{
	getdns_return_t r;
	getdns_network_req *netreq = NULL;
	r = getdns_general_ns(context, loop, name, GETDNS_RRTYPE_SRV,
	    extensions, userarg, &netreq, callback, NULL, 1);
	if (netreq && transaction_id)
		*transaction_id = netreq->owner->trans_id;
	return r;
}				/* getdns_service_loop */

/**
 * getdns_general
 */
getdns_return_t
getdns_general(getdns_context *context,
    const char *name, uint16_t request_type, const getdns_dict *extensions,
    void *userarg, getdns_transaction_t * transaction_id,
    getdns_callback_t callbackfn)
{
	getdns_return_t r;
	getdns_network_req *netreq = NULL;

	if (!context) return GETDNS_RETURN_INVALID_PARAMETER;
	r = _getdns_general_loop(context, context->extension,
	    name, request_type, extensions,
	    userarg, &netreq, callbackfn, NULL);
	if (netreq && transaction_id)
		*transaction_id = netreq->owner->trans_id;
	return r;
}				/* getdns_general */

/*
 * getdns_address
 *
 */
getdns_return_t
getdns_address(getdns_context *context,
    const char *name, const getdns_dict *extensions, void *userarg,
    getdns_transaction_t *transaction_id, getdns_callback_t callbackfn)
{
	if (!context) return GETDNS_RETURN_INVALID_PARAMETER;
	return _getdns_address_loop(context, context->extension,
	    name, extensions, userarg,
	    transaction_id, callbackfn);
} /* getdns_address */

/*
 * getdns_hostname
 *
 */
getdns_return_t
getdns_hostname(getdns_context *context,
    const getdns_dict *address, const getdns_dict *extensions, void *userarg,
    getdns_transaction_t *transaction_id, getdns_callback_t callbackfn)
{
	if (!context) return GETDNS_RETURN_INVALID_PARAMETER;
	return _getdns_hostname_loop(context, context->extension,
	    address, extensions, userarg, transaction_id, callbackfn);
}				/* getdns_hostname */

/*
 * getdns_service
 *
 */
getdns_return_t
getdns_service(getdns_context *context,
    const char *name, const getdns_dict *extensions, void *userarg,
    getdns_transaction_t *transaction_id, getdns_callback_t callbackfn)
{
	if (!context) return GETDNS_RETURN_INVALID_PARAMETER;
	return _getdns_service_loop(context, context->extension,
	    name, extensions, userarg, transaction_id, callbackfn);
}				/* getdns_service */

/* getdns_general.c */
