prepare for tcp

diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index 29657ff08347e6b5e8c073d70006db7a4835668f..c5b78e4f0c36955f2bf00a38365cd4f38af471de 100644 (file)
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -684,6 +684,16 @@ extern "C"
  */
 #define GNUNET_MESSAGE_TYPE_SERVICE_UDP_BACK 187
 
+/**
+ * Type of messages containing an TCP packet for a service
+ */
+#define GNUNET_MESSAGE_TYPE_SERVICE_TCP 188
+
+/**
+ * Type of messages containing an TCP packet from a service
+ */
+#define GNUNET_MESSAGE_TYPE_SERVICE_TCP_BACK 189
+
 
 /**
  * Type of messages between the gnunet-wlan-helper and the daemon

diff --git a/src/vpn/gnunet-daemon-vpn-helper.c b/src/vpn/gnunet-daemon-vpn-helper.c
index 7d9eb7d6ea1a91fcf3f5c69552842916267afb25..9f8bc49f2bd518c7ae65d1ce66ca9bb912d906ce 100644 (file)
--- a/src/vpn/gnunet-daemon-vpn-helper.c
+++ b/src/vpn/gnunet-daemon-vpn-helper.c
@@ -194,120 +194,165 @@ helper_write(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tsdkctx) {
                                       &helper_write,
                                       NULL);
 }
+
 /**
  * Receive packets from the helper-process
  */
 void
