src/vpn/gnunet-daemon-vpn-dns.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010 Christian Grothoff
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file vpn/gnunet-daemon-vpn-dns.c
  23  * @brief
  24  * @author Philipp Toelke
  25  */
  26 #include <platform.h>
  27 #include <gnunet_common.h>
  28 #include <gnunet_client_lib.h>
  29 #include <gnunet_os_lib.h>
  30 #include <gnunet_mesh_service.h>
  31 #include <gnunet_protocols.h>
  32 #include <gnunet_server_lib.h>
  33 #include <gnunet_container_lib.h>
  34 #include <block_dns.h>
  35
  36 #include "gnunet-daemon-vpn-dns.h"
  37 #include "gnunet-daemon-vpn.h"
  38 #include "gnunet-daemon-vpn-helper.h"
  39 #include "gnunet-service-dns-p.h"
  40 #include "gnunet-vpn-packet.h"
  41
  42 struct query_packet_list *head;
  43 struct query_packet_list *tail;
  44 struct GNUNET_CLIENT_Connection *dns_connection;
  45 unsigned char restart_hijack;
  46 struct answer_packet_list *answer_proc_head;
  47 struct answer_packet_list *answer_proc_tail;
  48
  49 /**
  50  * Callback called by notify_transmit_ready; sends dns-queries or rehijack-messages
  51  * to the service-dns
  52  * {{{
  53  */
  54 size_t
  55 send_query (void *cls __attribute__ ((unused)), size_t size, void *buf)
  56 {
  57   size_t len;
  58
  59   /*
  60    * Send the rehijack-message
  61    */
  62   if (restart_hijack == 1)
  63   {
  64     restart_hijack = 0;
  65     /*
  66      * The message is just a header
  67      */
  68     GNUNET_assert (sizeof (struct GNUNET_MessageHeader) <= size);
  69     struct GNUNET_MessageHeader *hdr = buf;
  70
  71     len = sizeof (struct GNUNET_MessageHeader);
  72     hdr->size = htons (len);
  73     hdr->type = htons (GNUNET_MESSAGE_TYPE_REHIJACK);
  74   }
  75   else if (head != NULL)
  76   {
  77     struct query_packet_list *query = head;
  78
  79     len = ntohs (query->pkt.hdr.size);
  80
  81     GNUNET_assert (len <= size);
  82
  83     memcpy (buf, &query->pkt.hdr, len);
  84
  85     GNUNET_CONTAINER_DLL_remove (head, tail, query);
  86
  87     GNUNET_free (query);
  88   }
  89   else
  90   {
  91     GNUNET_break (0);
  92     len = 0;
  93   }
  94
  95   /*
  96    * Check whether more data is to be sent
  97    */
  98   if (head != NULL)
  99   {
 100     GNUNET_CLIENT_notify_transmit_ready (dns_connection,
 101                                          ntohs (head->pkt.hdr.size),
 102                                          GNUNET_TIME_UNIT_FOREVER_REL,
 103                                          GNUNET_YES, &send_query, NULL);
 104   }
 105   else if (restart_hijack == 1)
 106   {
 107     GNUNET_CLIENT_notify_transmit_ready (dns_connection,
 108                                          sizeof (struct GNUNET_MessageHeader),
 109                                          GNUNET_TIME_UNIT_FOREVER_REL,
 110                                          GNUNET_YES, &send_query, NULL);
 111   }
 112
 113   return len;
 114 }
 115
 116 /* }}} */
 117
 118
 119 /**
 120  * Connect to the service-dns
 121  */
 122 void
 123 connect_to_service_dns (void *cls __attribute__ ((unused)),
 124                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 125 {
 126   conn_task = GNUNET_SCHEDULER_NO_TASK;
 127   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 128     return;
 129   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
 130   GNUNET_assert (dns_connection == NULL);
 131   dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
 132   /* This would most likely be a misconfiguration */
 133   GNUNET_assert (NULL != dns_connection);
 134   GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
 135                          GNUNET_TIME_UNIT_FOREVER_REL);
 136
 137   /* We might not yet be connected. Yay, mps. */
 138   if (NULL == dns_connection)
 139     return;
 140
 141   /* If a packet is already in the list, schedule to send it */
 142   if (head != NULL)
 143     GNUNET_CLIENT_notify_transmit_ready (dns_connection,
 144                                          ntohs (head->pkt.hdr.size),
 145                                          GNUNET_TIME_UNIT_FOREVER_REL,
 146                                          GNUNET_YES, &send_query, NULL);
 147   else if (restart_hijack == 1)
 148   {
 149     GNUNET_CLIENT_notify_transmit_ready (dns_connection,
 150                                          sizeof (struct GNUNET_MessageHeader),
 151                                          GNUNET_TIME_UNIT_FOREVER_REL,
 152                                          GNUNET_YES, &send_query, NULL);
 153   }
 154 }
 155
 156 /**
 157  * This receives packets from the service-dns and schedules process_answer to
 158  * handle it
 159  */
 160 void
 161 dns_answer_handler (void *cls
 162                     __attribute__ ((unused)),
 163                     const struct GNUNET_MessageHeader *msg)
 164 {
 165   /* the service disconnected, reconnect after short wait */
 166   if (msg == NULL)
 167   {
 168     GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
 169     dns_connection = NULL;
 170     conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 171                                               &connect_to_service_dns, NULL);
 172     return;
 173   }
 174
 175   /* the service did something strange, reconnect immediately */
 176   if (msg->type != htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS))
 177   {
 178     GNUNET_break (0);
 179     GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
 180     dns_connection = NULL;
 181     conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns, NULL);
 182     return;
 183   }
 184   void *pkt = GNUNET_malloc (ntohs (msg->size));
 185
 186   memcpy (pkt, msg, ntohs (msg->size));
 187
 188   GNUNET_SCHEDULER_add_now (process_answer, pkt);
 189   GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
 190                          GNUNET_TIME_UNIT_FOREVER_REL);
 191 }