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, size_t size, void* buf) {
  56     size_t len;
  57     /*
  58      * Send the rehijack-message
  59      */
  60     if (restart_hijack == 1)
  61       {
  62         restart_hijack = 0;
  63         /*
  64          * The message is just a header
  65          */
  66         GNUNET_assert(sizeof(struct GNUNET_MessageHeader) <= size);
  67         struct GNUNET_MessageHeader* hdr = buf;
  68         len = sizeof(struct GNUNET_MessageHeader);
  69         hdr->size = htons(len);
  70         hdr->type = htons(GNUNET_MESSAGE_TYPE_REHIJACK);
  71       }
  72     else if (head != NULL)
  73       {
  74         struct query_packet_list* query = head;
  75         len = ntohs(query->pkt.hdr.size);
  76
  77         GNUNET_assert(len <= size);
  78
  79         memcpy(buf, &query->pkt.hdr, len);
  80
  81         GNUNET_CONTAINER_DLL_remove (head, tail, query);
  82
  83         GNUNET_free(query);
  84       }
  85     else
  86       {
  87         GNUNET_break(0);
  88         len = 0;
  89       }
  90
  91     /*
  92      * Check whether more data is to be sent
  93      */
  94     if (head != NULL)
  95       {
  96         GNUNET_CLIENT_notify_transmit_ready(dns_connection, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
  97       }
  98     else if (restart_hijack == 1)
  99       {
 100         GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
 101       }
 102
 103     return len;
 104 }
 105 /* }}} */
 106
 107
 108 /**
 109  * Connect to the service-dns
 110  */
 111 void
 112 connect_to_service_dns (void *cls,
 113                         const struct GNUNET_SCHEDULER_TaskContext *tc) {
 114     if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 115       return;
 116     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
 117     GNUNET_assert (dns_connection == NULL);
 118     dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
 119     /* This would most likely be a misconfiguration */
 120     GNUNET_assert(dns_connection != NULL);
 121     GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
 122
 123     /* If a packet is already in the list, schedule to send it */
 124     if (head != NULL)
 125       GNUNET_CLIENT_notify_transmit_ready(dns_connection,
 126                                           ntohs(head->pkt.hdr.size),
 127                                           GNUNET_TIME_UNIT_FOREVER_REL,
 128                                           GNUNET_YES,
 129                                           &send_query,
 130                                           NULL);
 131     else if (restart_hijack == 1)
 132       {
 133         GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
 134       }
 135 }
 136
 137 /**
 138  * This receives packets from the service-dns and schedules process_answer to
 139  * handle it
 140  */
 141 void
 142 dns_answer_handler(void* cls, const struct GNUNET_MessageHeader *msg) {
 143     /* the service disconnected, reconnect after short wait */
 144     if (msg == NULL)
 145       {
 146         GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
 147         dns_connection = NULL;
 148         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 149                                       &connect_to_service_dns,
 150                                       NULL);
 151         return;
 152       }
 153
 154     /* the service did something strange, reconnect immediately */
 155     if (msg->type != htons(GNUNET_MESSAGE_TYPE_LOCAL_RESPONSE_DNS))
 156       {
 157         GNUNET_break (0);
 158         GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
 159         dns_connection = NULL;
 160         GNUNET_SCHEDULER_add_now (&connect_to_service_dns,
 161                                   NULL);
 162         return;
 163       }
 164     void *pkt = GNUNET_malloc(ntohs(msg->size));
 165
 166     memcpy(pkt, msg, ntohs(msg->size));
 167
 168     GNUNET_SCHEDULER_add_now(process_answer, pkt);
 169     GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
 170 }
 171