-message_token(void *cls,
-             void *client,
-             const struct GNUNET_MessageHeader *message) {
-    GNUNET_assert(ntohs(message->type) == GNUNET_MESSAGE_TYPE_VPN_HELPER);
-
-    struct tun_pkt *pkt_tun = (struct tun_pkt*) message;
-
-    /* ethertype is ipv6 */
-    if (ntohs(pkt_tun->tun.type) == 0x86dd)
-      {
-       struct ip6_pkt *pkt6 = (struct ip6_pkt*) message;
-       GNUNET_assert(pkt6->ip6_hdr.version == 6);
-       struct ip6_tcp *pkt6_tcp;
-       struct ip6_udp *pkt6_udp;
-       struct ip6_icmp *pkt6_icmp;
-       GNUNET_HashCode* key;
-
-       switch(pkt6->ip6_hdr.nxthdr)
-         {
-         case 0x06:
-           pkt6_tcp = (struct ip6_tcp*)pkt6;
-           break;
-         case 0x11:
-           pkt6_udp = (struct ip6_udp*)pkt6;
-           if ((key = address_mapping_exists(pkt6->ip6_hdr.dadr)) != NULL)
-             {
-               struct map_entry* me = GNUNET_CONTAINER_multihashmap_get(hashmap, key);
-               GNUNET_assert(me != NULL);
-               GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Mapping exists; type: %d; UDP is %d; port: %x/%x!\n", me->desc.service_type, htonl(GNUNET_DNS_SERVICE_TYPE_UDP), pkt6_udp->udp_hdr.dpt, me->desc.ports);
-               GNUNET_free(key);
-               if (me->desc.service_type & htonl(GNUNET_DNS_SERVICE_TYPE_UDP) &&
-                   (port_in_ports(me->desc.ports, pkt6_udp->udp_hdr.dpt) ||
-                    testBit(me->additional_ports, ntohs(pkt6_udp->udp_hdr.dpt))))
-                 {
-                   size_t size = sizeof(struct GNUNET_MESH_Tunnel*) + sizeof(struct GNUNET_MessageHeader) + sizeof(GNUNET_HashCode) + ntohs(pkt6_udp->udp_hdr.len);
-                   struct GNUNET_MESH_Tunnel **cls = GNUNET_malloc(size);
-                   struct GNUNET_MessageHeader *hdr = (struct GNUNET_MessageHeader*)(cls+1);
-                   GNUNET_HashCode* hc = (GNUNET_HashCode*)(hdr + 1);
-
-                   memcpy(hc, &me->desc.service_descriptor, sizeof(GNUNET_HashCode));
-                   memcpy(hc+1, &pkt6_udp->udp_hdr, ntohs(pkt6_udp->udp_hdr.len));
-
-                   if (me->tunnel == NULL)
-                     {
-                       *cls = GNUNET_MESH_peer_request_connect_all(mesh_handle,
-                                                                   GNUNET_TIME_UNIT_FOREVER_REL,
-                                                                   1,
-                                                                   (struct GNUNET_PeerIdentity*)&me->desc.peer,
-                                                                   send_udp_to_peer,
-                                                                   NULL,
-                                                                   cls);
-                       me->tunnel = *cls;
-                     }
-                   else
-                     {
-                       *cls = me->tunnel;
-                       send_udp_to_peer(cls, (struct GNUNET_PeerIdentity*)1, NULL);
-                     }
-                   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Queued to send to peer %x\n", *((unsigned int*)&me->desc.peer));
-                 }
-             }
-           break;
-         case 0x3a:
-           /* ICMPv6 */
-           pkt6_icmp = (struct ip6_icmp*)pkt6;
-           /* If this packet is an icmp-echo-request and a mapping exists, answer */
-           if (pkt6_icmp->icmp_hdr.type == 0x80 && (key = address_mapping_exists(pkt6->ip6_hdr.dadr)) != NULL)
-             {
-               GNUNET_free(key);
-               pkt6_icmp = GNUNET_malloc(ntohs(pkt6->shdr.size));
-               memcpy(pkt6_icmp, pkt6, ntohs(pkt6->shdr.size));
-               GNUNET_SCHEDULER_add_now(&send_icmp_response, pkt6_icmp);
-             }
-           break;
-         }
-      }
-    /* ethertype is ipv4 */
-    else if (ntohs(pkt_tun->tun.type) == 0x0800)
-      {
-       struct ip_pkt *pkt = (struct ip_pkt*) message;
-       struct ip_udp *udp = (struct ip_udp*) message;
-       GNUNET_assert(pkt->ip_hdr.version == 4);
-
-       /* Send dns-packets to the service-dns */
-       if (pkt->ip_hdr.proto == 0x11 && ntohs(udp->udp_hdr.dpt) == 53 )
-         {
-           /* 9 = 8 for the udp-header + 1 for the unsigned char data[1]; */
-           size_t len = sizeof(struct query_packet) + ntohs(udp->udp_hdr.len) - 9;
-
-           struct query_packet_list* query = GNUNET_malloc(len + 2*sizeof(struct query_packet_list*));
-           query->pkt.hdr.type = htons(GNUNET_MESSAGE_TYPE_LOCAL_QUERY_DNS);
-           query->pkt.hdr.size = htons(len);
-           query->pkt.orig_to = pkt->ip_hdr.dadr;
-           query->pkt.orig_from = pkt->ip_hdr.sadr;
-           query->pkt.src_port = udp->udp_hdr.spt;
-           memcpy(query->pkt.data, udp->data, ntohs(udp->udp_hdr.len) - 8);
-
-           GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, query);
-
-           GNUNET_assert(head != NULL);
-
-           if (dns_connection != NULL)
-             GNUNET_CLIENT_notify_transmit_ready(dns_connection,
-                                                 len,
-                                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 GNUNET_YES,
-                                                 &send_query,
-                                                 NULL);
-         }
-      }
+message_token (void *cls,
+               void *client, const struct GNUNET_MessageHeader *message)
+{
+  GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_HELPER);
+
+  struct tun_pkt *pkt_tun = (struct tun_pkt *) message;
+
+  /* ethertype is ipv6 */
+  if (ntohs (pkt_tun->tun.type) == 0x86dd)
+    {
+      struct ip6_pkt *pkt6 = (struct ip6_pkt *) message;
+      GNUNET_assert (pkt6->ip6_hdr.version == 6);
+      struct ip6_tcp *pkt6_tcp;
+      struct ip6_udp *pkt6_udp;
+      struct ip6_icmp *pkt6_icmp;
+      GNUNET_HashCode *key;
+
+      switch (pkt6->ip6_hdr.nxthdr)
+        {
+        case 0x06:             /* TCP */
+        case 0x11:             /* UDP */
+          pkt6_tcp = (struct ip6_tcp *) pkt6;
+          pkt6_udp = (struct ip6_udp *) pkt6;
+
+          if ((key = address_mapping_exists (pkt6->ip6_hdr.dadr)) != NULL)
+            {
+              struct map_entry *me =
+                GNUNET_CONTAINER_multihashmap_get (hashmap, key);
+              GNUNET_assert (me != NULL);
+              GNUNET_free (key);
+
+              size_t size =
+                sizeof (struct GNUNET_MESH_Tunnel *) +
+                sizeof (struct GNUNET_MessageHeader) +
+                sizeof (GNUNET_HashCode) + ntohs (pkt6->ip6_hdr.paylgth);
+
+              struct GNUNET_MESH_Tunnel **cls = GNUNET_malloc (size);
+              struct GNUNET_MessageHeader *hdr =
+                (struct GNUNET_MessageHeader *) (cls + 1);
+              GNUNET_HashCode *hc = (GNUNET_HashCode *) (hdr + 1);
+
+              hdr->size = htons (sizeof (struct GNUNET_MessageHeader) +
+                                 sizeof (GNUNET_HashCode) +
+                                 ntohs (pkt6->ip6_hdr.paylgth));
+
+              memcpy (hc, &me->desc.service_descriptor,
+                      sizeof (GNUNET_HashCode));
+
+              if (0x11 == pkt6->ip6_hdr.nxthdr
+                  && me->
+                  desc.service_type & htonl (GNUNET_DNS_SERVICE_TYPE_UDP)
+                  && (port_in_ports (me->desc.ports, pkt6_udp->udp_hdr.dpt)
+                      || testBit (me->additional_ports,
+                                  ntohs (pkt6_udp->udp_hdr.dpt))))
+                {
+                  hdr->type = ntohs (GNUNET_MESSAGE_TYPE_SERVICE_UDP);
+
+                  memcpy (hc + 1, &pkt6_udp->udp_hdr,
+                          ntohs (pkt6_udp->udp_hdr.len));
+
+                }
+              else if (0x11 == pkt6->ip6_hdr.nxthdr
+                       && me->desc.
+                       service_type & htonl (GNUNET_DNS_SERVICE_TYPE_TCP)
+                       &&
+                       (port_in_ports (me->desc.ports, pkt6_tcp->tcp_hdr.dpt)
+                        && testBit (me->additional_ports,
+                                    ntohs (pkt6_tcp->tcp_hdr.spt))))
+                {
+                  hdr->type = ntohs (GNUNET_MESSAGE_TYPE_SERVICE_TCP);
+
+                  memcpy (hc + 1, &pkt6_tcp->tcp_hdr,
+                          ntohs (pkt6->ip6_hdr.paylgth));
+
+                }
+              else
+                {
+                  GNUNET_free (cls);
+                  cls = NULL;
+                }
+              if (me->tunnel == NULL && NULL != cls)
+                {
+                  *cls =
+                    GNUNET_MESH_peer_request_connect_all (mesh_handle,
+                                                          GNUNET_TIME_UNIT_FOREVER_REL,
+                                                          1,
+                                                          (struct
+                                                           GNUNET_PeerIdentity
+                                                           *) &me->desc.peer,
+                                                          send_pkt_to_peer,
+                                                          NULL, cls);
+                  me->tunnel = *cls;
+                }
+              else if (NULL != cls)
+                {
+                  *cls = me->tunnel;
+                  send_pkt_to_peer (cls, (struct GNUNET_PeerIdentity *) 1,
+                                    NULL);
+                }
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Queued to send to peer %x\n",
+                          *((unsigned int *) &me->desc.peer));
+            }
+          break;
+        case 0x3a:
+          /* ICMPv6 */
+          pkt6_icmp = (struct ip6_icmp *) pkt6;
+          /* If this packet is an icmp-echo-request and a mapping exists, answer */
+          if (pkt6_icmp->icmp_hdr.type == 0x80
+              && (key = address_mapping_exists (pkt6->ip6_hdr.dadr)) != NULL)
+            {
+              GNUNET_free (key);
+              pkt6_icmp = GNUNET_malloc (ntohs (pkt6->shdr.size));
+              memcpy (pkt6_icmp, pkt6, ntohs (pkt6->shdr.size));
+              GNUNET_SCHEDULER_add_now (&send_icmp_response, pkt6_icmp);
+            }
+          break;
+        }
+    }
+  /* ethertype is ipv4 */
+  else if (ntohs (pkt_tun->tun.type) == 0x0800)
+    {
+      struct ip_pkt *pkt = (struct ip_pkt *) message;
+      struct ip_udp *udp = (struct ip_udp *) message;
+      GNUNET_assert (pkt->ip_hdr.version == 4);
+
+      /* Send dns-packets to the service-dns */
+      if (pkt->ip_hdr.proto == 0x11 && ntohs (udp->udp_hdr.dpt) == 53)
+        {
+          /* 9 = 8 for the udp-header + 1 for the unsigned char data[1]; */
+          size_t len =
+            sizeof (struct query_packet) + ntohs (udp->udp_hdr.len) - 9;
+
+          struct query_packet_list *query =
+            GNUNET_malloc (len + 2 * sizeof (struct query_packet_list *));
+          query->pkt.hdr.type = htons (GNUNET_MESSAGE_TYPE_LOCAL_QUERY_DNS);
+          query->pkt.hdr.size = htons (len);
+          query->pkt.orig_to = pkt->ip_hdr.dadr;
+          query->pkt.orig_from = pkt->ip_hdr.sadr;
+          query->pkt.src_port = udp->udp_hdr.spt;
+          memcpy (query->pkt.data, udp->data, ntohs (udp->udp_hdr.len) - 8);
+
+          GNUNET_CONTAINER_DLL_insert_after (head, tail, tail, query);
+
+          GNUNET_assert (head != NULL);
+
+          if (dns_connection != NULL)
+            GNUNET_CLIENT_notify_transmit_ready (dns_connection,
+                                                 len,
+                                                 GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 GNUNET_YES,
+                                                 &send_query, NULL);
+        }
+    }
 }
 
 void write_to_helper(void* buf, size_t len)

