Merge branch 'feature/unbound' into develop

README.md

@@ -40,6 +40,8 @@ External dependencies are linked outside the getdns API build tree (we rely on c
 
 The project relies on [libldns from NL](https://www.nlnetlabs.nl/projects/ldns/) for parsing and constructing DNS packets.  Version 1.6.16 (note that building ldns may require openssl headers and libraries)
 
+The project also relies on [libunbound from NL](http://www.nlnetlabs.nl/projects/unbound/).  Currently it relies on svn revision 2985.  The unbound.2985.patch must be applied to the source tree as well.  The ./configure must be run with the --with-libevent option (recommended to also use --with-libunbound-only)
+
 Although [libevent](http://libevent.org) is used initially to implement the asynchronous model, future work may include a move to other mechanisms (epoll based etc.).  Version 2.0.21 stable
 
 Doxygen is used to generate documentation, while this is not technically necessary for the build it makes things a lot more pleasant.

configure.ac

@@ -26,10 +26,11 @@ AC_PROG_CPP
 
 # Checks for libraries.
 found_all_libs=1
-AC_MSG_NOTICE([Checking for dependencies ldns and libevent])
+AC_MSG_NOTICE([Checking for dependencies libevent, ldns, pthread, and unbound])
 AC_CHECK_LIB([event_core], [event_base_new], [], [found_all_libs=0])
 AC_CHECK_LIB([ldns], [ldns_dname_new_frm_str], [], [found_all_libs=0])
 AC_CHECK_LIB([pthread], [pthread_create], [], [found_all_libs=0])
+AC_CHECK_LIB([unbound], [ub_ctx_set_event], [], [found_all_libs=0])
 if test $found_all_libs == 0
 then
     AC_MSG_ERROR([One more dependencies is missing])

src/Makefile.in

@@ -17,8 +17,7 @@ VPATH = @srcdir@
 
 CC=gcc
 CFLAGS=-Wall -g -fPIC -I$(srcdir)/ -I /usr/local/include -std=c99
-# LDFLAGS=-L. -L/usr/local/lib
+LDFLAGS=-levent_core -lldns -lunbound
-# LDLIBS=-levent_core -lldns -lgetdns
 # PROGRAMS=example-simple-answers example-tree example-all-functions example-synchronous
 
 .SUFFIXES: .c .o .a .lo .h
@@ -32,9 +31,9 @@ all: libgetdns
 	cd test && $(MAKE) $@
 	cd example && $(MAKE) $@
 
-libgetdns: sync.o context.o list.o dict.o convert.o general.o hostname.o service.o \
+libgetdns: sync.o context.o list.o dict.o convert.o general.o hostname.o service.o request-internal.o \
-	validate_dnssec.o nameserver-internal.o request-internal.o util-internal.o getdns_error.o
+	validate_dnssec.o util-internal.o getdns_error.o
-	$(CC) $(CFLAGS) -shared -o libgetdns.so $?
+	$(CC) $(CFLAGS) $(LDFLAGS) -shared -o libgetdns.so $?
 
 clean:
 	rm -f *.o $(PROGRAMS) libgetdns.so

src/context.c

@@ -29,9 +29,16 @@
  */
 
 #include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include "context.h"
 #include "util-internal.h"
+#include "types-internal.h"
 #include <ldns/ldns.h>
+#include <event2/event.h>
+#include <unbound.h>
+#include <unbound-event.h>
+#include <arpa/inet.h>
 
 /* stuff to make it compile pedantically */
 #define UNUSED_PARAM(x) ((void)(x))
@@ -55,6 +62,34 @@ static struct getdns_list* create_default_root_servers() {
     return NULL;
 }
 
+static getdns_return_t add_ip_str(getdns_dict* ip) {
+    struct sockaddr_storage storage;
+    char buff[256];
+    getdns_return_t r = dict_to_sockaddr(ip, &storage);
+    if (r != GETDNS_RETURN_GOOD) {
+        return r;
+    }
+    if (storage.ss_family == AF_INET) {
+        struct sockaddr_in* addr = (struct sockaddr_in*) &storage;
+        const char* ipStr = inet_ntop(AF_INET, &(addr->sin_addr), buff, 256);
+        if (!ipStr) {
+            return GETDNS_RETURN_GENERIC_ERROR;
+        }
+        getdns_dict_util_set_string(ip, GETDNS_STR_ADDRESS_STRING, ipStr);
+    } else if (storage.ss_family == AF_INET6) {
+        struct sockaddr_in6* addr = (struct sockaddr_in6*) &storage;
+        const char* ipStr = inet_ntop(AF_INET6, &(addr->sin6_addr), buff, 256);
+        if (!ipStr) {
+            return GETDNS_RETURN_GENERIC_ERROR;
+        }
+        getdns_dict_util_set_string(ip, GETDNS_STR_ADDRESS_STRING, ipStr);
+    } else {
+        /* unknown */
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+    return GETDNS_RETURN_GOOD;
+}
+
 static struct getdns_dict* create_ipaddr_dict_from_rdf(ldns_rdf* rdf) {
     ldns_rdf_type rt = ldns_rdf_get_type(rdf);
     size_t sz = ldns_rdf_size(rdf);
@@ -68,6 +103,7 @@ static struct getdns_dict* create_ipaddr_dict_from_rdf(ldns_rdf* rdf) {
     /* set data */
     getdns_bindata data_bin = { sz, ldns_rdf_data(rdf) };
     getdns_dict_set_bindata(result, GETDNS_STR_ADDRESS_DATA, &data_bin);
+    add_ip_str(result);
     return result;
 }
 
@@ -127,6 +163,26 @@ static getdns_return_t set_os_defaults(getdns_context_t context) {
     return GETDNS_RETURN_GOOD;
 }
 
+static int transaction_id_cmp(const void* id1, const void* id2) {
+    if (id1 == NULL && id2 == NULL) {
+        return 0;
+    } else if (id1 == NULL && id2 != NULL) {
+        return 1;
+    } else if (id1 != NULL && id2 == NULL) {
+        return -1;
+    } else {
+        getdns_transaction_t t1 = *((const getdns_transaction_t*) id1);
+        getdns_transaction_t t2 = *((const getdns_transaction_t*) id2);
+        if (t1 == t2) {
+            return 0;
+        } else if (t1 < t2) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+}
+
 /*
  * getdns_context_create
  *
@@ -143,17 +199,30 @@ getdns_return_t getdns_context_create(
         return GETDNS_RETURN_GENERIC_ERROR;
     }
 
-    getdns_dict *outbound_reqs = getdns_dict_create();
+    /** default init **/
-    if (outbound_reqs == NULL) {
+    result = malloc(sizeof(struct getdns_context_t));
+    if (!result) {
         return GETDNS_RETURN_GENERIC_ERROR;
     }
 
-    /** default init **/
+    result->update_callback = NULL;
-    result = malloc(sizeof(struct getdns_context_t));
+    result->memory_allocator = malloc;
+    result->memory_deallocator = free;
+    result->memory_reallocator = realloc;
+
+    result->event_base_sync = event_base_new();
+    result->unbound_sync = ub_ctx_create_event(result->event_base_sync);
+    /* create the async one also so options are kept up to date */
+    result->unbound_async = ub_ctx_create_event(result->event_base_sync);
+
+    result->async_set = 0;
+    result->resolution_type_set = 0;
+
+    result->outbound_requests = ldns_rbtree_create(transaction_id_cmp);
+
     result->resolution_type = GETDNS_CONTEXT_RECURSING;
     result->namespaces = create_default_namespaces();
-    result->dns_transport = GETDNS_CONTEXT_UDP_FIRST_AND_FALL_BACK_TO_TCP;
+
-    result->limit_outstanding_queries = 0;
     result->timeout = 5000;
     result->follow_redirects = GETDNS_CONTEXT_FOLLOW_REDIRECTS;
     result->dns_root_servers = create_default_root_servers();
@@ -161,22 +230,12 @@ getdns_return_t getdns_context_create(
     result->suffix = NULL;
 
     result->dnssec_trust_anchors = NULL;
-    result->dnssec_allow_skew = 0;
     result->upstream_list = NULL;
-    result->edns_maximum_udp_payload_size = 512;
+
     result->edns_extended_rcode = 0;
     result->edns_version = 0;
     result->edns_do_bit = 0;
 
-    result->event_base = NULL;
-    result->resolver_socket = 0;
-    result->outbound_reqs = outbound_reqs; 
-
-    result->update_callback = NULL;
-    result->memory_allocator = malloc;
-    result->memory_deallocator = free;
-    result->memory_reallocator = realloc;
-
     if (set_from_os) {
         if (GETDNS_RETURN_GOOD != set_os_defaults(result)) {
             getdns_context_destroy(result);
@@ -186,6 +245,12 @@ getdns_return_t getdns_context_create(
 
     *context = result;
 
+    /* other opts */
+    getdns_context_set_dnssec_allowed_skew(result, 0);
+    getdns_context_set_edns_maximum_udp_payload_size(result, 512);
+    getdns_context_set_dns_transport(result, GETDNS_CONTEXT_UDP_FIRST_AND_FALL_BACK_TO_TCP);
+
+
     return GETDNS_RETURN_GOOD;
 } /* getdns_context_create */
 
@@ -211,13 +276,13 @@ getdns_context_destroy(
     getdns_list_destroy(context->dnssec_trust_anchors);
     getdns_list_destroy(context->upstream_list);
 
-    getdns_dict_destroy(context->outbound_reqs);
+    /* destroy the ub context */
+    ub_ctx_delete(context->unbound_async);
+    ub_ctx_delete(context->unbound_sync);
 
-    /* TODO: cancel all events */
+    event_base_free(context->event_base_sync);
 
-    if (context->resolver_socket != 0) {
+    ldns_rbtree_free(context->outbound_requests);
-        evutil_closesocket(context->resolver_socket);
-    }
 
     free(context);
     return;
@@ -237,6 +302,30 @@ getdns_context_set_context_update_callback(
     return GETDNS_RETURN_GOOD;
 } /* getdns_context_set_context_update_callback */
 
+/*
+ * Helpers to set options on the unbound ctx
+ */
+
+static void set_ub_string_opt(getdns_context_t ctx, char* opt, char* value) {
+    ub_ctx_set_option(ctx->unbound_sync, opt, value);
+    ub_ctx_set_option(ctx->unbound_async, opt, value);
+}
+
+static void set_ub_number_opt(getdns_context_t ctx, char* opt, uint16_t value) {
+    char buffer[64];
+    snprintf(buffer, 64, "%hu", value);
+    set_ub_string_opt(ctx, opt, buffer);
+}
+
+/*
+ * Clear the resolution type set flag if needed
+ */
+static inline void clear_resolution_type_set_flag(getdns_context_t context, uint16_t type) {
+    if (context->resolution_type_set == type) {
+        context->resolution_type_set = 0;
+    }
+}
+
 /*
  * getdns_context_set_context_update
  *
@@ -323,15 +412,25 @@ getdns_context_set_dns_transport(
   uint16_t               value
 )
 {
-    if (value != GETDNS_CONTEXT_UDP_FIRST_AND_FALL_BACK_TO_TCP &&
+
-        value != GETDNS_CONTEXT_UDP_ONLY &&
+    switch (value) {
-        value != GETDNS_CONTEXT_TCP_ONLY &&
+        case GETDNS_CONTEXT_UDP_FIRST_AND_FALL_BACK_TO_TCP:
-        value != GETDNS_CONTEXT_TCP_ONLY_KEEP_CONNECTIONS_OPEN) {
+            set_ub_string_opt(context, "do-udp", "yes");
+            set_ub_string_opt(context, "do-tcp", "yes");
+            break;
+        case GETDNS_CONTEXT_UDP_ONLY:
+            set_ub_string_opt(context, "do-udp", "yes");
+            set_ub_string_opt(context, "do-tcp", "no");
+            break;
+        case GETDNS_CONTEXT_TCP_ONLY:
+            set_ub_string_opt(context, "do-udp", "no");
+            set_ub_string_opt(context, "do-tcp", "yes");
+            break;
+        default:
+            /* TODO GETDNS_CONTEXT_TCP_ONLY_KEEP_CONNECTIONS_OPEN */
             return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
     }
 
-    context->dns_transport = value;
-
     dispatch_updated(context, GETDNS_CONTEXT_CODE_DNS_TRANSPORT);
 
     return GETDNS_RETURN_GOOD;
@@ -347,7 +446,8 @@ getdns_context_set_limit_outstanding_queries(
   uint16_t               limit
 )
 {
-    context->limit_outstanding_queries = limit;
+    /* num-queries-per-thread */
+    set_ub_number_opt(context, "num-queries-per-thread", limit);
 
     dispatch_updated(context, GETDNS_CONTEXT_CODE_LIMIT_OUTSTANDING_QUERIES);
 
@@ -383,6 +483,7 @@ getdns_context_set_follow_redirects(
 {
     context->follow_redirects = value;
 
+    clear_resolution_type_set_flag(context, GETDNS_CONTEXT_RECURSING);
     dispatch_updated(context, GETDNS_CONTEXT_CODE_FOLLOW_REDIRECTS);
 
     return GETDNS_RETURN_GOOD;
@@ -399,15 +500,40 @@ getdns_context_set_dns_root_servers(
 )
 {
     getdns_list *copy = NULL;
+    size_t count = 0;
     if (addresses != NULL) {
         if (getdns_list_copy(addresses, &copy) != GETDNS_RETURN_GOOD) {
             return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
         }
         addresses = copy;
+        getdns_list_get_length(addresses, &count);
+        if (count == 0) {
+            getdns_list_destroy(addresses);
+            addresses = NULL;
+        } else {
+            size_t i = 0;
+            getdns_return_t r = GETDNS_RETURN_GOOD;
+            /* validate and add ip str */
+            for (i = 0; i < count; ++i) {
+                getdns_dict* dict = NULL;
+                getdns_list_get_dict(addresses, i, &dict);
+                r = add_ip_str(dict);
+                if (r != GETDNS_RETURN_GOOD) {
+                    break;
                 }
+            }
+            if (r != GETDNS_RETURN_GOOD) {
+                getdns_list_destroy(addresses);
+                return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
+            }
+        }
+    }
+
     getdns_list_destroy(context->dns_root_servers);
     context->dns_root_servers = addresses;
 
+    clear_resolution_type_set_flag(context, GETDNS_CONTEXT_RECURSING);
+
     dispatch_updated(context, GETDNS_CONTEXT_CODE_DNS_ROOT_SERVERS);
 
     return GETDNS_RETURN_GOOD;
@@ -427,7 +553,6 @@ getdns_context_set_append_name(
         value != GETDNS_CONTEXT_APPEND_NAME_ONLY_TO_SINGLE_LABEL_AFTER_FAILURE &&
         value != GETDNS_CONTEXT_APPEND_NAME_ONLY_TO_MULTIPLE_LABEL_NAME_AFTER_FAILURE &&
         value != GETDNS_CONTEXT_DO_NOT_APPEND_NAMES) {
-    
         return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
     }
 
@@ -458,6 +583,8 @@ getdns_context_set_suffix(
     getdns_list_destroy(context->suffix);
     context->suffix = value;
 
+    clear_resolution_type_set_flag(context, GETDNS_CONTEXT_STUB);
+
     dispatch_updated(context, GETDNS_CONTEXT_CODE_SUFFIX);
 
     return GETDNS_RETURN_GOOD;
@@ -498,8 +625,8 @@ getdns_context_set_dnssec_allowed_skew(
   uint16_t               value
 )
 {
-    context->dnssec_allow_skew = value;
+    set_ub_number_opt(context, "val-sig-skew-min", value);
-
+    set_ub_number_opt(context, "val-sig-skew-max", value);
     dispatch_updated(context, GETDNS_CONTEXT_CODE_DNSSEC_ALLOWED_SKEW);
 
     return GETDNS_RETURN_GOOD;
@@ -515,7 +642,10 @@ getdns_context_set_stub_resolution(
   struct getdns_list     *upstream_list
 )
 {
-    if (upstream_list == NULL) {
+    size_t count = 0;
+    size_t i = 0;
+    getdns_return_t r = getdns_list_get_length(upstream_list, &count);
+    if (count == 0 || r != GETDNS_RETURN_GOOD) {
         return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
     }
     getdns_list *copy = NULL;
@@ -523,12 +653,26 @@ getdns_context_set_stub_resolution(
         return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
     }
     upstream_list = copy;
+    /* validate and add ip str */
+    for (i = 0; i < count; ++i) {
+        getdns_dict* dict = NULL;
+        getdns_list_get_dict(upstream_list, i, &dict);
+        r = add_ip_str(dict);
+        if (r != GETDNS_RETURN_GOOD) {
+            break;
+        }
+    }
 
-    getdns_context_set_resolution_type(context, GETDNS_CONTEXT_STUB);
+    if (r != GETDNS_RETURN_GOOD) {
+        getdns_list_destroy(upstream_list);
+        return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
+    }
 
     getdns_list_destroy(context->upstream_list);
     context->upstream_list = upstream_list;
 
+    clear_resolution_type_set_flag(context, GETDNS_CONTEXT_STUB);
+
     dispatch_updated(context, GETDNS_CONTEXT_CODE_UPSTREAM_RECURSIVE_SERVERS);
 
     return GETDNS_RETURN_GOOD;
@@ -549,7 +693,8 @@ getdns_context_set_edns_maximum_udp_payload_size(
         return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
     }
 
-    context->edns_maximum_udp_payload_size = value;
+    /* max-udp-size */
+    set_ub_number_opt(context, "max-udp-size", value);
 
     dispatch_updated(context, GETDNS_CONTEXT_CODE_EDNS_MAXIMUM_UDP_PAYLOAD_SIZE);
 
@@ -667,12 +812,33 @@ getdns_extension_set_libevent_base(
     struct event_base      *this_event_base
 )
 {
-    /* TODO: cancel anything on an existing event base */
+    if (this_event_base) {
-    context->event_base = this_event_base;
+        ub_ctx_set_event(context->unbound_async, this_event_base);
-
+        context->async_set = 1;
+    } else {
+        ub_ctx_set_event(context->unbound_async, context->event_base_sync);
+        context->async_set = 0;
+    }
     return GETDNS_RETURN_GOOD;
 } /* getdns_extension_set_libevent_base */
 
+/* cancel the request */
+static void cancel_dns_req(getdns_dns_req* req) {
+    getdns_network_req* netreq = req->first_req;
+    while (netreq) {
+        if (netreq->state == NET_REQ_IN_FLIGHT) {
+            /* for ev based ub, this should always prevent
+             * the callback from firing */
+            ub_cancel(req->unbound, netreq->unbound_id);
+            netreq->state = NET_REQ_CANCELED;
+        } else if (netreq->state == NET_REQ_NOT_SENT) {
+            netreq->state = NET_REQ_CANCELED;
+        }
+        netreq = netreq->next;
+    }
+    req->canceled = 1;
+}
+
 /*
  * getdns_cancel_callback
  *
@@ -683,9 +849,112 @@ getdns_cancel_callback(
 	getdns_transaction_t       transaction_id
 )
 {
-    UNUSED_PARAM(context);
+    getdns_dns_req *req = NULL;
-    UNUSED_PARAM(transaction_id);
+    getdns_callback_t cb = NULL;
+    void* user_pointer = NULL;
+
+    /* delete the node from the tree */
+    ldns_rbnode_t* node = ldns_rbtree_delete(context->outbound_requests,
+                                             &transaction_id);
+
+    if (!node) {
+        return GETDNS_RETURN_UNKNOWN_TRANSACTION;
+    }
+    req = (getdns_dns_req*) node->data;
+    /* do the cancel */
+
+    cancel_dns_req(req);
+    cb = req->user_callback;
+    user_pointer = req->user_pointer;
+
+    /* clean up */
+    context->memory_deallocator(node);
+    dns_req_free(req);
+
+    /* fire callback */
+    cb(context,
+       GETDNS_CALLBACK_CANCEL,
+       NULL,
+       user_pointer,
+       transaction_id);
+
     return GETDNS_RETURN_GOOD;
 } /* getdns_cancel_callback */
 
+static void ub_setup_stub(struct ub_ctx* ctx, getdns_list* upstreams, size_t count) {
+    size_t i;
+    /* reset forwarding servers */
+    ub_ctx_set_fwd(ctx, NULL);
+    for (i = 0 ; i < count; ++i) {
+        getdns_dict* dict = NULL;
+        char* ip_str = NULL;
+        getdns_list_get_dict(upstreams, i, &dict);
+        getdns_dict_util_get_string(dict, GETDNS_STR_ADDRESS_STRING, &ip_str);
+        ub_ctx_set_fwd(ctx, ip_str);
+    }
+}
+
+getdns_return_t getdns_context_prepare_for_resolution(getdns_context_t context) {
+    if (context->resolution_type_set == context->resolution_type) {
+        /* already set and no config changes have caused this to be
+         * bad.
+         */
+         return GETDNS_RETURN_GOOD;
+    }
+    if (context->resolution_type == GETDNS_CONTEXT_STUB) {
+        size_t upstream_len = 0;
+        getdns_return_t r = getdns_list_get_length(context->upstream_list, &upstream_len);
+        if (r != GETDNS_RETURN_GOOD || upstream_len == 0) {
+            return GETDNS_RETURN_BAD_CONTEXT;
+        }
+        /* set upstreams */
+        ub_setup_stub(context->unbound_async, context->upstream_list, upstream_len);
+        ub_setup_stub(context->unbound_sync, context->upstream_list, upstream_len);
+
+    } else if (context->resolution_type == GETDNS_CONTEXT_RECURSING) {
+        /* set recursive */
+        /* TODO: use the root servers via root hints file */
+        ub_ctx_set_fwd(context->unbound_async, NULL);
+        ub_ctx_set_fwd(context->unbound_sync, NULL);
+
+    } else {
+        /* bogus? */
+        return GETDNS_RETURN_BAD_CONTEXT;
+    }
+    context->resolution_type_set = context->resolution_type;
+    return GETDNS_RETURN_GOOD;
+}
+
+getdns_return_t getdns_context_track_outbound_request(getdns_dns_req* req) {
+    if (!req) {
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+    getdns_context_t context = req->context;
+    ldns_rbnode_t* node = context->memory_allocator(sizeof(ldns_rbnode_t));
+    if (!node) {
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+    node->key = &(req->trans_id);
+    node->data = req;
+    if (!ldns_rbtree_insert(context->outbound_requests, node)) {
+        /* free the node */
+        context->memory_deallocator(node);
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+    return GETDNS_RETURN_GOOD;
+}
+
+getdns_return_t getdns_context_clear_outbound_request(getdns_dns_req* req) {
+    if (!req) {
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+    getdns_context_t context = req->context;
+    ldns_rbnode_t* node = ldns_rbtree_delete(context->outbound_requests,
+                                             &(req->trans_id));
+    if (node) {
+        context->memory_deallocator(node);
+    }
+    return GETDNS_RETURN_GOOD;
+}
+
 /* getdns_context.c */

src/context.h

@@ -32,6 +32,11 @@
 
 #include <getdns/getdns.h>
 
+struct event_base;
+struct ub_ctx;
+struct ldns_rbtree_t;
+struct getdns_dns_req;
+
 /** function pointer typedefs */
 typedef void (*getdns_update_callback)(getdns_context_t context, uint16_t changed_item);
 typedef void* (*getdns_memory_allocator)(size_t size);
@@ -43,17 +48,14 @@ struct getdns_context_t {
     /* Context values */
     uint16_t resolution_type;
     uint16_t *namespaces;
-    uint16_t dns_transport;
-    uint16_t limit_outstanding_queries;
     uint16_t timeout;
     uint16_t follow_redirects;
     struct getdns_list *dns_root_servers;
     uint16_t append_name;
     struct getdns_list *suffix;
     struct getdns_list *dnssec_trust_anchors;
-    uint16_t dnssec_allow_skew;
     struct getdns_list *upstream_list;
-    uint16_t edns_maximum_udp_payload_size;
+
     uint8_t edns_extended_rcode;
     uint8_t edns_version;
     uint8_t edns_do_bit;
@@ -63,15 +65,38 @@ struct getdns_context_t {
     getdns_memory_deallocator memory_deallocator;
     getdns_memory_reallocator memory_reallocator;
 
-    /* Event loop */
+    /* Event loop for sync requests */
-    struct event_base* event_base;
+    struct event_base* event_base_sync;
 
-    /* outbound request dict (transaction -> req struct) */
+    /* The underlying unbound contexts that do
-    getdns_dict *outbound_reqs;
+       the real work */
+    struct ub_ctx *unbound_sync;
+    struct ub_ctx *unbound_async;
+    /* whether an async event base was set */
+    uint8_t async_set;
 
-    /* socket */
+    /* which resolution type the contexts are configured for
-    evutil_socket_t resolver_socket;
+     * 0 means nothing set
+     */
+    uint8_t resolution_type_set;
+
+    /*
+     * outbound requests -> transaction to getdns_dns_req
+     */
+    struct ldns_rbtree_t* outbound_requests;
 } ;
 
+/** internal functions **/
+/**
+ * Sets up the unbound contexts with stub or recursive behavior
+ * if needed.
+ */
+getdns_return_t getdns_context_prepare_for_resolution(getdns_context_t context);
+
+/* track an outbound request */
+getdns_return_t getdns_context_track_outbound_request(struct getdns_dns_req* req);
+/* clear the outbound request from being tracked - does not cancel it */
+getdns_return_t getdns_context_clear_outbound_request(struct getdns_dns_req* req);
+
 #endif
 

src/convert.c

@@ -30,6 +30,8 @@
 
 #include <getdns/getdns.h>
 #include <stdio.h>
+#include <arpa/inet.h>
+#include <util-internal.h>
 
 /* stuff to make it compile pedantically */
 #define UNUSED_PARAM(x) ((void)(x))
@@ -62,7 +64,32 @@ char *
 getdns_display_ip_address(
   struct getdns_bindata    *bindata_of_ipv4_or_ipv6_address
 )
-{ UNUSED_PARAM(bindata_of_ipv4_or_ipv6_address); return NULL; }
+{
+    char buff[256];
+    if (!bindata_of_ipv4_or_ipv6_address ||
+        bindata_of_ipv4_or_ipv6_address->size == 0 ||
+        !bindata_of_ipv4_or_ipv6_address->data) {
+        return NULL;
+    }
+    if (bindata_of_ipv4_or_ipv6_address->size == 4) {
+        const char* ipStr = inet_ntop(AF_INET,
+                                      bindata_of_ipv4_or_ipv6_address->data,
+                                      buff,
+                                      256);
+        if (ipStr) {
+            return strdup(ipStr);
+        }
+    } else if (bindata_of_ipv4_or_ipv6_address->size == 16) {
+        const char* ipStr = inet_ntop(AF_INET6,
+                                      bindata_of_ipv4_or_ipv6_address->data,
+                                      buff,
+                                      256);
+        if (ipStr) {
+            return strdup(ipStr);
+        }
+    }
+    return NULL;
+}
 
 getdns_return_t
 getdns_strerror(getdns_return_t err, char *buf, size_t buflen)

src/example/Makefile.in

@@ -17,7 +17,7 @@ VPATH = @srcdir@
 CC=gcc
 CFLAGS=-Wall -g -fPIC -I$(srcdir)/ -I$(srcdir)/../ -I/usr/local/include -std=c99
 LDFLAGS=-L. -L$(srcdir)/.. -L/usr/local/lib 
-LDLIBS=-lgetdns -lldns -levent_core
+LDLIBS=-lgetdns -lldns -levent_core -lunbound
 PROGRAMS=example_simple_answers example_tree example_all_functions example_synchronous
 
 .SUFFIXES: .c .o .a .lo .h

src/example/example_simple_answers.c

@@ -32,6 +32,7 @@
 #include <string.h>
 #include <inttypes.h>
 #include <getdns/getdns.h>
+#include <event2/event.h>
 
 #define UNUSED_PARAM(x) ((void)(x))
 

src/example/example_tree.c

@@ -4,6 +4,7 @@
 #include <string.h>
 #include <inttypes.h>
 #include <getdns/getdns.h>
+#include <event2/event.h>
 
 #define UNUSED_PARAM(x) ((void)(x))
 

src/general.c

@@ -58,138 +58,190 @@
  * Version: 0.1b
  */
 
+#include <string.h>
+#include <unbound.h>
+#include <unbound-event.h>
+#include <ldns/ldns.h>
+#include "context.h"
 #include "types-internal.h"
 #include "util-internal.h"
 
 /* stuff to make it compile pedantically */
 #define UNUSED_PARAM(x) ((void)(x))
 
-/* libevent callback for a network request */
+/* declarations */
-static void dns_req_callback(int fd, short events, void *arg) {
+ static void ub_resolve_callback(void* arg, int err, ldns_buffer* result, int sec, char* bogus);
-    getdns_dns_req *request = (getdns_dns_req*) arg;
+ static void handle_network_request_error(getdns_network_req* netreq, int err);
-    uint8_t data[1500];
+ static void handle_dns_request_complete(getdns_dns_req* dns_req);
-    if (events & EV_READ) {
+ static int submit_network_request(getdns_network_req* netreq);
-        while (1) {
+
-            ssize_t r = recv(fd, data, sizeof(data), MSG_DONTWAIT);
+/* cleanup and send an error to the user callback */
-            if (r < 0) {
+ static void handle_network_request_error(getdns_network_req* netreq, int err) {
-                if (errno == EAGAIN) return;
+    getdns_dns_req *dns_req = netreq->owner;
-                /* otherwise failed */
+    getdns_context_t context = dns_req->context;
-                request->user_callback(request->context,
+    getdns_transaction_t trans_id = dns_req->trans_id;
+    getdns_callback_t cb = dns_req->user_callback;
+    void* user_arg = dns_req->user_pointer;
+
+    /* clean up */
+    getdns_context_clear_outbound_request(dns_req);
+    dns_req_free(dns_req);
+
+    cb(context,
        GETDNS_CALLBACK_ERROR,
-                                       NULL, request->user_pointer,
+       NULL,
-                                       request->trans_id);
+       user_arg,
-            }
+       trans_id);
-            /* parse a packet */
+}
-            ldns_pkt* pkt = NULL;
+
-            ldns_wire2pkt(&pkt, data, r);
+/* cleanup and send the response to the user callback */
-            if (pkt == NULL) {
+static void handle_dns_request_complete(getdns_dns_req* dns_req) {
-                /* otherwise failed */
+    getdns_dict* response = create_getdns_response(dns_req);
-                request->user_callback(request->context,
+
-                                       GETDNS_CALLBACK_ERROR,
+    getdns_context_t context = dns_req->context;
-                                       NULL, request->user_pointer,
+    getdns_transaction_t trans_id = dns_req->trans_id;
-                                       request->trans_id);
+    getdns_callback_t cb = dns_req->user_callback;
+    void* user_arg = dns_req->user_pointer;
+
+    /* clean up the request */
+    getdns_context_clear_outbound_request(dns_req);
+    dns_req_free(dns_req);
+    if (response) {
+        cb(context,
+           GETDNS_CALLBACK_COMPLETE,
+           response,
+           user_arg,
+           trans_id);
     } else {
-                /* success */
+        cb(context,
-                getdns_dict* response = create_getdns_response(pkt);
+           GETDNS_CALLBACK_ERROR,
-                ldns_pkt_free(pkt);
+           NULL,
-                request->user_callback(request->context, GETDNS_CALLBACK_COMPLETE,
+           user_arg,
-                                       response, request->user_pointer,
+           trans_id);
-                                       request->trans_id);
     }
-        }
+
-    } else if (events & EV_TIMEOUT) {
-        request->user_callback(request->context, GETDNS_CALLBACK_TIMEOUT,
-                               NULL, request->user_pointer, request->trans_id);
-    }
-    /* clean up ns since right now it's 1:1 with the request */
-    nameserver_free(request->current_req->ns);
-    /* cleanup the request */
-    dns_req_free(request);
 }
 
-/* submit a new request to the event loop */
+static int submit_network_request(getdns_network_req* netreq) {
-static getdns_return_t submit_new_dns_req(getdns_dns_req *request) {
+    getdns_dns_req *dns_req = netreq->owner;
-    getdns_dict *ip_dict = NULL;
+    int r = ub_resolve_event(dns_req->unbound,
-    getdns_context_t context = request->context;
+                            dns_req->name,
-    uint8_t* data = NULL;
+                            netreq->request_type,
-    size_t data_len = 0;
+                            netreq->request_class,
-    struct timeval timeout = { 5, 0 };
+                            netreq,
-    
+                            ub_resolve_callback,
-    /* get first upstream server */
+                            &(netreq->unbound_id));
-    getdns_list_get_dict(context->upstream_list, 0, &ip_dict);
+    netreq->state = NET_REQ_IN_FLIGHT;
-    if (!ip_dict) {
+    return r;
-        return GETDNS_RETURN_GENERIC_ERROR;
-    }
-    
-    /* get the nameserver */
-    getdns_nameserver *ns = nameserver_new_from_ip_dict(context, ip_dict);
-    if (!ns) {
-        return GETDNS_RETURN_GENERIC_ERROR;
-    }
-    
-    request->current_req->ns = ns;
-
-    /* schedule on the loop */
-    ns->event = event_new(context->event_base, request->current_req->ns->socket,
-                          EV_READ | EV_TIMEOUT,
-                          dns_req_callback, request);
-    
-    event_add(ns->event, &timeout);
-    
-    /* send data */
-    ldns_pkt *pkt = request->current_req->pkt;
-    ldns_pkt2wire(&data, pkt, &data_len);
-    send(ns->socket, data, data_len, MSG_DONTWAIT);
-    free(data);
-    
-    return GETDNS_RETURN_GOOD;
 }
 
-
+static void ub_resolve_callback(void* arg, int err, ldns_buffer* result, int sec, char* bogus) {
-/*
+    getdns_network_req* netreq = (getdns_network_req*) arg;
- * getdns_general
+    /* if netreq->state == NET_REQ_NOT_SENT here, that implies
+     * that ub called us back immediately - probably from a local file.
+     * This most likely means that getdns_general has not returned
      */
+    netreq->state = NET_REQ_FINISHED;
+    if (err) {
+        handle_network_request_error(netreq, err);
+    } else {
+        /* parse */
+        ldns_status r = ldns_buffer2pkt_wire(&(netreq->result), result);
+        if (r != LDNS_STATUS_OK) {
+            handle_network_request_error(netreq, r);
+        } else {
+            /* is this the last request */
+            if (!netreq->next) {
+                /* finished */
+                handle_dns_request_complete(netreq->owner);
+            } else {
+                /* not finished - update to next request and ship it */
+                getdns_dns_req* dns_req = netreq->owner;
+                dns_req->current_req = netreq->next;
+                submit_network_request(netreq->next);
+            }
+        }
+    }
+}
+
 getdns_return_t
-getdns_general(
+getdns_general_ub(struct ub_ctx* unbound,
                   getdns_context_t context,
                   const char *name,
                   uint16_t request_type,
                   struct getdns_dict *extensions,
                   void *userarg,
                   getdns_transaction_t *transaction_id,
-  getdns_callback_t          callback
+                  getdns_callback_t callbackfn) {
-)
+
-{
+    getdns_return_t gr;
-    /* Default to zero */
+    int r;
-    if (transaction_id != NULL) {
+
-        *transaction_id = 0;
+    gr = getdns_context_prepare_for_resolution(context);
+    if (gr != GETDNS_RETURN_GOOD) {
+        return GETDNS_RETURN_BAD_CONTEXT;
     }
-    if (!context || context->event_base == NULL ||
+
-        callback == NULL ||
+    /* request state */
-        context->resolution_type != GETDNS_CONTEXT_STUB) {
+    getdns_dns_req* req = dns_req_new(context,
+                                      unbound,
+                                      name,
+                                      request_type,
+                                      extensions);
+    if (!req) {
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+
+    req->user_pointer = userarg;
+    req->user_callback = callbackfn;
+
+    if (transaction_id) {
+        *transaction_id = req->trans_id;
+    }
+
+    getdns_context_track_outbound_request(req);
+
+    /* issue the first network req */
+    r = submit_network_request(req->first_req);
+
+    if (r != 0) {
+        /* clean up the request */
+        getdns_context_clear_outbound_request(req);
+        dns_req_free(req);
+        return GETDNS_RETURN_GENERIC_ERROR;
+    }
+    return GETDNS_RETURN_GOOD;
+}
+
+/*
+ * getdns_general
+ */
+ getdns_return_t
+ getdns_general(getdns_context_t context,
+                const char *name,
+                uint16_t request_type,
+                struct getdns_dict *extensions,
+                void *userarg,
+                getdns_transaction_t *transaction_id,
+                getdns_callback_t callback) {
+
+    if (!context || context->async_set == 0 ||
+        callback == NULL) {
         /* Can't do async without an event loop
          * or callback
-         *
-         * Only supports stub right now.
          */
         return GETDNS_RETURN_BAD_CONTEXT;
     }
 
+    return getdns_general_ub(context->unbound_async,
+                             context,
+                             name,
+                             request_type,
+                             extensions,
+                             userarg,
+                             transaction_id,
+                             callback);
 
-    /* create a req */
-    getdns_dns_req *dns_req = dns_req_new(context, name, request_type,
-                                          extensions, transaction_id);
-    if (dns_req == NULL) {
-        return GETDNS_RETURN_GENERIC_ERROR;
-    }
-    
-    dns_req->user_callback = callback;
-    dns_req->user_pointer = userarg;
-    
-    /* submit it */
-    submit_new_dns_req(dns_req);
-
-    return GETDNS_RETURN_GOOD;
 } /* getdns_general */
 
 
@@ -197,16 +249,13 @@ getdns_general(
  * getdns_address
  *
  */
-getdns_return_t
+ getdns_return_t
-getdns_address(
+ getdns_address(getdns_context_t context,
-  getdns_context_t           context,
                 const char *name,
                 struct getdns_dict *extensions,
                 void *userarg,
                 getdns_transaction_t *transaction_id,
-  getdns_callback_t          callback
+                getdns_callback_t callback) {
-)
-{
     int cleanup_extensions = 0;
     if (!extensions) {
         extensions = getdns_dict_create();

src/general.h

@@ -0,0 +1,49 @@
+/**
+ *
+ * /brief getdns contect management functions
+ *
+ * This is the meat of the API
+ * Originally taken from the getdns API description pseudo implementation.
+ *
+ */
+/* The MIT License (MIT)
+ * Copyright (c) 2013 Verisign, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef _GETDNS_GENERAL_H_
+#define _GETDNS_GENERAL_H_
+
+#include <getdns/getdns.h>
+
+struct ub_ctx;
+
+getdns_return_t
+getdns_general_ub(
+  struct ub_ctx*         unbound,
+  getdns_context_t       context,
+  const char             *name,
+  uint16_t               request_type,
+  struct getdns_dict     *extensions,
+  void                   *userarg,
+  getdns_transaction_t   *transaction_id,
+  getdns_callback_t      callbackfn
+);
+
+#endif

src/getdns/getdns.h

@@ -34,7 +34,8 @@
 #include <stdlib.h>
 #include <netinet/in.h>
 #include <stdbool.h>
-#include <event2/event.h>
+
+struct event_base;
 
 #define GETDNS_COMPILATION_COMMENT The API implementation should fill in something here, such as a compilation version string and date, and change it each time the API is compiled.
 
@@ -247,9 +248,42 @@
 #define GETDNS_STR_IPV6 "IPv6"
 #define GETDNS_STR_ADDRESS_TYPE "address_type"
 #define GETDNS_STR_ADDRESS_DATA "address_data"
+#define GETDNS_STR_ADDRESS_STRING "address_string"
 #define GETDNS_STR_PORT "port"
 #define GETDNS_STR_EXTENSION_RETURN_BOTH_V4_AND_V6 "return_both_v4_and_v6"
 
+#define GETDNS_STR_KEY_STATUS "status"
+#define GETDNS_STR_KEY_REPLIES_TREE "replies_tree"
+#define GETDNS_STR_KEY_REPLIES_FULL "replies_full"
+#define GETDNS_STR_KEY_JUST_ADDRS "just_address_answers"
+#define GETDNS_STR_KEY_CANONICAL_NM "canonical_name"
+#define GETDNS_STR_KEY_ANSWER_TYPE "answer_type"
+#define GETDNS_STR_KEY_INTERM_ALIASES "intermediate_aliases"
+#define GETDNS_STR_KEY_NAME "name"
+#define GETDNS_STR_KEY_HEADER "header"
+#define GETDNS_STR_KEY_QUESTION "question"
+#define GETDNS_STR_KEY_ANSWER "answer"
+#define GETDNS_STR_KEY_ID "id"
+#define GETDNS_STR_KEY_QR "qr"
+#define GETDNS_STR_KEY_OPC "opcode"
+#define GETDNS_STR_KEY_TYPE "type"
+#define GETDNS_STR_KEY_CLASS "class"
+#define GETDNS_STR_KEY_TTL "ttl"
+#define GETDNS_STR_KEY_RDATA "rdata"
+#define GETDNS_STR_KEY_V4_ADDR "ipv4_address"
+#define GETDNS_STR_KEY_V6_ADDR "ipv6_address"
+#define GETDNS_STR_KEY_RDATA_RAW "rdata_raw"
+#define GETDNS_STR_KEY_AUTHORITY "authority"
+#define GETDNS_STR_KEY_ADDITIONAL "additional"
+#define GETDNS_STR_KEY_QTYPE "qtype"
+#define GETDNS_STR_KEY_QCLASS "qclass"
+#define GETDNS_STR_KEY_QNAME "qname"
+
+
+
+
+
+
 /** @}
  */
 

src/list.c

@@ -214,6 +214,11 @@ getdns_list_copy(struct getdns_list *srclist, struct getdns_list **dstlist)
                         else
                             retval = GETDNS_RETURN_GENERIC_ERROR;
                     }
+                    else if (srclist->items[i].dtype == t_dict) 
+                    {
+                        retval = getdns_dict_copy(srclist->items[index].data.dict,
+                            &((*dstlist)->items[i].data.dict));
+                    }
                 }
                 else
                     retval = GETDNS_RETURN_GENERIC_ERROR;

src/request-internal.c

@@ -30,6 +30,7 @@
 
 #include "types-internal.h"
 #include "util-internal.h"
+#include <unbound.h>
 
 /* useful macros */
 #define gd_malloc(sz) context->memory_allocator(sz)
@@ -39,36 +40,33 @@ void network_req_free(getdns_network_req* net_req) {
     if (!net_req) {
         return;
     }
-    getdns_context_t context = net_req->context;
+    getdns_context_t context = net_req->owner->context;
-    if (net_req->pkt) {
+    if (net_req->result) {
-        ldns_pkt_free(net_req->pkt);
+        ldns_pkt_free(net_req->result);
     }
     gd_free(net_req);
 }
 
-getdns_network_req* network_req_new(getdns_context_t context,
+getdns_network_req* network_req_new(getdns_dns_req* owner,
-                                    const char* name,
                                     uint16_t request_type,
+                                    uint16_t request_class,
                                     struct getdns_dict* extensions) {
-    getdns_network_req *net_req = NULL;
+
-    ldns_pkt *pkt = NULL;
+    getdns_context_t context = owner->context;
-    net_req = gd_malloc(sizeof(getdns_network_req));
+    getdns_network_req* net_req = gd_malloc(sizeof(getdns_network_req));
     if (!net_req) {
         return NULL;
     }
-    net_req->ns = NULL;
+    net_req->result = NULL;
-    net_req->pkt = NULL;
+    net_req->next = NULL;
-    net_req->context = context;
-    net_req->request_type = request_type;
 
-    /* create ldns packet */
+    net_req->request_type = request_type;
-    pkt = create_new_pkt(context, name, request_type, extensions);
+    net_req->request_class = request_class;
-    if (!pkt) {
+    net_req->unbound_id = -1;
-        /* free up the req */
+    net_req->state = NET_REQ_NOT_SENT;
-        network_req_free(net_req);
+    net_req->owner = owner;
-        return NULL;
+
-    }
+    /* TODO: records and other extensions */
-    net_req->pkt = pkt;
 
     return net_req;
 }
@@ -77,43 +75,87 @@ void dns_req_free(getdns_dns_req* req) {
     if (!req) {
         return;
     }
+    getdns_network_req *net_req = NULL;
     getdns_context_t context = req->context;
-    network_req_free(req->current_req);
+
+    /* free network requests */
+    net_req = req->first_req;
+    while (net_req) {
+        getdns_network_req *next = net_req->next;
+        network_req_free(net_req);
+        net_req = next;
+    }
+
+    /* free strduped name */
+    free(req->name);
+
     gd_free(req);
 }
 
 /* create a new dns req to be submitted */
 getdns_dns_req* dns_req_new(getdns_context_t context,
+                            struct ub_ctx* unbound,
                             const char* name,
                             uint16_t request_type,
-                                   struct getdns_dict *extensions,
+                            struct getdns_dict *extensions) {
-                                   getdns_transaction_t *transaction_id) {
+
     getdns_dns_req *result = NULL;
-    getdns_network_req *net_req = NULL;
+    getdns_network_req *req = NULL;
+    getdns_return_t r;
+    uint32_t both = GETDNS_EXTENSION_FALSE;
+
     result = gd_malloc(sizeof(getdns_dns_req));
     if (result == NULL) {
         return NULL;
     }
+
+    result->name = strdup(name);
     result->context = context;
+    result->unbound = unbound;
+    result->canceled = 0;
     result->current_req = NULL;
-    result->pending_cb = 0;
+    result->first_req = NULL;
-    result->resolver_type = context->resolution_type;
+    result->trans_id = ldns_get_random();
 
-    /* create the initial network request */
+    getdns_dict_copy(extensions, &result->extensions);
-    net_req = network_req_new(context, name, request_type,
+
+    /* will be set by caller */
+    result->user_pointer = NULL;
+    result->user_callback = NULL;
+
+    /* create the requests */
+    req = network_req_new(result,
+                          request_type,
+                          LDNS_RR_CLASS_IN,
                           extensions);
-    if (!net_req) {
+    if (!req) {
         dns_req_free(result);
-        result = NULL;
+        return NULL;
     }
 
-    result->trans_id = ldns_pkt_id(net_req->pkt);
+    result->current_req = req;
-    if (transaction_id) {
+    result->first_req = req;
-        *transaction_id = result->trans_id;
-    }
 
-    result->current_req = net_req;
+    /* tack on A or AAAA if needed */
-    net_req->owner = result;
+    r = getdns_dict_get_int(extensions,
+                            GETDNS_STR_EXTENSION_RETURN_BOTH_V4_AND_V6,
+                            &both);
+    if (r == GETDNS_RETURN_GOOD &&
+        both == GETDNS_EXTENSION_TRUE &&
+        (request_type == GETDNS_RRTYPE_A || request_type == GETDNS_RRTYPE_AAAA)) {
+
+        uint16_t next_req_type = (request_type == GETDNS_RRTYPE_A) ? GETDNS_RRTYPE_AAAA : GETDNS_RRTYPE_A;
+        getdns_network_req* next_req =
+            network_req_new(result,
+                            next_req_type,
+                            LDNS_RR_CLASS_IN,
+                            extensions);
+        if (!next_req) {
+            dns_req_free(result);
+            return NULL;
+        }
+        req->next = next_req;
+    }
 
     return result;
 }

src/sync.c

@@ -29,7 +29,10 @@
 
 #include <getdns/getdns.h>
 #include <pthread.h>
-#include "types-internal.h"
+#include <event2/event.h>
+#include <unbound-event.h>
+#include "context.h"
+#include "general.h"
 
 /* stuff to make it compile pedantically */
 #define UNUSED_PARAM(x) ((void)(x))
@@ -55,10 +58,9 @@ static void sync_callback_func(getdns_context_t context,
 
 static void * request_thread_start(void *arg) {
     struct sync_request_data *req_data = arg;
-    struct event_base *event_base = event_base_new();
 
-    getdns_extension_set_libevent_base(req_data->context, event_base);
+    req_data->response_status = getdns_general_ub(req_data->context->unbound_sync,
-    req_data->response_status = getdns_general(req_data->context,
+                                                  req_data->context,
                                                   req_data->name,
                                                   req_data->request_type,
                                                   req_data->extensions,
@@ -66,7 +68,7 @@ static void * request_thread_start(void *arg) {
                                                   NULL,
                                                   sync_callback_func);
 
-    event_base_dispatch(event_base);
+    event_base_dispatch(req_data->context->event_base_sync);
     return NULL;
 }
 
@@ -82,8 +84,8 @@ getdns_general_sync(
 )
 {
     /* we will cheat and spawn a thread */
-    /* get the old event base */
+    /* set up for sync resolution */
-    struct event_base* orig_base = context->event_base;
+
     pthread_t thread;
     pthread_attr_t attr;
     sync_request_data req_data = {
@@ -111,9 +113,6 @@ getdns_general_sync(
         return GETDNS_RETURN_GENERIC_ERROR;
     }
 
-    /* set the old event loop */
-    getdns_extension_set_libevent_base(context, orig_base);
-    
     return req_data.response_status;
 }
 

src/test/tests_stub_async.c

@@ -31,6 +31,7 @@
 #include <string.h>
 #include "testmessages.h"
 #include <getdns/getdns.h>
+#include <event2/event.h>
 
 /* Set up the callback function, which will also do the processing of the results */
 void this_callbackfn(struct getdns_context_t *this_context,
@@ -41,14 +42,10 @@ void this_callbackfn(struct getdns_context_t *this_context,
 {
 	if (this_callback_type == GETDNS_CALLBACK_COMPLETE)  /* This is a callback with data */
 	{
-        getdns_bindata* bindata = NULL;
+        char* res = getdns_pretty_print_dict(this_response);
-        getdns_dict_get_bindata(this_response, "pkt", &bindata);
+        fprintf(stdout, "%s", res);
-        if (bindata) {
+        getdns_dict_destroy(this_response);
-            char* data = (char*) bindata->data;
+
-            data[bindata->size] = 0;
-            memcpy(data, bindata->data, bindata->size);
-            fprintf(stdout, "The packet %s\n", data);
-        }
 	}
 	else if (this_callback_type == GETDNS_CALLBACK_CANCEL)
 		fprintf(stderr, "The callback with ID %lld was cancelled. Exiting.", this_transaction_id);
@@ -90,13 +87,13 @@ main()
 		fprintf(stderr, "A bad domain name was used: %s. Exiting.", this_name);
 		return(GETDNS_RETURN_GENERIC_ERROR);
 	}
-    dns_request_return = getdns_service(this_context, this_name, NULL, this_userarg, &this_transaction_id,
+//    dns_request_return = getdns_service(this_context, this_name, NULL, this_userarg, &this_transaction_id,
-                                        this_callbackfn);
+//                                        this_callbackfn);
-    if (dns_request_return == GETDNS_RETURN_BAD_DOMAIN_NAME)
+//    if (dns_request_return == GETDNS_RETURN_BAD_DOMAIN_NAME)
-	{
+//	{
-		fprintf(stderr, "A bad domain name was used: %s. Exiting.", this_name);
+//		fprintf(stderr, "A bad domain name was used: %s. Exiting.", this_name);
-		return(GETDNS_RETURN_GENERIC_ERROR);
+//		return(GETDNS_RETURN_GENERIC_ERROR);
-	}
+//	}
 	else
 	{
 		/* Call the event loop */

src/types-internal.h

@@ -36,75 +36,72 @@
 
 /* declarations */
 struct getdns_dns_req;
-struct getdns_nameserver;
 struct getdns_network_req;
+struct ub_ctx;
 
-typedef struct getdns_nameserver {
+typedef enum network_req_state_enum {
-	evutil_socket_t socket;	 /* a connected UDP socket */
+    NET_REQ_NOT_SENT,
-	struct sockaddr_storage address;
+    NET_REQ_IN_FLIGHT,
-	ev_socklen_t addrlen;
+    NET_REQ_FINISHED,
+    NET_REQ_CANCELED
+} network_req_state;
 
-	int failed_times;  /* number of times which we have given this server a chance */
+/**
-	int timedout;  /* number of times in a row a request has timed out */
+ * Request data for unbound
-	
+ **/
-    struct event* event;
-    
-    /* when we next probe this server. */
-    /* Valid if state == 0 */
-	/* Outstanding probe request for this nameserver, if any */
-	struct getdns_dns_req *probe_request;
-	char state;  /* zero if we think that this server is down */
-	char choked;  /* true if we have an EAGAIN from this server's socket */
-	char write_waiting;  /* true if we are waiting for EV_WRITE events */
-	
-    /* getdns context */
-    getdns_context_t context;
-    
-	/* Number of currently inflight requests: used
-	 * to track when we should add/del the event. */
-	int requests_inflight;
-} getdns_nameserver;
-
-/* network request - state for a single network request and referenced
- * by the the outbound_req
- */
 typedef struct getdns_network_req {
-	ldns_pkt *pkt;  /* the dns packet data */
+	/* the async_id from unbound */
-	uint16_t request_type; /* query type */
+    int unbound_id;
+    /* state var */
+    network_req_state state;
+    /* owner request (contains name) */
+    struct getdns_dns_req* owner;
 
-	int reissue_count;
+    /* request type */
-	int tx_count;  /* the number of times that this packet has been sent */
+    uint16_t request_type;
 
-    /* not owned */
+    /* request class */
-    getdns_nameserver *ns;	/* the server which we sent to */
+    uint16_t request_class;
 
-	unsigned transmit_me :1;  /* needs to be transmitted */
+    /* result */
-    
+    ldns_pkt* result;
-	getdns_context_t context;
-    
-	struct getdns_dns_req *owner;
 
+    /* next request to issue after this one */
+    struct getdns_network_req* next;
 } getdns_network_req;
 
-/* outbound request - manages recursion and stub reqs */
+/* dns request - manages a number of network requests and
+ * the initial data passed to getdns_general
+ */
 typedef struct getdns_dns_req {
 
+    /* name */
+    char *name;
+
+    /* canceled flag */
+    int canceled;
+
+    /* current network request */
 	struct getdns_network_req *current_req;
+
+    /* first request in list */
+    struct getdns_network_req *first_req;
+
+    /* context that owns the request */
     getdns_context_t context;
 
-    uint16_t resolver_type;
+    /* ub_ctx issuing the request */
+    struct ub_ctx* unbound;
+
+    /* request extensions */
+    getdns_dict *extensions;
 
     /* callback data */
     getdns_callback_t user_callback;
     void *user_pointer;
 
-    getdns_transaction_t trans_id;  /* the transaction id */
+    /* the transaction id */
-	
+    getdns_transaction_t trans_id;
-    
-	int pending_cb; /* Waiting for its callback to be invoked; not
-                     * owned by event base any more. */
-    
-	/* search not supported.. yet */
 
 } getdns_dns_req;
 
@@ -113,29 +110,20 @@ typedef struct getdns_dns_req {
 /* network request utilities */
 void network_req_free(getdns_network_req* net_req);
 
-getdns_network_req* network_req_new(getdns_context_t context,
+getdns_network_req* network_req_new(getdns_dns_req* owner,
-                                    const char* name,
                                     uint16_t request_type,
+                                    uint16_t request_class,
                                     struct getdns_dict* extensions);
 
 
 /* dns request utils */
 getdns_dns_req* dns_req_new(getdns_context_t context,
+                            struct ub_ctx* unbound,
                             const char* name,
                             uint16_t request_type,
-                            struct getdns_dict *extensions,
+                            struct getdns_dict *extensions);
-                            getdns_transaction_t *transaction_id);
 
 
 void dns_req_free(getdns_dns_req* req);
 
-/* nameserver utils */
-getdns_nameserver* nameserver_new_from_ip_dict(getdns_context_t context,
-                                               getdns_dict* ip_dict);
-
-void nameserver_free(getdns_nameserver* nameserver);
-
-getdns_dict* nameserver_to_dict(getdns_nameserver* nameserver);
-
-
 #endif

src/util-internal.c

@@ -29,10 +29,14 @@
  */
 
 #include "util-internal.h"
+#include "types-internal.h"
 
 getdns_return_t getdns_dict_util_set_string(getdns_dict* dict, char* name,
-                                            char* value) {
+                                            const char* value) {
     /* account for the null term */
+    if (value == NULL) {
+        return GETDNS_RETURN_WRONG_TYPE_REQUESTED;
+    }
     getdns_bindata type_bin = { strlen(value) + 1, (uint8_t*) value };
     return getdns_dict_set_bindata(dict, name, &type_bin);
 }
@@ -113,35 +117,336 @@ getdns_return_t sockaddr_to_dict(struct sockaddr_storage* address, getdns_dict**
     return GETDNS_RETURN_GOOD;
 }
 
-/* TODO: flags */
+/* result must be freed */
-ldns_pkt *create_new_pkt(getdns_context_t context,
+static char* convert_rdf_to_str(ldns_rdf* rdf) {
-                         const char* name,
+    if (ldns_rdf_get_type(rdf) == LDNS_RDF_TYPE_DNAME) {
-                         uint16_t request_type,
+        ldns_dname2canonical(rdf);
-                         struct getdns_dict* extensions) {
-    ldns_pkt *pkt = NULL;
-    ldns_rr_type type = (ldns_rr_type) request_type;
-    uint16_t flags = 0;
-    if (context->resolution_type == GETDNS_CONTEXT_STUB) {
-        flags |= LDNS_RD;
     }
-    ldns_pkt_query_new_frm_str(&pkt, name,
+    return ldns_rdf2str(rdf);
-                               type,
-                               LDNS_RR_CLASS_IN, flags);
-    if (pkt) {
-        /* id */
-        ldns_pkt_set_id(pkt, ldns_get_random());
-    }
-    return pkt;
 }
 
-getdns_dict *create_getdns_response(ldns_pkt* pkt) {
+/* create the header dict */
-    char* data = ldns_pkt2str(pkt);
+static getdns_dict *create_reply_header_dict(ldns_pkt* reply) {
+    /* { "id": 23456, "qr": 1, "opcode": 0, ... }, */
+    int r = 0;
     getdns_dict* result = getdns_dict_create();
-    getdns_bindata bindata = {
+    if (!result) {
-        strlen(data), (uint8_t*) data
+        return NULL;
-    };
+    }
-    getdns_dict_set_bindata(result, "pkt", &bindata);
+    /* cheat since we know GETDNS_RETURN_GOOD == 0 */
-    free(data);
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_ID, ldns_pkt_id(reply));
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_QR, ldns_pkt_qr(reply));
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_OPC, (int) ldns_pkt_get_opcode(reply));
+
+    if (r != 0) {
+        getdns_dict_destroy(result);
+        result = NULL;
+    }
+    return result;
+}
+
+static getdns_dict *create_reply_question_dict(ldns_pkt* reply) {
+    /* { "qname": <bindata for "www.example.com">, "qtype": 1, "qclass": 1 } */
+    int r = 0;
+    ldns_rr *question = NULL;
+    char* qname;
+    getdns_dict* result = getdns_dict_create();
+    if (!result) {
+        return NULL;
+    }
+    question = ldns_rr_list_rr(ldns_pkt_question(reply), 0);
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_QTYPE, (int) ldns_rr_get_type(question));
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_QCLASS, (int) ldns_rr_get_class(question));
+    qname = convert_rdf_to_str(ldns_rr_owner(question));
+    if (qname) {
+        r |= getdns_dict_util_set_string(result, GETDNS_STR_KEY_QNAME, qname);
+        free(qname);
+    } else {
+        r = 1;
+    }
+    if (r != 0) {
+        getdns_dict_destroy(result);
+        result = NULL;
+    }
+    return result;
+}
+
+static getdns_dict *create_dict_from_rdf(ldns_rdf* rdf) {
+    /*
+    create a dict w/ rdata_raw and special fields if needed
+    i.e.
+    {
+      "ipv4_address": <bindata of 0x0a0b0c01>
+      "rdata_raw": <bindata of 0x0a0b0c01>
+    }
+    */
+    int r = 0;
+    getdns_bindata rbin = { ldns_rdf_size(rdf), ldns_rdf_data(rdf) };
+    getdns_dict* result = getdns_dict_create();
+    r |= getdns_dict_set_bindata(result, GETDNS_STR_KEY_RDATA_RAW, &rbin);
+    if (ldns_rdf_get_type(rdf) == LDNS_RDF_TYPE_AAAA) {
+        r |= getdns_dict_set_bindata(result, GETDNS_STR_KEY_V6_ADDR, &rbin);
+    } else if (ldns_rdf_get_type(rdf) == LDNS_RDF_TYPE_A) {
+        r |= getdns_dict_set_bindata(result, GETDNS_STR_KEY_V4_ADDR, &rbin);
+    }
+    if (r != 0) {
+        getdns_dict_destroy(result);
+        result = NULL;
+    }
+    return result;
+}
+
+static getdns_dict *create_dict_from_rr(ldns_rr* rr) {
+    /*
+    {
+      "name": <bindata for "www.example.com">,
+      "type": 1,
+      "class": 1,
+      "ttl": 33000,
+      "rdata":
+      {
+        "ipv4_address": <bindata of 0x0a0b0c01>
+        "rdata_raw": <bindata of 0x0a0b0c01>
+      }
+    }
+    */
+    int r = 0;
+    char * name = NULL;
+    getdns_dict *result = getdns_dict_create();
+    size_t rd_count = ldns_rr_rd_count(rr);
+    ldns_rdf* owner = ldns_rr_owner(rr);
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_TYPE, (int) ldns_rr_get_type(rr));
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_CLASS, (int) ldns_rr_get_class(rr));
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_TTL, ldns_rr_ttl(rr));
+    if (owner) {
+        name = convert_rdf_to_str(owner);
+        if (name) {
+            r |= getdns_dict_util_set_string(result, GETDNS_STR_KEY_NAME, name);
+            free(name);
+        } else {
+            r = 1;
+        }
+    }
+    /* create rdatas */
+    if (rd_count >= 1) {
+        getdns_dict* rdata = create_dict_from_rdf(ldns_rr_rdf(rr, 0));
+        r |= getdns_dict_set_dict(result, GETDNS_STR_KEY_RDATA, rdata);
+    }
+    /* TODO - if more than one, is rdata a list? */
+
+    if (r != 0) {
+        getdns_dict_destroy(result);
+        result = NULL;
+    }
+    return result;
+}
+
+/* helper to convert an rr_list to getdns_list.
+   returns a list of objects where each object
+   is a result from create_dict_from_rr */
+static getdns_list *create_list_from_rr_list(ldns_rr_list* rr_list) {
+    size_t i = 0;
+    size_t idx = 0;
+    int r = 0;
+    getdns_list *result = getdns_list_create();
+    for (i = 0; i < ldns_rr_list_rr_count(rr_list); ++i) {
+        ldns_rr *rr = ldns_rr_list_rr(rr_list, i);
+        r |= getdns_list_add_item(result, &idx);
+        r |= getdns_list_set_dict(result, idx, create_dict_from_rr(rr));
+    }
+    if (r != 0) {
+        getdns_list_destroy(result);
+        result = NULL;
+    }
+    return result;
+}
+
+/* helper to add the ipv4 or ipv6 bin data to the list of addrs */
+static getdns_return_t add_only_addresses(getdns_list* addrs, ldns_rr_list* rr_list) {
+    int r = 0;
+    size_t i = 0;
+    for (i = 0; i < ldns_rr_list_rr_count(rr_list); ++i) {
+        ldns_rr *rr = ldns_rr_list_rr(rr_list, i);
+        size_t j = 0;
+        size_t rd_count = ldns_rr_rd_count(rr);
+        for (j = 0; j < rd_count; ++j) {
+            size_t item_idx = 0;
+            ldns_rdf* rdf = ldns_rr_rdf(rr, j);
+            getdns_bindata rbin = { ldns_rdf_size(rdf), ldns_rdf_data(rdf) };
+            r |= getdns_list_add_item(addrs, &item_idx);
+            r |= getdns_list_set_bindata(addrs, item_idx, &rbin);
+        }
+    }
+    return r;
+}
+
+static getdns_dict *create_reply_dict(getdns_network_req* req,
+                                      getdns_list *just_addrs) {
+    /* turn a packet into this glorious structure
+
+    {     # This is the first reply
+      "header": { "id": 23456, "qr": 1, "opcode": 0, ... },
+      "question": { "qname": <bindata for "www.example.com">, "qtype": 1, "qclass": 1 },
+      "answer":
+      [
+        {
+          "name": <bindata for "www.example.com">,
+          "type": 1,
+          "class": 1,
+          "ttl": 33000,
+          "rdata":
+          {
+            "ipv4_address": <bindata of 0x0a0b0c01>
+            "rdata_raw": <bindata of 0x0a0b0c01>
+          }
+        }
+      ],
+      "authority":
+      [
+        {
+          "name": <bindata for "ns1.example.com">,
+          "type": 1,
+          "class": 1,
+          "ttl": 600,
+          "rdata":
+          {
+            "ipv4_address": <bindata of 0x65439876>
+            "rdata_raw": <bindata of 0x65439876>
+          }
+        }
+      ]
+      "additional": [],
+      "canonical_name": <bindata for "www.example.com">,
+      "answer_type": GETDNS_NAMETYPE_DNS
+    }
+
+    */
+    int r = 0;
+    ldns_pkt *reply = req->result;
+    ldns_rr_list *rr_list = NULL;
+    ldns_rr* question = NULL;
+    getdns_dict *subdict = NULL;
+    getdns_list *sublist = NULL;
+    char* name = NULL;
+
+    getdns_dict *result = getdns_dict_create();
+    if (!result) {
+        return NULL;
+    }
+    /* header */
+    subdict = create_reply_header_dict(reply);
+    r |= getdns_dict_set_dict(result, GETDNS_STR_KEY_HEADER, subdict);
+    getdns_dict_destroy(subdict);
+
+    /* question */
+    subdict = create_reply_question_dict(reply);
+    r |= getdns_dict_set_dict(result, GETDNS_STR_KEY_QUESTION, subdict);
+    getdns_dict_destroy(subdict);
+
+    /* answers */
+    rr_list = ldns_pkt_answer(reply);
+    sublist = create_list_from_rr_list(rr_list);
+    r |= getdns_dict_set_list(result, GETDNS_STR_KEY_ANSWER, sublist);
+    getdns_list_destroy(sublist);
+    if ((req->request_type == GETDNS_RRTYPE_A ||
+        req->request_type == GETDNS_RRTYPE_AAAA) &&
+        just_addrs != NULL) {
+        /* add to just addrs */
+        r |= add_only_addresses(just_addrs, rr_list);
+    }
+
+    /* authority */
+    rr_list = ldns_pkt_authority(reply);
+    sublist = create_list_from_rr_list(rr_list);
+    r |= getdns_dict_set_list(result, GETDNS_STR_KEY_AUTHORITY, sublist);
+    getdns_list_destroy(sublist);
+
+    /* additional */
+    rr_list = ldns_pkt_additional(reply);
+    sublist = create_list_from_rr_list(rr_list);
+    r |= getdns_dict_set_list(result, GETDNS_STR_KEY_ADDITIONAL, sublist);
+    getdns_list_destroy(sublist);
+
+    /* other stuff */
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_ANSWER_TYPE, GETDNS_NAMETYPE_DNS);
+    question = ldns_rr_list_rr(ldns_pkt_question(reply), 0);
+    name = convert_rdf_to_str(ldns_rr_owner(question));
+    if (name) {
+        r |= getdns_dict_util_set_string(result, GETDNS_STR_KEY_CANONICAL_NM, name);
+        free(name);
+    } else {
+        r |= 1;
+    }
+    if (r != 0) {
+        getdns_dict_destroy(result);
+        result = NULL;
+    }
+    return result;
+}
+
+static char* get_canonical_name(const char* name) {
+    ldns_rdf* rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, name);
+    if (!rdf) {
+        return NULL;
+    }
+    char* result = convert_rdf_to_str(rdf);
+    ldns_rdf_free(rdf);
+    return result;
+}
+
+getdns_dict *create_getdns_response(struct getdns_dns_req* completed_request) {
+    getdns_dict* result = getdns_dict_create();
+    getdns_list* replies_full = getdns_list_create();
+    getdns_list* just_addrs = NULL;
+    getdns_list* replies_tree = getdns_list_create();
+    getdns_network_req *netreq = completed_request->first_req;
+
+
+    int r = 0;
+
+    if (completed_request->first_req->request_class == GETDNS_RRTYPE_A ||
+        completed_request->first_req->request_class ==  GETDNS_RRTYPE_AAAA) {
+        just_addrs = getdns_list_create();
+    }
+
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_STATUS, GETDNS_RESPSTATUS_GOOD);
+    r |= getdns_dict_util_set_string(result, GETDNS_STR_KEY_CANONICAL_NM, get_canonical_name(completed_request->name));
+    r |= getdns_dict_set_int(result, GETDNS_STR_KEY_ANSWER_TYPE, GETDNS_NAMETYPE_DNS);
+
+    while (netreq) {
+        getdns_bindata full_data;
+        full_data.data = NULL;
+        full_data.size = 0;
+        ldns_pkt *pkt = netreq->result;
+        ldns_status s = ldns_pkt2wire(&(full_data.data), pkt, &(full_data.size));
+        size_t idx = 0;
+        /* reply tree */
+        getdns_dict *reply = create_reply_dict(netreq, just_addrs);
+        r |= getdns_list_add_item(replies_tree, &idx);
+        r |= getdns_list_set_dict(replies_tree, idx, reply);
+        /* buffer */
+        if (s == LDNS_STATUS_OK) {
+            r |= getdns_list_add_item(replies_full, &idx);
+            r |= getdns_list_set_bindata(replies_full, idx, &full_data);
+            free(full_data.data);
+        } else {
+            r = 1;
+            break;
+        }
+        netreq = netreq->next;
+    }
+
+    r |= getdns_dict_set_list(result, GETDNS_STR_KEY_REPLIES_TREE, replies_tree);
+    r |= getdns_dict_set_list(result, GETDNS_STR_KEY_REPLIES_FULL, replies_full);
+    if (just_addrs) {
+        r |= getdns_dict_set_list(result, GETDNS_STR_KEY_JUST_ADDRS, just_addrs);
+    }
+
+    if (r != 0) {
+        getdns_dict_destroy(result);
+        result = NULL;
+    }
+
     return result;
 }
 

src/util-internal.h

@@ -28,24 +28,25 @@
  * THE SOFTWARE.
  */
 
+/*
 #include "types-internal.h"
+*/
+
+#include <ldns/ldns.h>
+#include "context.h"
+
+struct getdns_dns_req;
 
 /* convert an ip address dict to a sock storage */
 getdns_return_t dict_to_sockaddr(getdns_dict* ns, struct sockaddr_storage* output);
 getdns_return_t sockaddr_to_dict(struct sockaddr_storage* sockaddr, getdns_dict** output);
 
-/* create a dns packet for the given request type and extensions */
+getdns_dict *create_getdns_response(struct getdns_dns_req* completed_request);
-ldns_pkt *create_new_pkt(getdns_context_t context,
-                         const char* name,
-                         uint16_t request_type,
-                         struct getdns_dict* extensions);
-
-getdns_dict *create_getdns_response(ldns_pkt* pkt);
 
 /* dict util */
 /* set a string as bindata */
 getdns_return_t getdns_dict_util_set_string(getdns_dict* dict, char* name,
-                                            char* value);
+                                            const char* value);
 
 /* get a string from a dict.  result is valid as long as dict is valid */
 getdns_return_t getdns_dict_util_get_string(getdns_dict* dict, char* name,

unbound.2985.patch

@@ -0,0 +1,118 @@
+Index: Makefile.in
+===================================================================
+--- Makefile.in	(revision 2985)
++++ Makefile.in	(working copy)
+@@ -280,7 +280,7 @@
+ longtest:	tests
+ 	if test -x "`which bash`"; then bash testcode/do-tests.sh; else sh testcode/do-tests.sh; fi
+ 
+-lib:	libunbound.la unbound.h
++lib:	libunbound.la unbound.h unbound-event.h
+ 
+ libunbound.la:	$(LIBUNBOUND_OBJ_LINK)
+ 	$(LINK_LIB) $(UBSYMS) -o $@ $(LIBUNBOUND_OBJ_LINK) -rpath $(libdir) -lssl $(LIBS)
+@@ -348,6 +348,9 @@
+ unbound.h:	$(srcdir)/libunbound/unbound.h
+ 	sed -e 's/@''UNBOUND_VERSION_MAJOR@/$(UNBOUND_VERSION_MAJOR)/' -e 's/@''UNBOUND_VERSION_MINOR@/$(UNBOUND_VERSION_MINOR)/' -e 's/@''UNBOUND_VERSION_MICRO@/$(UNBOUND_VERSION_MICRO)/' < $(srcdir)/libunbound/unbound.h > $@
+ 
++unbound-event.h: $(srcdir)/libunbound/unbound-event.h
++	sed -e 's/@''UNBOUND_VERSION_MAJOR@/$(UNBOUND_VERSION_MAJOR)/' -e 's/@''UNBOUND_VERSION_MINOR@/$(UNBOUND_VERSION_MINOR)/' -e 's/@''UNBOUND_VERSION_MICRO@/$(UNBOUND_VERSION_MICRO)/' < $(srcdir)/libunbound/unbound-event.h > $@
++
+ unbound-control-setup:	$(srcdir)/smallapp/unbound-control-setup.sh
+ 	sed -e 's:^DESTDIR=.*$$:DESTDIR=$(UNBOUND_RUN_DIR):' < $(srcdir)/smallapp/unbound-control-setup.sh > $@
+ 	-chmod +x $@
+@@ -496,6 +499,7 @@
+ 	$(INSTALL) -c -m 755 unbound-control-setup $(DESTDIR)$(sbindir)/unbound-control-setup
+ 	if test ! -e $(DESTDIR)$(configfile); then $(INSTALL) -d `dirname $(DESTDIR)$(configfile)`; $(INSTALL) -c -m 644 doc/example.conf $(DESTDIR)$(configfile); fi
+ 	$(LIBTOOL) --mode=install cp unbound.h $(DESTDIR)$(includedir)/unbound.h
++	$(LIBTOOL) --mode=install cp unbound-event.h $(DESTDIR)$(includedir)/unbound-event.h
+ 	$(LIBTOOL) --mode=install cp libunbound.la $(DESTDIR)$(libdir)
+ 	$(LIBTOOL) --mode=finish $(DESTDIR)$(libdir)
+ 
+Index: libunbound/ubsyms.def
+===================================================================
+--- libunbound/ubsyms.def	(revision 2985)
++++ libunbound/ubsyms.def	(working copy)
+@@ -29,3 +29,4 @@
+ ub_ctx_data_add
+ ub_ctx_data_remove
+ ub_version
++ub_ctx_set_event
+Index: libunbound/unbound-event.h
+===================================================================
+--- libunbound/unbound-event.h	(revision 2985)
++++ libunbound/unbound-event.h	(working copy)
+@@ -63,9 +63,9 @@
+ struct ub_ctx;
+ struct ub_result;
+ struct event_base;
+-struct ldns_buffer;
++struct ldns_struct_buffer;
+ 
+-typedef void (*ub_event_callback_t)(void*, int, struct ldns_buffer*, int, char*);
++typedef void (*ub_event_callback_t)(void*, int, struct ldns_struct_buffer*, int, char*);
+ 
+ /**
+  * Create a resolving and validation context.
+@@ -82,6 +82,15 @@
+ struct ub_ctx* ub_ctx_create_event(struct event_base* base);
+ 
+ /**
++ * Set a new event_base on a context created with ub_ctx_create_event.
++ * Any outbound queries will be canceled.
++ * @param ctx the ub_ctx to update.  Must have been created with ub_ctx_create_event
++ * @param base the new event_base to attach to the ctx
++ * @return 0 if OK, else error
++ */
++int ub_ctx_set_event(struct ub_ctx* ctx, struct event_base* base); 
++
++/**
+  * Perform resolution and validation of the target name.
+  * Asynchronous, after a while, the callback will be called with your
+  * data and the result.  Uses the event_base user installed by creating the
+Index: libunbound/libunbound.c
+===================================================================
+--- libunbound/libunbound.c	(revision 2985)
++++ libunbound/libunbound.c	(working copy)
+@@ -656,15 +656,14 @@
+ 			return r;
+ 		}
+ 	}
++	lock_basic_unlock(&ctx->cfglock);
+ 	if(!ctx->event_worker) {
+ 		ctx->event_worker = libworker_create_event(ctx,
+ 			ctx->event_base);
+ 		if(!ctx->event_worker) {
+-			lock_basic_unlock(&ctx->cfglock);
+ 			return UB_INITFAIL;
+ 		}
+ 	}
+-	lock_basic_unlock(&ctx->cfglock);
+ 
+ 	/* create new ctx_query and attempt to add to the list */
+ 	q = context_new(ctx, name, rrtype, rrclass, (ub_callback_t)callback,
+@@ -1212,3 +1211,24 @@
+ {
+ 	return PACKAGE_VERSION;
+ }
++
++int 
++ub_ctx_set_event(struct ub_ctx* ctx, struct event_base* base) {
++	if (!ctx || !ctx->event_base || !base) {
++		return UB_INITFAIL;
++	}
++	if (ctx->event_base == base) {
++		/* already set */
++		return UB_NOERROR;
++	}
++	
++	lock_basic_lock(&ctx->cfglock);
++	/* destroy the current worker - safe to pass in NULL */
++	libworker_delete_event(ctx->event_worker);
++	ctx->event_worker = NULL;
++	ctx->event_base = base;	
++	ctx->created_bg = 0;
++	ctx->dothread = 1;
++	lock_basic_unlock(&ctx->cfglock);
++	return UB_NOERROR;
++}