X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fdns%2Fdns_api.c;h=4803fe3fc006ae7c8c9eb78fedc09c6dbe9122b7;hb=7f937e3781f36538d9864fa841822eecdaf0bf27;hp=7a1577365969b88c49667b408c9ff717af34821b;hpb=b75373955d92c8ac1e9554182025843c01cbb96c;p=oweals%2Fgnunet.git diff --git a/src/dns/dns_api.c b/src/dns/dns_api.c index 7a1577365..4803fe3fc 100644 --- a/src/dns/dns_api.c +++ b/src/dns/dns_api.c @@ -1,343 +1,390 @@ /* - 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 + Copyright (C) 2012, 2016 GNUnet e.V. + + 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, 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 -{ - struct query_packet_list *next GNUNET_PACKED; - struct query_packet_list *prev GNUNET_PACKED; - struct query_packet pkt; -}; - - -struct GNUNET_DNS_Handle +/** + * Handle to identify an individual DNS request. + */ +struct GNUNET_DNS_RequestHandle { - struct query_packet_list *head; - struct query_packet_list *tail; - struct GNUNET_CLIENT_Connection *dns_connection; - unsigned char restart_hijack; - struct GNUNET_CLIENT_TransmitHandle *dns_transmit_handle; + /** + * Handle to DNS API. + */ + struct GNUNET_DNS_Handle *dh; - const struct GNUNET_CONFIGURATION_Handle *cfg; + /** + * 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; - GNUNET_DNS_ResponseCallback process_answer_cb; - - void *process_answer_cb_cls; }; /** - * Callback called by notify_transmit_ready; sends dns-queries or rehijack-messages - * to the service-dns - * {{{ + * DNS handle */ -size_t -send_query (void *cls GNUNET_UNUSED, size_t size, void *buf) +struct GNUNET_DNS_Handle { - struct GNUNET_DNS_Handle *h = cls; - size_t len; - - h->dns_transmit_handle = NULL; - - /* - * Send the rehijack-message + /** + * Connection to DNS service, or NULL. */ - 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; + struct GNUNET_MQ_Handle *mq; - len = ntohs (query->pkt.hdr.size); + /** + * Configuration to use. + */ + const struct GNUNET_CONFIGURATION_Handle *cfg; - GNUNET_assert (len <= size); + /** + * Function to call to get replies. + */ + GNUNET_DNS_RequestHandler rh; - memcpy (buf, &query->pkt.hdr, len); + /** + * Closure for @e rh. + */ + void *rh_cls; - GNUNET_CONTAINER_DLL_remove (h->head, h->tail, query); + /** + * Task to reconnect to the service. + */ + struct GNUNET_SCHEDULER_Task *reconnect_task; - GNUNET_free (query); - } - else - { - GNUNET_break (0); - len = 0; - } + /** + * Re-connect counter, to make sure we did not reconnect in the meantime. + */ + uint32_t generation; - /* - * Check whether more data is to be sent + /** + * Flags for events we care about. */ - if (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->restart_hijack == 1) - { - 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); - } + enum GNUNET_DNS_Flags flags; - return len; -} + /** + * Number of GNUNET_DNS_RequestHandles we have outstanding. Must be 0 before + * we can be disconnected. + */ + unsigned int pending_requests; +}; -/* }}} */ +/** + * Reconnect to the DNS service. + * + * @param cls handle with the connection to connect + * @param tc scheduler context (unused) + */ +static void +reconnect (void *cls); /** - * This receives packets from the service-dns and schedules process_answer to - * handle it + * Drop the existing connection and reconnect to the DNS service. + * + * @param dh handle with the connection */ static void -dns_answer_handler (void *cls, - const struct GNUNET_MessageHeader *msg) +force_reconnect (struct GNUNET_DNS_Handle *dh) { - struct GNUNET_DNS_Handle *h = cls; - - /* the service disconnected, reconnect after short wait */ - if (msg == NULL) + if (NULL != dh->mq) { - 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 = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, - &connect_to_service_dns, h); -#endif - return; + GNUNET_MQ_destroy (dh->mq); + dh->mq = NULL; } + dh->reconnect_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, + &reconnect, + dh); +} - /* the service did something strange, reconnect immediately */ - if (msg->type != htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS)) - { - 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 - 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, - GNUNET_TIME_UNIT_FOREVER_REL); + +/** + * Generic error handler, called with the appropriate error code and + * the same closure specified at the creation of the message queue. + * Not every message queue implementation supports an error handler. + * + * @param cls closure with the `struct GNUNET_DNS_Handle *` + * @param error error code + */ +static void +mq_error_handler (void *cls, + enum GNUNET_MQ_Error error) +{ + struct GNUNET_DNS_Handle *dh = cls; + + force_reconnect (dh); } + /** - * Connect to the service-dns + * This receives packets from the DNS service and calls the application to + * check that the request is well-formed + * + * @param cls the struct GNUNET_DNS_Handle + * @param req message from the service (request) */ -struct GNUNET_DNS_Handle * -GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, - GNUNET_DNS_ResponseCallback cb, - void *cb_cls) +static int +check_request (void *cls, + const struct GNUNET_DNS_Request *req) { - 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) + if (0 != ntohl (req->reserved)) { - 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_break (0); + return GNUNET_SYSERR; } - return h; + return GNUNET_OK; } -void -GNUNET_DNS_restart_hijack (struct GNUNET_DNS_Handle *h) +/** + * 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 +handle_request (void *cls, + const struct GNUNET_DNS_Request *req) { - 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 GNUNET_DNS_Handle *dh = cls; + size_t payload_length = ntohs (req->header.size) - sizeof (*req); + struct GNUNET_DNS_RequestHandle *rh; + + rh = GNUNET_new (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]); } /** - * FIXME: we should not expost our internal structures like this. - * Just a quick initial hack. + * Reconnect to the DNS service. + * + * @param cls handle with the connection to connect */ static void -queue_request (struct GNUNET_DNS_Handle *h, - struct query_packet_list *q) +reconnect (void *cls) { - 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 GNUNET_DNS_Handle *dh = cls; + struct GNUNET_MQ_MessageHandler handlers[] = { + GNUNET_MQ_hd_var_size (request, + GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST, + struct GNUNET_DNS_Request, + dh), + GNUNET_MQ_handler_end () + }; + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DNS_Register *msg; + + dh->reconnect_task = NULL; + dh->mq = GNUNET_CLIENT_connecT (dh->cfg, + "dns", + handlers, + &mq_error_handler, + dh); + if (NULL == dh->mq) + return; + dh->generation++; + env = GNUNET_MQ_msg (msg, + GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT); + msg->flags = htonl (dh->flags); + GNUNET_MQ_send (dh->mq, + env); } +/** + * 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_request_forward (struct GNUNET_DNS_RequestHandle *rh) +{ + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DNS_Response *resp; + + GNUNET_assert (0 < rh->dh->pending_requests--); + if (rh->generation != rh->dh->generation) + { + GNUNET_free (rh); + return; + } + env = GNUNET_MQ_msg (resp, + GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); + resp->drop_flag = htonl (1); + resp->request_id = rh->request_id; + GNUNET_MQ_send (rh->dh->mq, + env); + 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 + * to be dropped and no response should be generated. * - * @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 dropped */ 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_drop (struct GNUNET_DNS_RequestHandle *rh) { - size_t len = sizeof (struct query_packet) + udp_packet_len - 1; - struct query_packet_list *query = - GNUNET_malloc (len + sizeof (struct answer_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, 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 GNUNET_MQ_Envelope *env; + struct GNUNET_DNS_Response *resp; + + GNUNET_assert (0 < rh->dh->pending_requests--); + if (rh->generation != rh->dh->generation) + { + GNUNET_free (rh); + return; + } + env = GNUNET_MQ_msg (resp, + GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); + resp->request_id = rh->request_id; + resp->drop_flag = htonl (0); + GNUNET_MQ_send (rh->dh->mq, + env); + GNUNET_free (rh); } /** - * Process a DNS request sent to an IPv6 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 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 rh request that should now be answered + * @param reply_length size of @a reply (uint16_t to force sane size) + * @param reply reply data */ 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) +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 answer_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_MQ_Envelope *env; + 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; + } + env = GNUNET_MQ_msg_extra (resp, + reply_length, + GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); + resp->drop_flag = htonl (2); + resp->request_id = rh->request_id; + GNUNET_memcpy (&resp[1], + reply, + reply_length); + GNUNET_MQ_send (rh->dh->mq, + env); + GNUNET_free (rh); } +/** + * Connect to the service-dns + * + * @param cfg configuration to use + * @param flags when to call @a rh + * @param rh function to call with DNS requests + * @param rh_cls closure to pass to @a rh + * @return DNS handle + */ +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) +{ + struct GNUNET_DNS_Handle *dh; + + dh = GNUNET_new (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 (NULL != dh->mq) + { + GNUNET_MQ_destroy (dh->mq); + dh->mq = NULL; + } + if (NULL != dh->reconnect_task) { - GNUNET_CLIENT_disconnect (h->dns_connection, GNUNET_NO); - h->dns_connection = NULL; + GNUNET_SCHEDULER_cancel (dh->reconnect_task); + dh->reconnect_task = NULL; } - GNUNET_free (h); + /* make sure client has no pending requests left over! */ + GNUNET_break (0 == dh->pending_requests); + GNUNET_free (dh); } /* end of dns_api.c */