diff --git a/src/vpn/gnunet-daemon-vpn.c b/src/vpn/gnunet-daemon-vpn.c
index 4d6a569f490724d9f1cbf02dd25be3b77f4a889d..86a61610968fbaefe3b38a9531fd6b09e4066470 100644 (file)
--- a/src/vpn/gnunet-daemon-vpn.c
+++ b/src/vpn/gnunet-daemon-vpn.c
@@ -139,20 +139,15 @@ send_icmp_response(void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc) {
 
 /**
  * cls is the pointer to a GNUNET_MessageHeader that is
- * followed by the service-descriptor and the udp-packet that should be sent;
+ * followed by the service-descriptor and the packet that should be sent;
  */
 static size_t
-send_udp_to_peer_notify_callback (void *cls, size_t size, void *buf)
+send_pkt_to_peer_notify_callback (void *cls, size_t size, void *buf)
 {
   struct GNUNET_MESH_Tunnel **tunnel = cls;
   struct GNUNET_MessageHeader *hdr =
     (struct GNUNET_MessageHeader *) (tunnel + 1);
-  GNUNET_HashCode *hc = (GNUNET_HashCode *) (hdr + 1);
-  struct udp_pkt *udp = (struct udp_pkt *) (hc + 1);
-  hdr->size = htons (sizeof (struct GNUNET_MessageHeader) +
-                    sizeof (GNUNET_HashCode) + ntohs (udp->len));
-  hdr->type = ntohs (GNUNET_MESSAGE_TYPE_SERVICE_UDP);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "send_udp_to_peer_notify_callback: buf = %x; size = %u;\n", buf, size);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "send_pkt_to_peer_notify_callback: buf = %x; size = %u;\n", buf, size);
   GNUNET_assert (size >= ntohs (hdr->size));
   memcpy (buf, hdr, ntohs (hdr->size));
   size = ntohs(hdr->size);
