X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fdns%2Fdns_api.c;h=a280265da0d588297b83676b17caec384babb5ce;hb=2156a54c589c358442a366e00f3aeb9de6d89af0;hp=b434fc1e7247725158bd401d7791ef06e337f301;hpb=8025ab3ecdbaf1d0e5128bb21a443545848139ae;p=oweals%2Fgnunet.git diff --git a/src/dns/dns_api.c b/src/dns/dns_api.c index b434fc1e7..a280265da 100644 --- a/src/dns/dns_api.c +++ b/src/dns/dns_api.c @@ -1,342 +1,522 @@ /* - This file is part of GNUnet. - (C) 2010 Christian Grothoff - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ + This file is part of GNUnet + (C) 2012 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + */ /** * @file dns/dns_api.c - * @brief - * @author Philipp Toelke + * @brief API to access the DNS service. + * @author Christian Grothoff */ -#include -#include -#include -#include -#include -#include -#include -#include -#include - +#include "platform.h" #include "gnunet_dns_service.h" #include "dns.h" -struct query_packet_list + +/** + * Reply to send to service. + */ +struct ReplyQueueEntry { - struct query_packet_list *next; - struct query_packet_list *prev; - struct query_packet pkt; + /** + * Kept in DLL. + */ + struct ReplyQueueEntry *next; + + /** + * Kept in DLL. + */ + struct ReplyQueueEntry *prev; + + /** + * Message to transmit, allocated at the end of this struct. + */ + const struct GNUNET_MessageHeader *msg; + }; +/** + * Handle to identify an individual DNS request. + */ +struct GNUNET_DNS_RequestHandle +{ + + /** + * Handle to DNS API. + */ + struct GNUNET_DNS_Handle *dh; + + /** + * Stored in network byte order (as for us, it is just a random number). + */ + uint64_t request_id; + + /** + * Re-connect counter, to make sure we did not reconnect in the meantime. + */ + uint32_t generation; + +}; + + +/** + * DNS handle + */ struct GNUNET_DNS_Handle { - struct query_packet_list *head; - struct query_packet_list *tail; + + /** + * Connection to DNS service, or NULL. + */ struct GNUNET_CLIENT_Connection *dns_connection; - unsigned char restart_hijack; + /** + * Handle to active transmission request, or NULL. + */ struct GNUNET_CLIENT_TransmitHandle *dns_transmit_handle; + /** + * Configuration to use. + */ const struct GNUNET_CONFIGURATION_Handle *cfg; - GNUNET_DNS_ResponseCallback process_answer_cb; + /** + * Function to call to get replies. + */ + GNUNET_DNS_RequestHandler rh; - void *process_answer_cb_cls; -}; + /** + * Closure for 'rh'. + */ + void *rh_cls; + /** + * Head of replies to transmit. + */ + struct ReplyQueueEntry *rq_head; -/** - * Callback called by notify_transmit_ready; sends dns-queries or rehijack-messages - * to the service-dns - * {{{ - */ -size_t -send_query (void *cls GNUNET_UNUSED, size_t size, void *buf) -{ - struct GNUNET_DNS_Handle *h = cls; + /** + * Tail of replies to transmit. + */ + struct ReplyQueueEntry *rq_tail; - size_t len; + /** + * Task to reconnect to the service. + */ + GNUNET_SCHEDULER_TaskIdentifier reconnect_task; - h->dns_transmit_handle = NULL; + /** + * Re-connect counter, to make sure we did not reconnect in the meantime. + */ + uint32_t generation; + + /** + * Flags for events we care about. + */ + enum GNUNET_DNS_Flags flags; - /* - * Send the rehijack-message + /** + * Did we start the receive loop yet? */ - if (h->restart_hijack == 1) - { - h->restart_hijack = 0; - /* - * The message is just a header - */ - GNUNET_assert (sizeof (struct GNUNET_MessageHeader) <= size); - struct GNUNET_MessageHeader *hdr = buf; - - len = sizeof (struct GNUNET_MessageHeader); - hdr->size = htons (len); - hdr->type = htons (GNUNET_MESSAGE_TYPE_REHIJACK); - } - else if (h->head != NULL) - { - struct query_packet_list *query = h->head; + int in_receive; + + /** + * Number of GNUNET_DNS_RequestHandles we have outstanding. Must be 0 before + * we can be disconnected. + */ + unsigned int pending_requests; +}; - len = ntohs (query->pkt.hdr.size); - GNUNET_assert (len <= size); +/** + * Add the given reply to our transmission queue and trigger sending if needed. + * + * @param dh handle with the connection + * @param qe reply to queue + */ +static void +queue_reply (struct GNUNET_DNS_Handle *dh, + struct ReplyQueueEntry *qe); - memcpy (buf, &query->pkt.hdr, len); - GNUNET_CONTAINER_DLL_remove (h->head, h->tail, query); +/** + * Reconnect to the DNS service. + * + * @param cls handle with the connection to connect + * @param tc scheduler context (unused) + */ +static void +reconnect (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct GNUNET_DNS_Handle *dh = cls; + struct ReplyQueueEntry *qe; + struct GNUNET_DNS_Register *msg; - GNUNET_free (query); - } - else + dh->reconnect_task = GNUNET_SCHEDULER_NO_TASK; + dh->dns_connection = GNUNET_CLIENT_connect ("dns", dh->cfg); + if (NULL == dh->dns_connection) + return; + dh->generation++; + qe = GNUNET_malloc (sizeof (struct ReplyQueueEntry) + + sizeof (struct GNUNET_DNS_Register)); + msg = (struct GNUNET_DNS_Register*) &qe[1]; + qe->msg = &msg->header; + msg->header.size = htons (sizeof (struct GNUNET_DNS_Register)); + msg->header.type = htons (GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT); + msg->flags = htonl (dh->flags); + queue_reply (dh, qe); +} + + +/** + * Disconnect from the DNS service. + * + * @param dh handle with the connection to disconnect + */ +static void +disconnect (struct GNUNET_DNS_Handle *dh) +{ + struct ReplyQueueEntry *qe; + + if (NULL != dh->dns_transmit_handle) { - GNUNET_break (0); - len = 0; + GNUNET_CLIENT_notify_transmit_ready_cancel (dh->dns_transmit_handle); + dh->dns_transmit_handle = NULL; } - - /* - * Check whether more data is to be sent - */ - if (h->head != NULL) + if (NULL != dh->dns_connection) { - h->dns_transmit_handle = - GNUNET_CLIENT_notify_transmit_ready (h->dns_connection, - ntohs (h->head->pkt.hdr.size), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &send_query, h); + GNUNET_CLIENT_disconnect (dh->dns_connection, GNUNET_NO); + dh->dns_connection = NULL; } - else if (h->restart_hijack == 1) + while (NULL != (qe = dh->rq_head)) { - h->dns_transmit_handle = - GNUNET_CLIENT_notify_transmit_ready (h->dns_connection, - sizeof (struct - GNUNET_MessageHeader), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &send_query, h); + GNUNET_CONTAINER_DLL_remove (dh->rq_head, + dh->rq_tail, + qe); + GNUNET_free (qe); } - - return len; + dh->in_receive = GNUNET_NO; } -/* }}} */ - - /** - * This receives packets from the service-dns and schedules process_answer to - * handle it + * This receives packets from the DNS service and calls the application to + * handle it. + * + * @param cls the struct GNUNET_DNS_Handle + * @param msg message from the service (request) */ static void -dns_answer_handler (void *cls, - const struct GNUNET_MessageHeader *msg) +request_handler (void *cls, + const struct GNUNET_MessageHeader *msg) { - struct GNUNET_DNS_Handle *h = cls; + struct GNUNET_DNS_Handle *dh = cls; + const struct GNUNET_DNS_Request *req; + struct GNUNET_DNS_RequestHandle *rh; + size_t payload_length; /* the service disconnected, reconnect after short wait */ if (msg == NULL) { - if (h->dns_transmit_handle != NULL) - GNUNET_CLIENT_notify_transmit_ready_cancel (h->dns_transmit_handle); - h->dns_transmit_handle = NULL; - GNUNET_CLIENT_disconnect (h->dns_connection, GNUNET_NO); - h->dns_connection = NULL; -#if 0 - h->conn_task = + disconnect (dh); + dh->reconnect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, - &connect_to_service_dns, h); -#endif + &reconnect, dh); return; } - - /* the service did something strange, reconnect immediately */ - if (msg->type != htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS)) + if ( (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST) || + (ntohs (msg->size) < sizeof (struct GNUNET_DNS_Request)) ) { + /* the service did something strange, reconnect immediately */ GNUNET_break (0); - GNUNET_CLIENT_disconnect (h->dns_connection, GNUNET_NO); - h->dns_connection = NULL; -#if 0 - conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns, NULL); -#endif + disconnect (dh); + dh->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, dh); return; } - h->process_answer_cb (h->process_answer_cb_cls, - (const struct answer_packet*) msg); - GNUNET_CLIENT_receive (h->dns_connection, &dns_answer_handler, h, + req = (const struct GNUNET_DNS_Request *) msg; + GNUNET_break (ntohl (req->reserved) == 0); + payload_length = ntohs (req->header.size) - sizeof (struct GNUNET_DNS_Request); + GNUNET_CLIENT_receive (dh->dns_connection, + &request_handler, dh, GNUNET_TIME_UNIT_FOREVER_REL); + + /* finally, pass request to callback for answers */ + rh = GNUNET_malloc (sizeof (struct GNUNET_DNS_RequestHandle)); + rh->dh =dh; + rh->request_id = req->request_id; + rh->generation = dh->generation; + dh->pending_requests++; + dh->rh (dh->rh_cls, + rh, + payload_length, + (const char*) &req[1]); } /** - * Connect to the service-dns + * Callback called by notify_transmit_ready; sends DNS replies + * to the DNS service. + * + * @param cls the struct GNUNET_DNS_Handle + * @param size number of bytes available in buf + * @param buf where to copy the message for transmission + * @return number of bytes copied to buf */ -struct GNUNET_DNS_Handle * -GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, - GNUNET_DNS_ResponseCallback cb, - void *cb_cls) +static size_t +send_response (void *cls, size_t size, void *buf) { - struct GNUNET_DNS_Handle *h; - - h = GNUNET_malloc (sizeof (struct GNUNET_DNS_Handle)); - h->cfg = cfg; - h->process_answer_cb = cb; - h->process_answer_cb_cls = cb_cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n"); - h->dns_connection = GNUNET_CLIENT_connect ("dns", h->cfg); - /* This would most likely be a misconfiguration */ - GNUNET_assert (NULL != h->dns_connection); - GNUNET_CLIENT_receive (h->dns_connection, - &dns_answer_handler, NULL, - GNUNET_TIME_UNIT_FOREVER_REL); - /* If a packet is already in the list, schedule to send it */ - if (h->dns_transmit_handle == NULL && h->head != NULL) - h->dns_transmit_handle = - GNUNET_CLIENT_notify_transmit_ready (h->dns_connection, - ntohs (h->head->pkt.hdr.size), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &send_query, h); - else if (h->dns_transmit_handle == NULL && h->restart_hijack == 1) + struct GNUNET_DNS_Handle *dh = cls; + struct ReplyQueueEntry *qe; + size_t len; + + dh->dns_transmit_handle = NULL; + if (NULL == buf) + { + disconnect (dh); + dh->reconnect_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, + &reconnect, dh); + return 0; + } + qe = dh->rq_head; + if (NULL == qe) + return 0; + len = ntohs (qe->msg->size); + if (len > size) + { + dh->dns_transmit_handle = + GNUNET_CLIENT_notify_transmit_ready (dh->dns_connection, + len, + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_NO, + &send_response, dh); + return 0; + } + memcpy (buf, qe->msg, len); + GNUNET_CONTAINER_DLL_remove (dh->rq_head, + dh->rq_tail, + qe); + GNUNET_free (qe); + if (GNUNET_NO == dh->in_receive) + { + dh->in_receive = GNUNET_YES; + GNUNET_CLIENT_receive (dh->dns_connection, + &request_handler, dh, + GNUNET_TIME_UNIT_FOREVER_REL); + } + if (NULL != (qe = dh->rq_head)) + { + dh->dns_transmit_handle = + GNUNET_CLIENT_notify_transmit_ready (dh->dns_connection, + ntohs (qe->msg->size), + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_NO, + &send_response, dh); + } + return len; +} + + +/** + * Add the given reply to our transmission queue and trigger sending if needed. + * + * @param dh handle with the connection + * @param qe reply to queue + */ +static void +queue_reply (struct GNUNET_DNS_Handle *dh, + struct ReplyQueueEntry *qe) +{ + if (NULL == dh->dns_connection) { - h->dns_transmit_handle = - GNUNET_CLIENT_notify_transmit_ready (h->dns_connection, - sizeof (struct - GNUNET_MessageHeader), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &send_query, NULL); + GNUNET_free (qe); + return; } - return h; + GNUNET_CONTAINER_DLL_insert_tail (dh->rq_head, + dh->rq_tail, + qe); + if (NULL != dh->dns_transmit_handle) + return; + /* trigger sending */ + dh->dns_transmit_handle = + GNUNET_CLIENT_notify_transmit_ready (dh->dns_connection, + ntohs (dh->rq_head->msg->size), + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_NO, + &send_response, dh); } +/** + * If a GNUNET_DNS_RequestHandler calls this function, the request is + * given to other clients or the global DNS for resolution. Once a + * global response has been obtained, the request handler is AGAIN + * called to give it a chance to observe and modify the response after + * the "normal" resolution. It is not legal for the request handler + * to call this function if a response is already present. + * + * @param rh request that should now be forwarded + */ void -GNUNET_DNS_restart_hijack (struct GNUNET_DNS_Handle *h) +GNUNET_DNS_request_forward (struct GNUNET_DNS_RequestHandle *rh) { - h->restart_hijack = 1; - if (NULL != h->dns_connection && h->dns_transmit_handle == NULL) - h->dns_transmit_handle = - GNUNET_CLIENT_notify_transmit_ready (h->dns_connection, - sizeof (struct - GNUNET_MessageHeader), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &send_query, h); + struct ReplyQueueEntry *qe; + struct GNUNET_DNS_Response *resp; + + GNUNET_assert (0 < rh->dh->pending_requests--); + if (rh->generation != rh->dh->generation) + { + GNUNET_free (rh); + return; + } + qe = GNUNET_malloc (sizeof (struct ReplyQueueEntry) + + sizeof (struct GNUNET_DNS_Response)); + resp = (struct GNUNET_DNS_Response*) &qe[1]; + qe->msg = &resp->header; + resp->header.size = htons (sizeof (struct GNUNET_DNS_Response)); + resp->header.type = htons (GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); + resp->drop_flag = htonl (1); + resp->request_id = rh->request_id; + queue_reply (rh->dh, qe); + GNUNET_free (rh); } /** - * FIXME: we should not expost our internal structures like this. - * Just a quick initial hack. + * If a GNUNET_DNS_RequestHandler calls this function, the request is + * to be dropped and no response should be generated. + * + * @param rh request that should now be dropped */ -static void -queue_request (struct GNUNET_DNS_Handle *h, - struct query_packet_list *q) +void +GNUNET_DNS_request_drop (struct GNUNET_DNS_RequestHandle *rh) { - GNUNET_CONTAINER_DLL_insert_tail (h->head, h->tail, q); - if (h->dns_connection != NULL && h->dns_transmit_handle == NULL) - h->dns_transmit_handle = - GNUNET_CLIENT_notify_transmit_ready (h->dns_connection, ntohs(q->pkt.hdr.size), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &send_query, - h); -} + struct ReplyQueueEntry *qe; + struct GNUNET_DNS_Response *resp; + GNUNET_assert (0 < rh->dh->pending_requests--); + if (rh->generation != rh->dh->generation) + { + GNUNET_free (rh); + return; + } + qe = GNUNET_malloc (sizeof (struct ReplyQueueEntry) + + sizeof (struct GNUNET_DNS_Response)); + resp = (struct GNUNET_DNS_Response*) &qe[1]; + qe->msg = &resp->header; + resp->header.size = htons (sizeof (struct GNUNET_DNS_Response)); + resp->header.type = htons (GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); + resp->request_id = rh->request_id; + resp->drop_flag = htonl (0); + queue_reply (rh->dh, qe); + GNUNET_free (rh); +} /** - * Process a DNS request sent to an IPv4 resolver. Pass it - * to the DNS service for resolution. + * If a GNUNET_DNS_RequestHandler calls this function, the request is + * supposed to be answered with the data provided to this call (with + * the modifications the function might have made). * - * @param h DNS handle - * @param dst_ip destination IPv4 address - * @param src_ip source IPv4 address (usually local machine) - * @param src_port source port (to be used for reply) - * @param udp_packet_len length of the UDP payload in bytes - * @param udp_packet UDP payload + * @param rh request that should now be answered + * @param reply_length size of reply (uint16_t to force sane size) + * @param reply reply data */ void -GNUNET_DNS_queue_request_v4 (struct GNUNET_DNS_Handle *h, - const struct in_addr *dst_ip, - const struct in_addr *src_ip, - uint16_t src_port, - size_t udp_packet_len, - const char *udp_packet) +GNUNET_DNS_request_answer (struct GNUNET_DNS_RequestHandle *rh, + uint16_t reply_length, + const char *reply) { - size_t len = sizeof (struct query_packet) + udp_packet_len - 1; - struct query_packet_list *query = - GNUNET_malloc (len + sizeof (struct query_packet_list) - - sizeof (struct query_packet)); - query->pkt.hdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_QUERY_DNS); - query->pkt.hdr.size = htons (len); - memcpy (query->pkt.orig_to, dst_ip, 4); - memcpy (query->pkt.orig_from, src_ip, 4); - query->pkt.addrlen = 4; - query->pkt.src_port = htons (src_port); - memcpy (query->pkt.data, udp_packet, udp_packet_len); - queue_request (h, query); + struct ReplyQueueEntry *qe; + struct GNUNET_DNS_Response *resp; + + GNUNET_assert (0 < rh->dh->pending_requests--); + if (rh->generation != rh->dh->generation) + { + GNUNET_free (rh); + return; + } + if (reply_length + sizeof (struct GNUNET_DNS_Response) >= GNUNET_SERVER_MAX_MESSAGE_SIZE) + { + GNUNET_break (0); + GNUNET_free (rh); + return; + } + qe = GNUNET_malloc (sizeof (struct ReplyQueueEntry) + + sizeof (struct GNUNET_DNS_Response) + reply_length); + resp = (struct GNUNET_DNS_Response*) &qe[1]; + qe->msg = &resp->header; + resp->header.size = htons (sizeof (struct GNUNET_DNS_Response) + reply_length); + resp->header.type = htons (GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); + resp->drop_flag = htonl (2); + resp->request_id = rh->request_id; + memcpy (&resp[1], reply, reply_length); + queue_reply (rh->dh, qe); + GNUNET_free (rh); } /** - * Process a DNS request sent to an IPv6 resolver. Pass it - * to the DNS service for resolution. + * Connect to the service-dns * - * @param h DNS handle - * @param dst_ip destination IPv6 address - * @param src_ip source IPv6 address (usually local machine) - * @param src_port source port (to be used for reply) - * @param udp_packet_len length of the UDP payload in bytes - * @param udp_packet UDP payload + * @param cfg configuration to use + * @param flags when to call rh + * @param rh function to call with DNS requests + * @param rh_cls closure to pass to rh + * @return DNS handle */ -void -GNUNET_DNS_queue_request_v6 (struct GNUNET_DNS_Handle *h, - const struct in6_addr *dst_ip, - const struct in6_addr *src_ip, - uint16_t src_port, - size_t udp_packet_len, - const char *udp_packet) +struct GNUNET_DNS_Handle * +GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, + enum GNUNET_DNS_Flags flags, + GNUNET_DNS_RequestHandler rh, + void *rh_cls) { - size_t len = - sizeof (struct query_packet) + udp_packet_len - 1; - struct query_packet_list *query = - GNUNET_malloc (len + sizeof (struct query_packet_list) - - sizeof (struct answer_packet)); - query->pkt.hdr.type = - htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_QUERY_DNS); - query->pkt.hdr.size = htons (len); - memcpy (query->pkt.orig_to, dst_ip, 16); - memcpy (query->pkt.orig_from, src_ip, 16); - query->pkt.addrlen = 16; - query->pkt.src_port = htons (src_port); - memcpy (query->pkt.data, udp_packet, - udp_packet_len); - queue_request (h, query); + struct GNUNET_DNS_Handle *dh; + + dh = GNUNET_malloc (sizeof (struct GNUNET_DNS_Handle)); + dh->cfg = cfg; + dh->flags = flags; + dh->rh = rh; + dh->rh_cls = rh_cls; + dh->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, dh); + return dh; } +/** + * Disconnect from the DNS service. + * + * @param dh DNS handle + */ void -GNUNET_DNS_disconnect (struct GNUNET_DNS_Handle *h) +GNUNET_DNS_disconnect (struct GNUNET_DNS_Handle *dh) { - if (h->dns_connection != NULL) + if (GNUNET_SCHEDULER_NO_TASK != dh->reconnect_task) { - GNUNET_CLIENT_disconnect (h->dns_connection, GNUNET_NO); - h->dns_connection = NULL; + GNUNET_SCHEDULER_cancel (dh->reconnect_task); + dh->reconnect_task = GNUNET_SCHEDULER_NO_TASK; } - GNUNET_free (h); + disconnect (dh); + /* make sure client has no pending requests left over! */ + GNUNET_assert (0 == dh->pending_requests); + GNUNET_free (dh); } -/* end of dns_api.c */ +/* end of dns_api_new.c */