/*
- 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 <platform.h>
-#include <gnunet_common.h>
-#include <gnunet_client_lib.h>
-#include <gnunet_os_lib.h>
-#include <gnunet_mesh_service.h>
-#include <gnunet_protocols.h>
-#include <gnunet_server_lib.h>
-#include <gnunet_container_lib.h>
-#include <block_dns.h>
-
+#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_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 */
projects / oweals / gnunet.git / blobdiff