@@ -169,7 +164,7 @@ port_in_ports (uint64_t ports, uint16_t port)
 }
 
 void
-send_udp_to_peer (void *cls, 
+send_pkt_to_peer (void *cls, 
                  const struct GNUNET_PeerIdentity *peer,
                  const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
@@ -177,17 +172,12 @@ send_udp_to_peer (void *cls,
   struct GNUNET_MESH_Tunnel **tunnel = cls;
   struct GNUNET_MessageHeader *hdr =
     (struct GNUNET_MessageHeader *) (tunnel + 1);
-  GNUNET_HashCode *hc = (GNUNET_HashCode *) (hdr + 1);
-  struct udp_pkt *udp = (struct udp_pkt *) (hc + 1);
   GNUNET_MESH_notify_transmit_ready (*tunnel,
                                     GNUNET_NO,
                                     42,
                                     GNUNET_TIME_relative_divide(GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                    htons (sizeof
-                                           (struct GNUNET_MessageHeader) +
-                                           sizeof (GNUNET_HashCode) +
-                                           ntohs (udp->len)),
-                                    send_udp_to_peer_notify_callback,
+                                     ntohs(hdr->size),
+                                    send_pkt_to_peer_notify_callback,
                                     cls);
 }
 

diff --git a/src/vpn/gnunet-daemon-vpn.h b/src/vpn/gnunet-daemon-vpn.h
index e0e688f99e968b74390905b2949c739653a4c369..c640123b7a0fee98dc81edeff10b7c97312bf43d 100644 (file)
--- a/src/vpn/gnunet-daemon-vpn.h
+++ b/src/vpn/gnunet-daemon-vpn.h
@@ -49,7 +49,7 @@ GNUNET_HashCode* address_mapping_exists(unsigned char addr[]);
 unsigned int port_in_ports (uint64_t ports, uint16_t port);
 
 void
-send_udp_to_peer (void *cls,
+send_pkt_to_peer (void *cls,
                  const struct GNUNET_PeerIdentity *peer,
                  const struct GNUNET_TRANSPORT_ATS_Information *atsi);