indentation

17 files changed, 3806 insertions, 3450 deletions

diff --git a/src/vpn/gnunet-daemon-exit.c b/src/vpn/gnunet-daemon-exit.c
index ac07dd4d5..de906af3b 100644
--- a/src/vpn/gnunet-daemon-exit.c
+++ b/src/vpn/gnunet-daemon-exit.c
@@ -132,11 +132,12 @@ struct redirect_state
   struct redirect_service *serv;
   struct remote_addr remote;
 
-  struct GNUNET_CONTAINER_HeapNode* heap_node;
+  struct GNUNET_CONTAINER_HeapNode *heap_node;
   struct GNUNET_CONTAINER_MultiHashMap *hashmap;
   GNUNET_HashCode hash;
 
-  enum { SERVICE, REMOTE } type;
+  enum
+  { SERVICE, REMOTE } type;
 
   /**
    * The source-address and -port of this connection
@@ -152,9 +153,9 @@ static struct GNUNET_CONTAINER_MultiHashMap *tcp_services;
 
 struct tunnel_notify_queue
 {
-  struct tunnel_notify_queue* next;
-  struct tunnel_notify_queue* prev;
-  void* cls;
+  struct tunnel_notify_queue *next;
+  struct tunnel_notify_queue *prev;
+  void *cls;
   size_t len;
 };
 
@@ -162,9 +163,10 @@ struct tunnel_notify_queue
  * Function that frees everything from a hashmap
  */
 static int
-free_iterate(void* cls __attribute__((unused)), const GNUNET_HashCode* hash __attribute__((unused)), void* value)
+free_iterate (void *cls __attribute__ ((unused)), const GNUNET_HashCode * hash
+              __attribute__ ((unused)), void *value)
 {
-  GNUNET_free(value);
+  GNUNET_free (value);
   return GNUNET_YES;
 }
 
@@ -172,46 +174,47 @@ free_iterate(void* cls __attribute__((unused)), const GNUNET_HashCode* hash __at
  * Function scheduled as very last function, cleans up after us
  */
 static void
-cleanup(void* cls __attribute__((unused)), const struct GNUNET_SCHEDULER_TaskContext* tskctx) {
-    GNUNET_assert (0 != (tskctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
+cleanup (void *cls
+         __attribute__ ((unused)),
+         const struct GNUNET_SCHEDULER_TaskContext *tskctx)
+{
+  GNUNET_assert (0 != (tskctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
 
-    GNUNET_CONTAINER_multihashmap_iterate(udp_connections,
-                                          free_iterate,
-                                          NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (udp_connections, free_iterate, NULL);
 
-    GNUNET_CONTAINER_multihashmap_iterate(tcp_connections,
-                                          free_iterate,
-                                          NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (tcp_connections, free_iterate, NULL);
 
-    if (mesh_handle != NULL)
-      {
-        GNUNET_MESH_disconnect(mesh_handle);
-        mesh_handle = NULL;
-      }
+  if (mesh_handle != NULL)
+  {
+    GNUNET_MESH_disconnect (mesh_handle);
+    mesh_handle = NULL;
+  }
 }
 
 static void
-collect_connections(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tc) {
-          if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-      return;
+collect_connections (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
 
 
-    struct GNUNET_CONTAINER_Heap *heap = cls;
+  struct GNUNET_CONTAINER_Heap *heap = cls;
 
-    struct redirect_state* state = GNUNET_CONTAINER_heap_remove_root(heap);
+  struct redirect_state *state = GNUNET_CONTAINER_heap_remove_root (heap);
 
-    /* This is free()ed memory! */
-    state->heap_node = NULL;
+  /* This is free()ed memory! */
+  state->heap_node = NULL;
 
-    /* FIXME! GNUNET_MESH_close_tunnel(state->tunnel); */
+  /* FIXME! GNUNET_MESH_close_tunnel(state->tunnel); */
 
-    GNUNET_CONTAINER_multihashmap_remove(state->hashmap, &state->hash, state);
+  GNUNET_CONTAINER_multihashmap_remove (state->hashmap, &state->hash, state);
 
-    GNUNET_free(state);
+  GNUNET_free (state);
 }
 
 static void
-hash_redirect_info(GNUNET_HashCode* hash, struct redirect_info* u_i, size_t addrlen)
+hash_redirect_info (GNUNET_HashCode * hash, struct redirect_info *u_i,
+                    size_t addrlen)
 {
 
   /* the gnunet hashmap only uses the first sizeof(unsigned int) of the hash
@@ -219,9 +222,12 @@ hash_redirect_info(GNUNET_HashCode* hash, struct redirect_info* u_i, size_t addr
    * build the hash out of the last bytes of the address and the 2 bytes of
    * the port
    */
-  memcpy(hash, &u_i->pt, sizeof(u_i->pt));
-  memcpy(((unsigned char*)hash)+2, u_i->addr+(addrlen-(sizeof(unsigned int) - 2)), (sizeof(unsigned int) - 2));
-  memset(((unsigned char*)hash)+sizeof(unsigned int), 0, sizeof(GNUNET_HashCode) - sizeof(unsigned int));
+  memcpy (hash, &u_i->pt, sizeof (u_i->pt));
+  memcpy (((unsigned char *) hash) + 2,
+          u_i->addr + (addrlen - (sizeof (unsigned int) - 2)),
+          (sizeof (unsigned int) - 2));
+  memset (((unsigned char *) hash) + sizeof (unsigned int), 0,
+          sizeof (GNUNET_HashCode) - sizeof (unsigned int));
 }
 
 /**
@@ -231,36 +237,41 @@ hash_redirect_info(GNUNET_HashCode* hash, struct redirect_info* u_i, size_t addr
 static size_t
 send_udp_to_peer_notify_callback (void *cls, size_t size, void *buf)
 {
-  struct GNUNET_MESH_Tunnel** tunnel = cls;
-  GNUNET_MESH_tunnel_set_data(*tunnel, NULL);
-  struct GNUNET_MessageHeader *hdr = (struct GNUNET_MessageHeader*)(tunnel + 1);
+  struct GNUNET_MESH_Tunnel **tunnel = cls;
+
+  GNUNET_MESH_tunnel_set_data (*tunnel, NULL);
+  struct GNUNET_MessageHeader *hdr =
+      (struct GNUNET_MessageHeader *) (tunnel + 1);
   GNUNET_assert (size >= ntohs (hdr->size));
   memcpy (buf, hdr, ntohs (hdr->size));
-  size = ntohs(hdr->size);
+  size = ntohs (hdr->size);
 
-  if (NULL != GNUNET_MESH_tunnel_get_head(*tunnel))
-    {
-      struct tunnel_notify_queue* element = GNUNET_MESH_tunnel_get_head(*tunnel);
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(*tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(*tunnel);
-
-      GNUNET_CONTAINER_DLL_remove(head, tail, element);
-
-      GNUNET_MESH_tunnel_set_head(*tunnel, head);
-      GNUNET_MESH_tunnel_set_tail(*tunnel, tail);
-
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (*tunnel,
-                                                                                 GNUNET_NO,
-                                                                                 42,
-                                                                                 GNUNET_TIME_relative_divide
-                                                                                 (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                                                                 (const struct GNUNET_PeerIdentity *)
-                                                                                 NULL, element->len,
-                                                                                 send_udp_to_peer_notify_callback, element->cls);
-      /* save the handle */
-      GNUNET_MESH_tunnel_set_data(*tunnel, th);
-      GNUNET_free(element);
-    }
+  if (NULL != GNUNET_MESH_tunnel_get_head (*tunnel))
+  {
+    struct tunnel_notify_queue *element = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *head = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *tail = GNUNET_MESH_tunnel_get_tail (*tunnel);
+
+    GNUNET_CONTAINER_DLL_remove (head, tail, element);
+
+    GNUNET_MESH_tunnel_set_head (*tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (*tunnel, tail);
+
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (*tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL, element->len,
+                                           send_udp_to_peer_notify_callback,
+                                           element->cls);
+
+    /* save the handle */
+    GNUNET_MESH_tunnel_set_data (*tunnel, th);
+    GNUNET_free (element);
+  }
 
   GNUNET_free (cls);
 
@@ -291,10 +302,11 @@ udp_from_helper (struct udp_pkt *udp, unsigned char *dadr, size_t addrlen)
 
   /* get tunnel and service-descriptor from this */
   GNUNET_HashCode hash;
-  hash_redirect_info(&hash, &u_i, addrlen);
+
+  hash_redirect_info (&hash, &u_i, addrlen);
 
   struct redirect_state *state =
-    GNUNET_CONTAINER_multihashmap_get (udp_connections, &hash);
+      GNUNET_CONTAINER_multihashmap_get (udp_connections, &hash);
 
   /* Mark this connection as freshly used */
   GNUNET_CONTAINER_heap_update_cost (udp_connections_heap, state->heap_node,
@@ -303,80 +315,92 @@ udp_from_helper (struct udp_pkt *udp, unsigned char *dadr, size_t addrlen)
   tunnel = state->tunnel;
 
   if (state->type == SERVICE)
+  {
+    /* check if spt == serv.remote if yes: set spt = serv.myport ("nat") */
+    if (ntohs (udp->spt) == state->serv->remote_port)
     {
-      /* check if spt == serv.remote if yes: set spt = serv.myport ("nat") */
-      if (ntohs (udp->spt) == state->serv->remote_port)
-        {
-          udp->spt = htons (state->serv->my_port);
-        }
-      else
-        {
-          /* otherwise the answer came from a different port (tftp does this)
-           * add this new port to the list of all services, so that the packets
-           * coming back from the client to this new port will be routed correctly
-           */
-          struct redirect_service *serv =
-            GNUNET_malloc (sizeof (struct redirect_service));
-          memcpy (serv, state->serv, sizeof (struct redirect_service));
-          serv->my_port = ntohs (udp->spt);
-          serv->remote_port = ntohs (udp->spt);
-          uint16_t *desc = alloca (sizeof (GNUNET_HashCode) + 2);
-          memcpy ((GNUNET_HashCode *) (desc + 1), &state->desc,
-                  sizeof (GNUNET_HashCode));
-          *desc = ntohs (udp->spt);
-          GNUNET_assert (GNUNET_OK ==
-                         GNUNET_CONTAINER_multihashmap_put (udp_services,
-                                                            (GNUNET_HashCode*)desc, serv,
-                                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-
-          state->serv = serv;
-        }
+      udp->spt = htons (state->serv->my_port);
+    }
+    else
+    {
+      /* otherwise the answer came from a different port (tftp does this)
+       * add this new port to the list of all services, so that the packets
+       * coming back from the client to this new port will be routed correctly
+       */
+      struct redirect_service *serv =
+          GNUNET_malloc (sizeof (struct redirect_service));
+      memcpy (serv, state->serv, sizeof (struct redirect_service));
+      serv->my_port = ntohs (udp->spt);
+      serv->remote_port = ntohs (udp->spt);
+      uint16_t *desc = alloca (sizeof (GNUNET_HashCode) + 2);
+
+      memcpy ((GNUNET_HashCode *) (desc + 1), &state->desc,
+              sizeof (GNUNET_HashCode));
+      *desc = ntohs (udp->spt);
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONTAINER_multihashmap_put (udp_services,
+                                                        (GNUNET_HashCode *)
+                                                        desc, serv,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+
+      state->serv = serv;
     }
+  }
 
   /* send udp-packet back */
   len =
-    sizeof (struct GNUNET_MessageHeader) + sizeof (GNUNET_HashCode) +
-    ntohs (udp->len);
-  struct GNUNET_MESH_Tunnel** ctunnel = GNUNET_malloc (sizeof(struct GNUNET_MESH_TUNNEL*) + len);
+      sizeof (struct GNUNET_MessageHeader) + sizeof (GNUNET_HashCode) +
+      ntohs (udp->len);
+  struct GNUNET_MESH_Tunnel **ctunnel =
+      GNUNET_malloc (sizeof (struct GNUNET_MESH_TUNNEL *) + len);
   *ctunnel = tunnel;
-  msg = (struct GNUNET_MessageHeader*)(ctunnel + 1);
+  msg = (struct GNUNET_MessageHeader *) (ctunnel + 1);
   msg->size = htons (len);
-  msg->type = htons (state->type == SERVICE ? GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK : GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP_BACK);
+  msg->type =
+      htons (state->type ==
+             SERVICE ? GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK :
+             GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP_BACK);
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (msg + 1);
+
   if (state->type == SERVICE)
     memcpy (desc, &state->desc, sizeof (GNUNET_HashCode));
   else
     memcpy (desc, &state->remote, sizeof (struct remote_addr));
   void *_udp = desc + 1;
+
   memcpy (_udp, udp, ntohs (udp->len));
 
-  if (NULL == GNUNET_MESH_tunnel_get_data(tunnel))
-    {
-      /* No notify is pending */
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (tunnel,
-                                                                                 GNUNET_NO,
-                                                                                 42,
-                                                                                 GNUNET_TIME_relative_divide
-                                                                                 (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                                                                 (const struct GNUNET_PeerIdentity *)
-                                                                                 NULL, len,
-                                                                                 send_udp_to_peer_notify_callback, ctunnel);
-      /* save the handle */
-      GNUNET_MESH_tunnel_set_data(tunnel, th);
-    }
+  if (NULL == GNUNET_MESH_tunnel_get_data (tunnel))
+  {
+    /* No notify is pending */
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL, len,
+                                           send_udp_to_peer_notify_callback,
+                                           ctunnel);
+
+    /* save the handle */
+    GNUNET_MESH_tunnel_set_data (tunnel, th);
+  }
   else
-    {
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(tunnel);
-
-      struct tunnel_notify_queue* element = GNUNET_malloc(sizeof(struct tunnel_notify_queue));
-      element->cls = ctunnel;
-      element->len = len;
-
-      GNUNET_CONTAINER_DLL_insert_tail(head, tail, element);
-      GNUNET_MESH_tunnel_set_head(tunnel, head);
-      GNUNET_MESH_tunnel_set_tail(tunnel, tail);
-    }
+  {
+    struct tunnel_notify_queue *head = GNUNET_MESH_tunnel_get_head (tunnel);
+    struct tunnel_notify_queue *tail = GNUNET_MESH_tunnel_get_tail (tunnel);
+
+    struct tunnel_notify_queue *element =
+        GNUNET_malloc (sizeof (struct tunnel_notify_queue));
+    element->cls = ctunnel;
+    element->len = len;
+
+    GNUNET_CONTAINER_DLL_insert_tail (head, tail, element);
+    GNUNET_MESH_tunnel_set_head (tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (tunnel, tail);
+  }
 }
 
 /**
@@ -404,16 +428,19 @@ tcp_from_helper (struct tcp_pkt *tcp, unsigned char *dadr, size_t addrlen,
 
   /* get tunnel and service-descriptor from this */
   GNUNET_HashCode hash;
-  hash_redirect_info(&hash, &u_i, addrlen);
+
+  hash_redirect_info (&hash, &u_i, addrlen);
 
   struct redirect_state *state =
-    GNUNET_CONTAINER_multihashmap_get (tcp_connections, &hash);
+      GNUNET_CONTAINER_multihashmap_get (tcp_connections, &hash);
 
   if (state == NULL)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "No mapping for this connection; hash is %x\n", *((uint32_t*)&hash));
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No mapping for this connection; hash is %x\n",
+                *((uint32_t *) & hash));
+    return;
+  }
 
   /* Mark this connection as freshly used */
   GNUNET_CONTAINER_heap_update_cost (tcp_connections_heap, state->heap_node,
@@ -422,61 +449,72 @@ tcp_from_helper (struct tcp_pkt *tcp, unsigned char *dadr, size_t addrlen,
   tunnel = state->tunnel;
 
   if (state->type == SERVICE)
+  {
+    /* check if spt == serv.remote if yes: set spt = serv.myport ("nat") */
+    if (ntohs (tcp->spt) == state->serv->remote_port)
     {
-      /* check if spt == serv.remote if yes: set spt = serv.myport ("nat") */
-      if (ntohs (tcp->spt) == state->serv->remote_port)
-        {
-          tcp->spt = htons (state->serv->my_port);
-        }
-      else
-        {
-          // This is an illegal packet.
-          return;
-        }
+      tcp->spt = htons (state->serv->my_port);
+    }
+    else
+    {
+      // This is an illegal packet.
+      return;
     }
+  }
 
   /* send tcp-packet back */
   len =
-    sizeof (struct GNUNET_MessageHeader) + sizeof (GNUNET_HashCode) + pktlen;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "len: %d\n", pktlen);
-  struct GNUNET_MESH_Tunnel** ctunnel = GNUNET_malloc (sizeof(struct GNUNET_MESH_TUNNEL*) + len);
+      sizeof (struct GNUNET_MessageHeader) + sizeof (GNUNET_HashCode) + pktlen;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "len: %d\n", pktlen);
+  struct GNUNET_MESH_Tunnel **ctunnel =
+      GNUNET_malloc (sizeof (struct GNUNET_MESH_TUNNEL *) + len);
   *ctunnel = tunnel;
-  msg = (struct GNUNET_MessageHeader*)(ctunnel + 1);
+  msg = (struct GNUNET_MessageHeader *) (ctunnel + 1);
   msg->size = htons (len);
-  msg->type = htons (state->type == SERVICE ? GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP_BACK : GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP_BACK);
+  msg->type =
+      htons (state->type ==
+             SERVICE ? GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP_BACK :
+             GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP_BACK);
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (msg + 1);
+
   if (state->type == SERVICE)
     memcpy (desc, &state->desc, sizeof (GNUNET_HashCode));
   else
     memcpy (desc, &state->remote, sizeof (struct remote_addr));
   void *_tcp = desc + 1;
+
   memcpy (_tcp, tcp, pktlen);
 
-  if (NULL == GNUNET_MESH_tunnel_get_data(tunnel))
-    {
-      /* No notify is pending */
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (tunnel,
-                                     GNUNET_NO,
-                                     42,
-                                     GNUNET_TIME_relative_divide
-                                     (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                     (const struct GNUNET_PeerIdentity *)NULL,
-                                     len, send_udp_to_peer_notify_callback,
-                                     ctunnel);
-      /* save the handle */
-      GNUNET_MESH_tunnel_set_data(tunnel, th);
-    }
+  if (NULL == GNUNET_MESH_tunnel_get_data (tunnel))
+  {
+    /* No notify is pending */
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL,
+                                           len,
+                                           send_udp_to_peer_notify_callback,
+                                           ctunnel);
+
+    /* save the handle */
+    GNUNET_MESH_tunnel_set_data (tunnel, th);
+  }
   else
-    {
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(tunnel);
+  {
+    struct tunnel_notify_queue *head = GNUNET_MESH_tunnel_get_head (tunnel);
+    struct tunnel_notify_queue *tail = GNUNET_MESH_tunnel_get_tail (tunnel);
 
-      struct tunnel_notify_queue* element = GNUNET_malloc(sizeof(struct tunnel_notify_queue));
-      element->cls = ctunnel;
-      element->len = len;
+    struct tunnel_notify_queue *element =
+        GNUNET_malloc (sizeof (struct tunnel_notify_queue));
+    element->cls = ctunnel;
+    element->len = len;
 
-      GNUNET_CONTAINER_DLL_insert_tail(head, tail, element);
-    }
+    GNUNET_CONTAINER_DLL_insert_tail (head, tail, element);
+  }
 }
 
 
@@ -484,8 +522,10 @@ tcp_from_helper (struct tcp_pkt *tcp, unsigned char *dadr, size_t addrlen,
  * Receive packets from the helper-process
  */
 static void
-message_token (void *cls __attribute__((unused)),
-               void *client __attribute__((unused)), const struct GNUNET_MessageHeader *message)
+message_token (void *cls __attribute__ ((unused)),
+               void *client
+               __attribute__ ((unused)),
+               const struct GNUNET_MessageHeader *message)
 {
   GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_HELPER);
 
@@ -493,37 +533,40 @@ message_token (void *cls __attribute__((unused)),
 
   /* ethertype is ipv6 */
   if (ntohs (pkt_tun->tun.type) == 0x86dd)
-    {
-      struct ip6_pkt *pkt6 = (struct ip6_pkt *) pkt_tun;
-      if (0x11 == pkt6->ip6_hdr.nxthdr)
-        udp_from_helper (&((struct ip6_udp *) pkt6)->udp_hdr,
-                         (unsigned char *) &pkt6->ip6_hdr.dadr, 16);
-      else if (0x06 == pkt6->ip6_hdr.nxthdr)
-        tcp_from_helper (&((struct ip6_tcp *) pkt6)->tcp_hdr,
-                         (unsigned char *) &pkt6->ip6_hdr.dadr, 16,
-                         ntohs (pkt6->ip6_hdr.paylgth));
-    }
+  {
+    struct ip6_pkt *pkt6 = (struct ip6_pkt *) pkt_tun;
+
+    if (0x11 == pkt6->ip6_hdr.nxthdr)
+      udp_from_helper (&((struct ip6_udp *) pkt6)->udp_hdr,
+                       (unsigned char *) &pkt6->ip6_hdr.dadr, 16);
+    else if (0x06 == pkt6->ip6_hdr.nxthdr)
+      tcp_from_helper (&((struct ip6_tcp *) pkt6)->tcp_hdr,
+                       (unsigned char *) &pkt6->ip6_hdr.dadr, 16,
+                       ntohs (pkt6->ip6_hdr.paylgth));
+  }
   else if (ntohs (pkt_tun->tun.type) == 0x0800)
+  {
+    struct ip_pkt *pkt4 = (struct ip_pkt *) pkt_tun;
+    uint32_t tmp = pkt4->ip_hdr.dadr;
+
+    if (0x11 == pkt4->ip_hdr.proto)
+      udp_from_helper (&((struct ip_udp *) pkt4)->udp_hdr,
+                       (unsigned char *) &tmp, 4);
+    else if (0x06 == pkt4->ip_hdr.proto)
     {
-      struct ip_pkt *pkt4 = (struct ip_pkt *) pkt_tun;
-      uint32_t tmp = pkt4->ip_hdr.dadr;
-      if (0x11 == pkt4->ip_hdr.proto)
-        udp_from_helper (&((struct ip_udp *) pkt4)->udp_hdr,
-                         (unsigned char *) &tmp, 4);
-      else if (0x06 == pkt4->ip_hdr.proto)
-        {
-          size_t pktlen = ntohs(pkt4->ip_hdr.tot_lngth);
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "tot: %d\n", pktlen);
-          pktlen -= 4*pkt4->ip_hdr.hdr_lngth;
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "-hdr: %d\n", pktlen);
-          tcp_from_helper (&((struct ip_tcp *) pkt4)->tcp_hdr,
-                           (unsigned char *) &tmp, 4, pktlen);
-        }
+      size_t pktlen = ntohs (pkt4->ip_hdr.tot_lngth);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "tot: %d\n", pktlen);
+      pktlen -= 4 * pkt4->ip_hdr.hdr_lngth;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "-hdr: %d\n", pktlen);
+      tcp_from_helper (&((struct ip_tcp *) pkt4)->tcp_hdr,
+                       (unsigned char *) &tmp, 4, pktlen);
     }
+  }
   else
-    {
-      return;
-    }
+  {
+    return;
+  }
 }
 
 /**
@@ -533,18 +576,21 @@ message_token (void *cls __attribute__((unused)),
  * @param section name of section in config, equal to hostname
  */
 static void
-read_service_conf (void *cls __attribute__((unused)), const char *section)
+read_service_conf (void *cls __attribute__ ((unused)), const char *section)
 {
-  if ((strlen(section) < 8) || (0 != strcmp (".gnunet.", section + (strlen(section) - 8))))
+  if ((strlen (section) < 8) ||
+      (0 != strcmp (".gnunet.", section + (strlen (section) - 8))))
     return;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Parsing dns-name %d %s %s\n", strlen(section), section, section + (strlen(section) - 8));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Parsing dns-name %d %s %s\n",
+              strlen (section), section, section + (strlen (section) - 8));
 
   char *cpy;
   char *redirect;
   char *hostname;
   char *hostport;
   uint16_t *desc = alloca (sizeof (GNUNET_HashCode) + 2);
+
   GNUNET_CRYPTO_hash (section, strlen (section) + 1,
                       (GNUNET_HashCode *) (desc + 1));
 
@@ -554,96 +600,105 @@ read_service_conf (void *cls __attribute__((unused)), const char *section)
   int proto = UDP;
 
   do
+  {
+    if (proto == UDP &&
+        (GNUNET_OK !=
+         GNUNET_CONFIGURATION_get_value_string (cfg, section, "UDP_REDIRECTS",
+                                                &cpy)))
+      goto next;
+    else if (proto == TCP &&
+             (GNUNET_OK !=
+              GNUNET_CONFIGURATION_get_value_string (cfg, section,
+                                                     "TCP_REDIRECTS", &cpy)))
+      goto next;
+
+    for (redirect = strtok (cpy, " "); redirect != NULL; redirect = strtok
+         (NULL, " "))
     {
-      if (proto == UDP && (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, section, "UDP_REDIRECTS", &cpy)))
-        goto next;
-      else if (proto == TCP && (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, section, "TCP_REDIRECTS", &cpy)))
-        goto next;
-
-      for (redirect = strtok (cpy, " "); redirect != NULL; redirect = strtok
-           (NULL, " "))
-        {
-          if (NULL == (hostname = strstr (redirect, ":")))
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Warning: option %s is not formatted correctly!\n",
-                          redirect);
-              continue;
-            }
-          hostname[0] = '\0';
-          hostname++;
-          if (NULL == (hostport = strstr (hostname, ":")))
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Warning: option %s is not formatted correctly!\n",
-                          redirect);
-              continue;
-            }
-          hostport[0] = '\0';
-          hostport++;
-
-          int local_port = atoi (redirect);
-          if (!((local_port > 0) && (local_port < 65536)))
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Warning: %s is not a correct port.",
-                        redirect);
-
-          *desc = local_port;
-
-          struct redirect_service *serv =
-            GNUNET_malloc (sizeof (struct redirect_service));
-          memset (serv, 0, sizeof (struct redirect_service));
-          serv->my_port = local_port;
-
-          if (0 == strcmp ("localhost4", hostname))
-            {
-              serv->version = 4;
-
-              char *ip4addr;
-              GNUNET_assert (GNUNET_OK ==
-                             GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                                    "exit",
-                                                                    "IPV4ADDR",
-                                                                    &ip4addr));
-              GNUNET_assert (1 ==
-                             inet_pton (AF_INET, ip4addr,
-                                        serv->v4.ip4address));
-              GNUNET_free (ip4addr);
-            }
-          else if (0 == strcmp ("localhost6", hostname))
-            {
-              serv->version = 6;
-
-              char *ip6addr;
-              GNUNET_assert (GNUNET_OK ==
-                             GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                                    "exit",
-                                                                    "IPV6ADDR",
-                                                                    &ip6addr));
-              GNUNET_assert (1 ==
-                             inet_pton (AF_INET6, ip6addr,
-                                        serv->v6.ip6address));
-              GNUNET_free (ip6addr);
-            }
-          else
-            {
-              // TODO Lookup, yadayadayada
-              GNUNET_assert (0);
-            }
-          serv->remote_port = atoi (hostport);
-          if (UDP == proto)
-            GNUNET_assert (GNUNET_OK ==
-                           GNUNET_CONTAINER_multihashmap_put (udp_services,
-                                                              (GNUNET_HashCode*)desc, serv,
-                                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-          else
-            GNUNET_assert (GNUNET_OK ==
-                           GNUNET_CONTAINER_multihashmap_put (tcp_services,
-                                                              (GNUNET_HashCode*)desc, serv,
-                                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-
-        }
-      GNUNET_free (cpy);
-next:
-      proto = (proto == UDP) ? TCP : UDP;
+      if (NULL == (hostname = strstr (redirect, ":")))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: option %s is not formatted correctly!\n",
+                    redirect);
+        continue;
+      }
+      hostname[0] = '\0';
+      hostname++;
+      if (NULL == (hostport = strstr (hostname, ":")))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: option %s is not formatted correctly!\n",
+                    redirect);
+        continue;
+      }
+      hostport[0] = '\0';
+      hostport++;
+
+      int local_port = atoi (redirect);
+
+      if (!((local_port > 0) && (local_port < 65536)))
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: %s is not a correct port.", redirect);
+
+      *desc = local_port;
+
+      struct redirect_service *serv =
+          GNUNET_malloc (sizeof (struct redirect_service));
+      memset (serv, 0, sizeof (struct redirect_service));
+      serv->my_port = local_port;
+
+      if (0 == strcmp ("localhost4", hostname))
+      {
+        serv->version = 4;
+
+        char *ip4addr;
+
+        GNUNET_assert (GNUNET_OK ==
+                       GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              "exit",
+                                                              "IPV4ADDR",
+                                                              &ip4addr));
+        GNUNET_assert (1 == inet_pton (AF_INET, ip4addr, serv->v4.ip4address));
+        GNUNET_free (ip4addr);
+      }
+      else if (0 == strcmp ("localhost6", hostname))
+      {
+        serv->version = 6;
+
+        char *ip6addr;
+
+        GNUNET_assert (GNUNET_OK ==
+                       GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              "exit",
+                                                              "IPV6ADDR",
+                                                              &ip6addr));
+        GNUNET_assert (1 == inet_pton (AF_INET6, ip6addr, serv->v6.ip6address));
+        GNUNET_free (ip6addr);
+      }
+      else
+      {
+        // TODO Lookup, yadayadayada
+        GNUNET_assert (0);
+      }
+      serv->remote_port = atoi (hostport);
+      if (UDP == proto)
+        GNUNET_assert (GNUNET_OK ==
+                       GNUNET_CONTAINER_multihashmap_put (udp_services,
+                                                          (GNUNET_HashCode *)
+                                                          desc, serv,
+                                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+      else
+        GNUNET_assert (GNUNET_OK ==
+                       GNUNET_CONTAINER_multihashmap_put (tcp_services,
+                                                          (GNUNET_HashCode *)
+                                                          desc, serv,
+                                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+
     }
+    GNUNET_free (cpy);
+next:
+    proto = (proto == UDP) ? TCP : UDP;
+  }
   while (proto != UDP);
 }
 
@@ -654,71 +709,84 @@ next:
  * helper. cls is then taken as handle to the old helper and is cleaned up.
  */
 static void
-start_helper_and_schedule(void *cls,
-                          const struct GNUNET_SCHEDULER_TaskContext *tc) {
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      return;
-
-    if (cls != NULL)
-      cleanup_helper(cls);
-    cls = NULL;
-
-    char* ifname;
-    char* ipv6addr;
-    char* ipv6prefix;
-    char* ipv4addr;
-    char* ipv4mask;
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "exit", "IFNAME", &ifname))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IFNAME' in configuration!\n");
-        exit(1);
-      }
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "exit", "IPV6ADDR", &ipv6addr))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV6ADDR' in configuration!\n");
-        exit(1);
-      }
+start_helper_and_schedule (void *cls,
+                           const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
 
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "exit", "IPV6PREFIX", &ipv6prefix))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV6PREFIX' in configuration!\n");
-        exit(1);
-      }
+  if (cls != NULL)
+    cleanup_helper (cls);
+  cls = NULL;
 
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "exit", "IPV4ADDR", &ipv4addr))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV4ADDR' in configuration!\n");
-        exit(1);
-      }
+  char *ifname;
+  char *ipv6addr;
+  char *ipv6prefix;
+  char *ipv4addr;
+  char *ipv4mask;
 
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "exit", "IPV4MASK", &ipv4mask))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV4MASK' in configuration!\n");
-        exit(1);
-      }
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "exit", "IFNAME", &ifname))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IFNAME' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "exit", "IPV6ADDR",
+                                             &ipv6addr))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV6ADDR' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "exit", "IPV6PREFIX",
+                                             &ipv6prefix))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV6PREFIX' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "exit", "IPV4ADDR",
+                                             &ipv4addr))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV4ADDR' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "exit", "IPV4MASK",
+                                             &ipv4mask))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV4MASK' in configuration!\n");
+    exit (1);
+  }
+
+  /* Start the helper
+   * Messages get passed to the function message_token
+   * When the helper dies, this function will be called again with the
+   * helper_handle as cls.
+   */
+  helper_handle = start_helper (ifname,
+                                ipv6addr,
+                                ipv6prefix,
+                                ipv4addr,
+                                ipv4mask,
+                                "exit-gnunet",
+                                start_helper_and_schedule, message_token, NULL);
 
-    /* Start the helper
-     * Messages get passed to the function message_token
-     * When the helper dies, this function will be called again with the
-     * helper_handle as cls.
-     */
-    helper_handle = start_helper(ifname,
-                                 ipv6addr,
-                                 ipv6prefix,
-                                 ipv4addr,
-                                 ipv4mask,
-                                 "exit-gnunet",
-                                 start_helper_and_schedule,
-                                 message_token,
-                                 NULL);
-
-    GNUNET_free(ipv6addr);
-    GNUNET_free(ipv6prefix);
-    GNUNET_free(ipv4addr);
-    GNUNET_free(ipv4mask);
-    GNUNET_free(ifname);
+  GNUNET_free (ipv6addr);
+  GNUNET_free (ipv6prefix);
+  GNUNET_free (ipv4addr);
+  GNUNET_free (ipv4mask);
+  GNUNET_free (ifname);
 }
 
 static void
@@ -752,14 +820,13 @@ prepare_ipv4_packet (ssize_t len, ssize_t pktlen, void *payload,
   /* Generate a new src-address */
   char *ipv4addr;
   char *ipv4mask;
+
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "exit",
-                                                        "IPV4ADDR",
-                                                        &ipv4addr));
+                                                        "IPV4ADDR", &ipv4addr));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "exit",
-                                                        "IPV4MASK",
-                                                        &ipv4mask));
+                                                        "IPV4MASK", &ipv4mask));
   inet_pton (AF_INET, ipv4addr, &tmp);
   inet_pton (AF_INET, ipv4mask, &tmp2);
   GNUNET_free (ipv4addr);
@@ -774,41 +841,44 @@ prepare_ipv4_packet (ssize_t len, ssize_t pktlen, void *payload,
 
   memcpy (&state->redirect_info.addr, &tmp, 4);
   if (0x11 == protocol)
-    {
-      struct ip_udp* pkt4_udp = (struct ip_udp*)pkt4;
-      state->redirect_info.pt = pkt4_udp->udp_hdr.spt;
+  {
+    struct ip_udp *pkt4_udp = (struct ip_udp *) pkt4;
 
-      pkt4_udp->udp_hdr.crc = 0;        /* Optional for IPv4 */
-    }
+    state->redirect_info.pt = pkt4_udp->udp_hdr.spt;
+
+    pkt4_udp->udp_hdr.crc = 0;  /* Optional for IPv4 */
+  }
   else if (0x06 == protocol)
-    {
-      struct ip_tcp* pkt4_tcp = (struct ip_tcp*)pkt4;
-      state->redirect_info.pt = pkt4_tcp->tcp_hdr.spt;
+  {
+    struct ip_tcp *pkt4_tcp = (struct ip_tcp *) pkt4;
 
-      pkt4_tcp->tcp_hdr.crc = 0;
-      uint32_t sum = 0;
-      tmp = pkt4->ip_hdr.sadr;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-      tmp = pkt4->ip_hdr.dadr;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    state->redirect_info.pt = pkt4_tcp->tcp_hdr.spt;
 
-      tmp = (protocol << 16) | (0xffff & pktlen);
+    pkt4_tcp->tcp_hdr.crc = 0;
+    uint32_t sum = 0;
 
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "line: %08x, %x \n", tmp, (0xffff & pktlen));
+    tmp = pkt4->ip_hdr.sadr;
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = pkt4->ip_hdr.dadr;
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
 
-      tmp = htonl(tmp);
+    tmp = (protocol << 16) | (0xffff & pktlen);
 
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "line: %08x, %x \n", tmp,
+                (0xffff & pktlen));
 
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt4_tcp->tcp_hdr, pktlen);
-      pkt4_tcp->tcp_hdr.crc = calculate_checksum_end (sum);
-    }
+    tmp = htonl (tmp);
+
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt4_tcp->tcp_hdr,
+                                   pktlen);
+    pkt4_tcp->tcp_hdr.crc = calculate_checksum_end (sum);
+  }
 
   pkt4->ip_hdr.chks =
-    calculate_ip_checksum ((uint16_t *) & pkt4->ip_hdr, 5 * 4);
+      calculate_ip_checksum ((uint16_t *) & pkt4->ip_hdr, 5 * 4);
 }
 
 static void
@@ -838,10 +908,10 @@ prepare_ipv6_packet (ssize_t len, ssize_t pktlen, void *payload,
    * the host-mask*/
   char *ipv6addr;
   unsigned long long ipv6prefix;
+
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "exit",
-                                                        "IPV6ADDR",
-                                                        &ipv6addr));
+                                                        "IPV6ADDR", &ipv6addr));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_number (cfg, "exit",
                                                         "IPV6PREFIX",
@@ -856,6 +926,7 @@ prepare_ipv6_packet (ssize_t len, ssize_t pktlen, void *payload,
     ipv6prefix = 16 - sizeof (void *);
 
   unsigned int offset = ipv6prefix - (16 - sizeof (void *));
+
   memcpy ((((char *) &pkt6->ip6_hdr.sadr)) + ipv6prefix,
           ((char *) &tunnel) + offset, 16 - ipv6prefix);
 
@@ -863,66 +934,74 @@ prepare_ipv6_packet (ssize_t len, ssize_t pktlen, void *payload,
   memcpy (&state->redirect_info.addr, &pkt6->ip6_hdr.sadr, 16);
 
   if (0x11 == protocol)
-    {
-      struct ip6_udp* pkt6_udp = (struct ip6_udp*)pkt6;
-      state->redirect_info.pt = pkt6_udp->udp_hdr.spt;
-
-      pkt6_udp->udp_hdr.crc = 0;
-      uint32_t sum = 0;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt6_udp->ip6_hdr.sadr, 16);
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt6_udp->ip6_hdr.dadr, 16);
-      tmp = (htons (pktlen) & 0xffff);
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-      tmp = htons (((pkt6_udp->ip6_hdr.nxthdr & 0x00ff)));
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-
-      sum =
+  {
+    struct ip6_udp *pkt6_udp = (struct ip6_udp *) pkt6;
+
+    state->redirect_info.pt = pkt6_udp->udp_hdr.spt;
+
+    pkt6_udp->udp_hdr.crc = 0;
+    uint32_t sum = 0;
+
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt6_udp->ip6_hdr.sadr,
+                                   16);
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt6_udp->ip6_hdr.dadr,
+                                   16);
+    tmp = (htons (pktlen) & 0xffff);
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = htons (((pkt6_udp->ip6_hdr.nxthdr & 0x00ff)));
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+
+    sum =
         calculate_checksum_update (sum, (uint16_t *) & pkt6_udp->udp_hdr,
                                    ntohs (pkt6_udp->udp_hdr.len));
-      pkt6_udp->udp_hdr.crc = calculate_checksum_end (sum);
-    }
+    pkt6_udp->udp_hdr.crc = calculate_checksum_end (sum);
+  }
   else if (0x06 == protocol)
-    {
-      struct ip6_tcp* pkt6_tcp = (struct ip6_tcp*)pkt6;
-      state->redirect_info.pt = pkt6_tcp->tcp_hdr.spt;
+  {
+    struct ip6_tcp *pkt6_tcp = (struct ip6_tcp *) pkt6;
+
+    state->redirect_info.pt = pkt6_tcp->tcp_hdr.spt;
+
+    pkt6_tcp->tcp_hdr.crc = 0;
+    uint32_t sum = 0;
 
-      pkt6_tcp->tcp_hdr.crc = 0;
-      uint32_t sum = 0;
-      sum =
+    sum =
         calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.sadr, 16);
-      sum =
+    sum =
         calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.dadr, 16);
-      tmp = htonl(pktlen);
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-      tmp = htonl (((pkt6->ip6_hdr.nxthdr & 0x000000ff)));
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = htonl (pktlen);
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = htonl (((pkt6->ip6_hdr.nxthdr & 0x000000ff)));
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
 
-      sum =
+    sum =
         calculate_checksum_update (sum, (uint16_t *) & pkt6_tcp->tcp_hdr,
                                    ntohs (pkt6->ip6_hdr.paylgth));
-      pkt6_tcp->tcp_hdr.crc = calculate_checksum_end (sum);
-    }
+    pkt6_tcp->tcp_hdr.crc = calculate_checksum_end (sum);
+  }
 }
 
 /**
  * The messages are one GNUNET_HashCode for the service followed by a struct tcp_pkt
  */
 static int
-receive_tcp_service (void *cls __attribute__((unused)),
+receive_tcp_service (void *cls __attribute__ ((unused)),
                      struct GNUNET_MESH_Tunnel *tunnel,
-                     void **tunnel_ctx __attribute__((unused)),
-                     const struct GNUNET_PeerIdentity *sender __attribute__((unused)),
+                     void **tunnel_ctx __attribute__ ((unused)),
+                     const struct GNUNET_PeerIdentity *sender
+                     __attribute__ ((unused)),
                      const struct GNUNET_MessageHeader *message,
-                     const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+                     const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                     __attribute__ ((unused)))
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received TCP-Packet\n");
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1);
   struct tcp_pkt *pkt = (struct tcp_pkt *) (desc + 1);
   unsigned int pkt_len = ntohs (message->size) - sizeof (struct
                                                          GNUNET_MessageHeader)
-    - sizeof (GNUNET_HashCode);
+      - sizeof (GNUNET_HashCode);
 
   /** Get the configuration from the services-hashmap.
    *
@@ -934,13 +1013,15 @@ receive_tcp_service (void *cls __attribute__((unused)),
   memcpy (tcp_desc + 1, desc, sizeof (GNUNET_HashCode));
   *tcp_desc = ntohs (pkt->dpt);
   struct redirect_service *serv =
-    GNUNET_CONTAINER_multihashmap_get (tcp_services, (GNUNET_HashCode*)tcp_desc);
+      GNUNET_CONTAINER_multihashmap_get (tcp_services,
+                                         (GNUNET_HashCode *) tcp_desc);
+
   if (NULL == serv)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "No service found for TCP dpt %d!\n", *tcp_desc);
-      return GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "No service found for TCP dpt %d!\n", *tcp_desc);
+    return GNUNET_YES;
+  }
 
   pkt->dpt = htons (serv->remote_port);
 
@@ -955,8 +1036,8 @@ receive_tcp_service (void *cls __attribute__((unused)),
    * This will be saved in the hashmap, so that the receiving procedure knows
    * through which tunnel this connection has to be routed.
    */
-  struct redirect_state *state =
-    GNUNET_malloc (sizeof (struct redirect_state));
+  struct redirect_state *state = GNUNET_malloc (sizeof (struct redirect_state));
+
   memset (state, 0, sizeof (struct redirect_state));
   state->tunnel = tunnel;
   state->serv = serv;
@@ -965,44 +1046,46 @@ receive_tcp_service (void *cls __attribute__((unused)),
   memcpy (&state->desc, desc, sizeof (GNUNET_HashCode));
 
   len = sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) +
-    sizeof (struct ip6_hdr) + pkt_len;
+      sizeof (struct ip6_hdr) + pkt_len;
   buf = alloca (len);
 
   memset (buf, 0, len);
 
   switch (serv->version)
-    {
-    case 4:
-      prepare_ipv4_packet (len, pkt_len, pkt, 0x06,     /* TCP */
-                           &serv->v4.ip4address,
-                           tunnel, state, (struct ip_pkt *) buf);
-      break;
-    case 6:
-      prepare_ipv6_packet (len, pkt_len, pkt, 0x06,     /* TCP */
-                           &serv->v6.ip6address,
-                           tunnel, state, (struct ip6_pkt *) buf);
-
-      break;
-    default:
-      GNUNET_assert (0);
-      break;
-    }
-
-  hash_redirect_info(&state->hash, &state->redirect_info, serv->version == 4 ? 4 : 16);
+  {
+  case 4:
+    prepare_ipv4_packet (len, pkt_len, pkt, 0x06,       /* TCP */
+                         &serv->v4.ip4address,
+                         tunnel, state, (struct ip_pkt *) buf);
+    break;
+  case 6:
+    prepare_ipv6_packet (len, pkt_len, pkt, 0x06,       /* TCP */
+                         &serv->v6.ip6address,
+                         tunnel, state, (struct ip6_pkt *) buf);
+
+    break;
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+
+  hash_redirect_info (&state->hash, &state->redirect_info,
+                      serv->version == 4 ? 4 : 16);
 
   if (GNUNET_NO ==
       GNUNET_CONTAINER_multihashmap_contains (tcp_connections, &state->hash))
-    {
-      GNUNET_CONTAINER_multihashmap_put (tcp_connections, &state->hash, state,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  {
+    GNUNET_CONTAINER_multihashmap_put (tcp_connections, &state->hash, state,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 
-      state->heap_node =
+    state->heap_node =
         GNUNET_CONTAINER_heap_insert (tcp_connections_heap, state,
                                       GNUNET_TIME_absolute_get ().abs_value);
 
-      if (GNUNET_CONTAINER_heap_get_size(tcp_connections_heap) > max_tcp_connections)
-        GNUNET_SCHEDULER_add_now(collect_connections, tcp_connections_heap);
-    }
+    if (GNUNET_CONTAINER_heap_get_size (tcp_connections_heap) >
+        max_tcp_connections)
+      GNUNET_SCHEDULER_add_now (collect_connections, tcp_connections_heap);
+  }
   else
     GNUNET_free (state);
 
@@ -1011,22 +1094,26 @@ receive_tcp_service (void *cls __attribute__((unused)),
 }
 
 static int
-receive_tcp_remote (void *cls __attribute__((unused)),
-                     struct GNUNET_MESH_Tunnel *tunnel,
-                     void **tunnel_ctx __attribute__((unused)),
-                     const struct GNUNET_PeerIdentity *sender __attribute__((unused)),
-                     const struct GNUNET_MessageHeader *message,
-                     const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+receive_tcp_remote (void *cls __attribute__ ((unused)),
+                    struct GNUNET_MESH_Tunnel *tunnel,
+                    void **tunnel_ctx __attribute__ ((unused)),
+                    const struct GNUNET_PeerIdentity *sender
+                    __attribute__ ((unused)),
+                    const struct GNUNET_MessageHeader *message,
+                    const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                    __attribute__ ((unused)))
 {
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1);
   struct tcp_pkt *pkt = (struct tcp_pkt *) (desc + 1);
   struct remote_addr *s = (struct remote_addr *) desc;
   char *buf;
   size_t len;
-  unsigned int pkt_len = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - sizeof (GNUNET_HashCode);
+  unsigned int pkt_len =
+      ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) -
+      sizeof (GNUNET_HashCode);
+
+  struct redirect_state *state = GNUNET_malloc (sizeof (struct redirect_state));
 
-  struct redirect_state *state =
-    GNUNET_malloc (sizeof (struct redirect_state));
   memset (state, 0, sizeof (struct redirect_state));
   state->tunnel = tunnel;
   state->type = REMOTE;
@@ -1034,44 +1121,45 @@ receive_tcp_remote (void *cls __attribute__((unused)),
   memcpy (&state->remote, s, sizeof (struct remote_addr));
 
   len = sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) +
-    sizeof (struct ip6_hdr) + pkt_len;
+      sizeof (struct ip6_hdr) + pkt_len;
   buf = alloca (len);
 
   memset (buf, 0, len);
 
   switch (s->addrlen)
-    {
-    case 4:
-      prepare_ipv4_packet (len, pkt_len, pkt, 0x06,    /* TCP */
-                           &s->addr, tunnel, state, (struct ip_pkt *) buf);
-      break;
-    case 16:
-      prepare_ipv6_packet (len, pkt_len, pkt, 0x06,    /* TCP */
-                           &s->addr, tunnel, state, (struct ip6_pkt *) buf);
-      break;
-    default:
-      return GNUNET_SYSERR;
-      break;
-    }
+  {
+  case 4:
+    prepare_ipv4_packet (len, pkt_len, pkt, 0x06,       /* TCP */
+                         &s->addr, tunnel, state, (struct ip_pkt *) buf);
+    break;
+  case 16:
+    prepare_ipv6_packet (len, pkt_len, pkt, 0x06,       /* TCP */
+                         &s->addr, tunnel, state, (struct ip6_pkt *) buf);
+    break;
+  default:
+    return GNUNET_SYSERR;
+    break;
+  }
 
   hash_redirect_info (&state->hash, &state->redirect_info, s->addrlen);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packet from remote; hash is %x\n", *((uint32_t*)&state->hash));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Packet from remote; hash is %x\n",
+              *((uint32_t *) & state->hash));
 
   if (GNUNET_NO ==
       GNUNET_CONTAINER_multihashmap_contains (tcp_connections, &state->hash))
-    {
-      GNUNET_CONTAINER_multihashmap_put (tcp_connections, &state->hash, state,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  {
+    GNUNET_CONTAINER_multihashmap_put (tcp_connections, &state->hash, state,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 
-      state->heap_node =
+    state->heap_node =
         GNUNET_CONTAINER_heap_insert (tcp_connections_heap, state,
                                       GNUNET_TIME_absolute_get ().abs_value);
 
-      if (GNUNET_CONTAINER_heap_get_size (tcp_connections_heap) >
-          max_tcp_connections)
-        GNUNET_SCHEDULER_add_now (collect_connections, tcp_connections_heap);
-    }
+    if (GNUNET_CONTAINER_heap_get_size (tcp_connections_heap) >
+        max_tcp_connections)
+      GNUNET_SCHEDULER_add_now (collect_connections, tcp_connections_heap);
+  }
   else
     GNUNET_free (state);
 
@@ -1081,12 +1169,14 @@ receive_tcp_remote (void *cls __attribute__((unused)),
 }
 
 static int
-receive_udp_remote (void *cls __attribute__((unused)),
+receive_udp_remote (void *cls __attribute__ ((unused)),
                     struct GNUNET_MESH_Tunnel *tunnel,
-                    void **tunnel_ctx __attribute__((unused)),
-                    const struct GNUNET_PeerIdentity *sender __attribute__((unused)),
+                    void **tunnel_ctx __attribute__ ((unused)),
+                    const struct GNUNET_PeerIdentity *sender
+                    __attribute__ ((unused)),
                     const struct GNUNET_MessageHeader *message,
-                    const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+                    const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                    __attribute__ ((unused)))
 {
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1);
   struct udp_pkt *pkt = (struct udp_pkt *) (desc + 1);
@@ -1103,8 +1193,8 @@ receive_udp_remote (void *cls __attribute__((unused)),
    * This will be saved in the hashmap, so that the receiving procedure knows
    * through which tunnel this connection has to be routed.
    */
-  struct redirect_state *state =
-    GNUNET_malloc (sizeof (struct redirect_state));
+  struct redirect_state *state = GNUNET_malloc (sizeof (struct redirect_state));
+
   memset (state, 0, sizeof (struct redirect_state));
   state->tunnel = tunnel;
   state->hashmap = udp_connections;
@@ -1112,42 +1202,42 @@ receive_udp_remote (void *cls __attribute__((unused)),
   memcpy (&state->remote, s, sizeof (struct remote_addr));
 
   len = sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) +
-    sizeof (struct ip6_hdr) + ntohs (pkt->len);
+      sizeof (struct ip6_hdr) + ntohs (pkt->len);
   buf = alloca (len);
 
   memset (buf, 0, len);
 
   switch (s->addrlen)
-    {
-    case 4:
-      prepare_ipv4_packet (len, ntohs (pkt->len), pkt, 0x11,    /* UDP */
-                           &s->addr, tunnel, state, (struct ip_pkt *) buf);
-      break;
-    case 16:
-      prepare_ipv6_packet (len, ntohs (pkt->len), pkt, 0x11,    /* UDP */
-                           &s->addr, tunnel, state, (struct ip6_pkt *) buf);
-      break;
-    default:
-      GNUNET_assert (0);
-      break;
-    }
+  {
+  case 4:
+    prepare_ipv4_packet (len, ntohs (pkt->len), pkt, 0x11,      /* UDP */
+                         &s->addr, tunnel, state, (struct ip_pkt *) buf);
+    break;
+  case 16:
+    prepare_ipv6_packet (len, ntohs (pkt->len), pkt, 0x11,      /* UDP */
+                         &s->addr, tunnel, state, (struct ip6_pkt *) buf);
+    break;
+  default:
+    GNUNET_assert (0);
+    break;
+  }
 
   hash_redirect_info (&state->hash, &state->redirect_info, s->addrlen);
 
   if (GNUNET_NO ==
       GNUNET_CONTAINER_multihashmap_contains (udp_connections, &state->hash))
-    {
-      GNUNET_CONTAINER_multihashmap_put (udp_connections, &state->hash, state,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  {
+    GNUNET_CONTAINER_multihashmap_put (udp_connections, &state->hash, state,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 
-      state->heap_node =
+    state->heap_node =
         GNUNET_CONTAINER_heap_insert (udp_connections_heap, state,
                                       GNUNET_TIME_absolute_get ().abs_value);
 
-      if (GNUNET_CONTAINER_heap_get_size (udp_connections_heap) >
-          max_udp_connections)
-        GNUNET_SCHEDULER_add_now (collect_connections, udp_connections_heap);
-    }
+    if (GNUNET_CONTAINER_heap_get_size (udp_connections_heap) >
+        max_udp_connections)
+      GNUNET_SCHEDULER_add_now (collect_connections, udp_connections_heap);
+  }
   else
     GNUNET_free (state);
 
@@ -1159,12 +1249,14 @@ receive_udp_remote (void *cls __attribute__((unused)),
  * The messages are one GNUNET_HashCode for the service, followed by a struct udp_pkt
  */
 static int
-receive_udp_service (void *cls __attribute__((unused)),
+receive_udp_service (void *cls __attribute__ ((unused)),
                      struct GNUNET_MESH_Tunnel *tunnel,
-                     void **tunnel_ctx __attribute__((unused)),
-                     const struct GNUNET_PeerIdentity *sender __attribute__((unused)),
+                     void **tunnel_ctx __attribute__ ((unused)),
+                     const struct GNUNET_PeerIdentity *sender
+                     __attribute__ ((unused)),
                      const struct GNUNET_MessageHeader *message,
-                     const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+                     const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                     __attribute__ ((unused)))
 {
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1);
   struct udp_pkt *pkt = (struct udp_pkt *) (desc + 1);
@@ -1176,16 +1268,19 @@ receive_udp_service (void *cls __attribute__((unused)),
 
   /* Get the configuration from the hashmap */
   uint16_t *udp_desc = alloca (sizeof (GNUNET_HashCode) + 2);
+
   memcpy (udp_desc + 1, desc, sizeof (GNUNET_HashCode));
   *udp_desc = ntohs (pkt->dpt);
   struct redirect_service *serv =
-    GNUNET_CONTAINER_multihashmap_get (udp_services, (GNUNET_HashCode*)udp_desc);
+      GNUNET_CONTAINER_multihashmap_get (udp_services,
+                                         (GNUNET_HashCode *) udp_desc);
+
   if (NULL == serv)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "No service found for UDP dpt %d!\n", *udp_desc);
-      return GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "No service found for UDP dpt %d!\n", *udp_desc);
+    return GNUNET_YES;
+  }
 
   pkt->dpt = htons (serv->remote_port);
 
@@ -1200,8 +1295,8 @@ receive_udp_service (void *cls __attribute__((unused)),
    * This will be saved in the hashmap, so that the receiving procedure knows
    * through which tunnel this connection has to be routed.
    */
-  struct redirect_state *state =
-    GNUNET_malloc (sizeof (struct redirect_state));
+  struct redirect_state *state = GNUNET_malloc (sizeof (struct redirect_state));
+
   memset (state, 0, sizeof (struct redirect_state));
   state->tunnel = tunnel;
   state->serv = serv;
@@ -1210,44 +1305,46 @@ receive_udp_service (void *cls __attribute__((unused)),
   memcpy (&state->desc, desc, sizeof (GNUNET_HashCode));
 
   len = sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) +
-    sizeof (struct ip6_hdr) + ntohs (pkt->len);
+      sizeof (struct ip6_hdr) + ntohs (pkt->len);
   buf = alloca (len);
 
   memset (buf, 0, len);
 
   switch (serv->version)
-    {
-    case 4:
-      prepare_ipv4_packet (len, ntohs (pkt->len), pkt, 0x11,    /* UDP */
-                           &serv->v4.ip4address,
-                           tunnel, state, (struct ip_pkt *) buf);
-      break;
-    case 6:
-      prepare_ipv6_packet (len, ntohs (pkt->len), pkt, 0x11,    /* UDP */
-                           &serv->v6.ip6address,
-                           tunnel, state, (struct ip6_pkt *) buf);
-
-      break;
-    default:
-      GNUNET_assert (0);
-      break;
-    }
-
-  hash_redirect_info(&state->hash, &state->redirect_info, serv->version == 4 ? 4 : 16);
+  {
+  case 4:
+    prepare_ipv4_packet (len, ntohs (pkt->len), pkt, 0x11,      /* UDP */
+                         &serv->v4.ip4address,
+                         tunnel, state, (struct ip_pkt *) buf);
+    break;
+  case 6:
+    prepare_ipv6_packet (len, ntohs (pkt->len), pkt, 0x11,      /* UDP */
+                         &serv->v6.ip6address,
+                         tunnel, state, (struct ip6_pkt *) buf);
+
+    break;
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+
+  hash_redirect_info (&state->hash, &state->redirect_info,
+                      serv->version == 4 ? 4 : 16);
 
   if (GNUNET_NO ==
       GNUNET_CONTAINER_multihashmap_contains (udp_connections, &state->hash))
-    {
-      GNUNET_CONTAINER_multihashmap_put (udp_connections, &state->hash, state,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  {
+    GNUNET_CONTAINER_multihashmap_put (udp_connections, &state->hash, state,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 
-      state->heap_node =
+    state->heap_node =
         GNUNET_CONTAINER_heap_insert (udp_connections_heap, state,
                                       GNUNET_TIME_absolute_get ().abs_value);
 
-      if (GNUNET_CONTAINER_heap_get_size(udp_connections_heap) > max_udp_connections)
-        GNUNET_SCHEDULER_add_now(collect_connections, udp_connections_heap);
-    }
+    if (GNUNET_CONTAINER_heap_get_size (udp_connections_heap) >
+        max_udp_connections)
+      GNUNET_SCHEDULER_add_now (collect_connections, udp_connections_heap);
+  }
   else
     GNUNET_free (state);
 
@@ -1256,13 +1353,13 @@ receive_udp_service (void *cls __attribute__((unused)),
 }
 
 static void
-connect_to_mesh()
+connect_to_mesh ()
 {
   int udp, tcp;
   int handler_idx, app_idx;
 
-  udp = GNUNET_CONFIGURATION_get_value_yesno(cfg, "exit", "ENABLE_UDP");
-  tcp = GNUNET_CONFIGURATION_get_value_yesno(cfg, "exit", "ENABLE_TCP");
+  udp = GNUNET_CONFIGURATION_get_value_yesno (cfg, "exit", "ENABLE_UDP");
+  tcp = GNUNET_CONFIGURATION_get_value_yesno (cfg, "exit", "ENABLE_TCP");
 
   static struct GNUNET_MESH_MessageHandler handlers[] = {
     {receive_udp_service, GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP, 0},
@@ -1272,35 +1369,34 @@ connect_to_mesh()
     {NULL, 0, 0}
   };
 
-  static GNUNET_MESH_ApplicationType apptypes[] =
-    {
-      GNUNET_APPLICATION_TYPE_END,
-      GNUNET_APPLICATION_TYPE_END,
-      GNUNET_APPLICATION_TYPE_END
-    };
+  static GNUNET_MESH_ApplicationType apptypes[] = {
+    GNUNET_APPLICATION_TYPE_END,
+    GNUNET_APPLICATION_TYPE_END,
+    GNUNET_APPLICATION_TYPE_END
+  };
 
   app_idx = 0;
   handler_idx = 2;
 
   if (GNUNET_YES == udp)
-    {
-      handlers[handler_idx].callback = receive_udp_remote;
-      handlers[handler_idx].expected_size = 0;
-      handlers[handler_idx].type = GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP;
-      apptypes[app_idx] = GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY;
-      handler_idx++;
-      app_idx++;
-    }
+  {
+    handlers[handler_idx].callback = receive_udp_remote;
+    handlers[handler_idx].expected_size = 0;
+    handlers[handler_idx].type = GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP;
+    apptypes[app_idx] = GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY;
+    handler_idx++;
+    app_idx++;
+  }
 
   if (GNUNET_YES == tcp)
-    {
-      handlers[handler_idx].callback = receive_tcp_remote;
-      handlers[handler_idx].expected_size = 0;
-      handlers[handler_idx].type = GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP;
-      apptypes[app_idx] = GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY;
-      handler_idx++;
-      app_idx++;
-    }
+  {
+    handlers[handler_idx].callback = receive_tcp_remote;
+    handlers[handler_idx].expected_size = 0;
+    handlers[handler_idx].type = GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP;
+    apptypes[app_idx] = GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY;
+    handler_idx++;
+    app_idx++;
+  }
 
   mesh_handle = GNUNET_MESH_connect (cfg, NULL, NULL, handlers, apptypes);
 }
@@ -1315,19 +1411,20 @@ connect_to_mesh()
  */
 static void
 run (void *cls,
-     char *const *args __attribute__((unused)),
-     const char *cfgfile __attribute__((unused)), const struct GNUNET_CONFIGURATION_Handle *cfg_)
+     char *const *args __attribute__ ((unused)),
+     const char *cfgfile
+     __attribute__ ((unused)), const struct GNUNET_CONFIGURATION_Handle *cfg_)
 {
   cfg = cfg_;
 
-  connect_to_mesh();
+  connect_to_mesh ();
 
   udp_connections = GNUNET_CONTAINER_multihashmap_create (65536);
   udp_connections_heap =
-    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   tcp_connections = GNUNET_CONTAINER_multihashmap_create (65536);
   tcp_connections_heap =
-    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   udp_services = GNUNET_CONTAINER_multihashmap_create (65536);
   tcp_services = GNUNET_CONTAINER_multihashmap_create (65536);
 
@@ -1350,18 +1447,18 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv) {
-    static const struct GNUNET_GETOPT_CommandLineOption options[] = {
-        GNUNET_GETOPT_OPTION_END
-    };
-
-    return (GNUNET_OK ==
-            GNUNET_PROGRAM_run (argc,
-                                argv,
-                                "exit",
-                                gettext_noop ("help text"),
-                                options, &run, NULL)) ? ret : 1;
+main (int argc, char *const *argv)
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "exit",
+                              gettext_noop ("help text"),
+                              options, &run, NULL)) ? ret : 1;
 }
 
 /* end of gnunet-daemon-exit.c */
-
diff --git a/src/vpn/gnunet-daemon-vpn-dns.c b/src/vpn/gnunet-daemon-vpn-dns.c
index 6ccef5869..d6f842e34 100644
--- a/src/vpn/gnunet-daemon-vpn-dns.c
+++ b/src/vpn/gnunet-daemon-vpn-dns.c
@@ -52,56 +52,67 @@ struct answer_packet_list *answer_proc_tail;
  * {{{
  */
 size_t
-send_query(void* cls __attribute__((unused)), size_t size, void* buf) {
-    size_t len;
+send_query (void *cls __attribute__ ((unused)), size_t size, void *buf)
+{
+  size_t len;
+
+  /*
+   * Send the rehijack-message
+   */
+  if (restart_hijack == 1)
+  {
+    restart_hijack = 0;
     /*
-     * Send the rehijack-message
+     * The message is just a header
      */
-    if (restart_hijack == 1)
-      {
-        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 (head != NULL)
-      {
-        struct query_packet_list* query = head;
-        len = ntohs(query->pkt.hdr.size);
-
-        GNUNET_assert(len <= size);
-
-        memcpy(buf, &query->pkt.hdr, len);
-
-        GNUNET_CONTAINER_DLL_remove (head, tail, query);
-
-        GNUNET_free(query);
-      }
-    else
-      {
-        GNUNET_break(0);
-        len = 0;
-      }
-
-    /*
-     * Check whether more data is to be sent
-     */
-    if (head != NULL)
-      {
-        GNUNET_CLIENT_notify_transmit_ready(dns_connection, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
-      }
-    else if (restart_hijack == 1)
-      {
-        GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
-      }
-
-    return len;
+    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 (head != NULL)
+  {
+    struct query_packet_list *query = head;
+
+    len = ntohs (query->pkt.hdr.size);
+
+    GNUNET_assert (len <= size);
+
+    memcpy (buf, &query->pkt.hdr, len);
+
+    GNUNET_CONTAINER_DLL_remove (head, tail, query);
+
+    GNUNET_free (query);
+  }
+  else
+  {
+    GNUNET_break (0);
+    len = 0;
+  }
+
+  /*
+   * Check whether more data is to be sent
+   */
+  if (head != NULL)
+  {
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
+                                         ntohs (head->pkt.hdr.size),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
+  }
+  else if (restart_hijack == 1)
+  {
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
+                                         sizeof (struct GNUNET_MessageHeader),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
+  }
+
+  return len;
 }
+
 /* }}} */
 
 
@@ -109,33 +120,37 @@ send_query(void* cls __attribute__((unused)), size_t size, void* buf) {
  * Connect to the service-dns
  */
 void
-connect_to_service_dns (void *cls __attribute__((unused)),
-                        const struct GNUNET_SCHEDULER_TaskContext *tc) {
-    conn_task = GNUNET_SCHEDULER_NO_TASK;
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      return;
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
-    GNUNET_assert (dns_connection == NULL);
-    dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
-    /* This would most likely be a misconfiguration */
-    GNUNET_assert(NULL != dns_connection);
-    GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
-
-    /* We might not yet be connected. Yay, mps. */
-    if (NULL == dns_connection) return;
-
-    /* If a packet is already in the list, schedule to send it */
-    if (head != NULL)
-      GNUNET_CLIENT_notify_transmit_ready(dns_connection,
-                                          ntohs(head->pkt.hdr.size),
-                                          GNUNET_TIME_UNIT_FOREVER_REL,
-                                          GNUNET_YES,
-                                          &send_query,
-                                          NULL);
-    else if (restart_hijack == 1)
-      {
-        GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
-      }
+connect_to_service_dns (void *cls __attribute__ ((unused)),
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  conn_task = GNUNET_SCHEDULER_NO_TASK;
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
+  GNUNET_assert (dns_connection == NULL);
+  dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
+  /* This would most likely be a misconfiguration */
+  GNUNET_assert (NULL != dns_connection);
+  GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+
+  /* We might not yet be connected. Yay, mps. */
+  if (NULL == dns_connection)
+    return;
+
+  /* If a packet is already in the list, schedule to send it */
+  if (head != NULL)
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
+                                         ntohs (head->pkt.hdr.size),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
+  else if (restart_hijack == 1)
+  {
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
+                                         sizeof (struct GNUNET_MessageHeader),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
+  }
 }
 
 /**
@@ -143,33 +158,34 @@ connect_to_service_dns (void *cls __attribute__((unused)),
  * handle it
  */
 void
-dns_answer_handler(void* cls __attribute__((unused)), const struct GNUNET_MessageHeader *msg) {
-    /* the service disconnected, reconnect after short wait */
-    if (msg == NULL)
-      {
-        GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
-        dns_connection = NULL;
-        conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                                  &connect_to_service_dns,
-                                                  NULL);
-        return;
-      }
-
-    /* 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(dns_connection, GNUNET_NO);
-        dns_connection = NULL;
-        conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns,
-                                              NULL);
-        return;
-      }
-    void *pkt = GNUNET_malloc(ntohs(msg->size));
-
-    memcpy(pkt, msg, ntohs(msg->size));
-
-    GNUNET_SCHEDULER_add_now(process_answer, pkt);
-    GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
+dns_answer_handler (void *cls
+                    __attribute__ ((unused)),
+                    const struct GNUNET_MessageHeader *msg)
+{
+  /* the service disconnected, reconnect after short wait */
+  if (msg == NULL)
+  {
+    GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
+    dns_connection = NULL;
+    conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                              &connect_to_service_dns, NULL);
+    return;
+  }
+
+  /* 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 (dns_connection, GNUNET_NO);
+    dns_connection = NULL;
+    conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns, NULL);
+    return;
+  }
+  void *pkt = GNUNET_malloc (ntohs (msg->size));
+
+  memcpy (pkt, msg, ntohs (msg->size));
+
+  GNUNET_SCHEDULER_add_now (process_answer, pkt);
+  GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
 }
-
diff --git a/src/vpn/gnunet-daemon-vpn-dns.h b/src/vpn/gnunet-daemon-vpn-dns.h
index ed980e65f..2882969e5 100644
--- a/src/vpn/gnunet-daemon-vpn-dns.h
+++ b/src/vpn/gnunet-daemon-vpn-dns.h
@@ -40,19 +40,19 @@ extern struct query_packet_list *tail;
  * Callback called by notify_transmit_ready; sends dns-queries or rehijack-messages
  * to the service-dns
  */
-size_t send_query(void* cls, size_t size, void* buf);
+size_t send_query (void *cls, size_t size, void *buf);
 
 /**
  * Connect to the service-dns
  */
 void connect_to_service_dns (void *cls,
-                             const struct GNUNET_SCHEDULER_TaskContext *tc);
+                             const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 /**
  * This receives packets from the service-dns and schedules process_answer to
  * handle it
  */
-void dns_answer_handler(void* cls, const struct GNUNET_MessageHeader *msg);
+void dns_answer_handler (void *cls, const struct GNUNET_MessageHeader *msg);
 
 /**
  * The connection to the service-dns
diff --git a/src/vpn/gnunet-daemon-vpn-helper.c b/src/vpn/gnunet-daemon-vpn-helper.c
index 05e2bd081..65e92b8f9 100644
--- a/src/vpn/gnunet-daemon-vpn-helper.c
+++ b/src/vpn/gnunet-daemon-vpn-helper.c
@@ -48,8 +48,8 @@ struct GNUNET_VPN_HELPER_Handle *helper_handle;
 /**
  * The tunnels that will be used to send tcp- and udp-packets
  */
-static struct GNUNET_MESH_Tunnel* tcp_tunnel;
-static struct GNUNET_MESH_Tunnel* udp_tunnel;
+static struct GNUNET_MESH_Tunnel *tcp_tunnel;
+static struct GNUNET_MESH_Tunnel *udp_tunnel;
 
 /**
  * Start the helper-process
@@ -59,542 +59,558 @@ static struct GNUNET_MESH_Tunnel* udp_tunnel;
  * {{{
  */
 void
-start_helper_and_schedule(void *cls,
-                          const struct GNUNET_SCHEDULER_TaskContext *tc) {
+start_helper_and_schedule (void *cls,
+                           const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
   shs_task = GNUNET_SCHEDULER_NO_TASK;
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      return;
-
-    if (cls != NULL)
-      cleanup_helper(cls);
-    cls = NULL;
-
-    char* ifname;
-    char* ipv6addr;
-    char* ipv6prefix;
-    char* ipv4addr;
-    char* ipv4mask;
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IFNAME", &ifname))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IFNAME' in configuration!\n");
-        exit(1);
-      }
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IPV6ADDR", &ipv6addr))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV6ADDR' in configuration!\n");
-        exit(1);
-      }
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IPV6PREFIX", &ipv6prefix))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV6PREFIX' in configuration!\n");
-        exit(1);
-      }
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IPV4ADDR", &ipv4addr))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV4ADDR' in configuration!\n");
-        exit(1);
-      }
-
-    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IPV4MASK", &ipv4mask))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No entry 'IPV4MASK' in configuration!\n");
-        exit(1);
-      }
-
-    /* Start the helper
-     * Messages get passed to the function message_token
-     * When the helper dies, this function will be called again with the
-     * helper_handle as cls.
-     */
-    helper_handle = start_helper(ifname,
-                                 ipv6addr,
-                                 ipv6prefix,
-                                 ipv4addr,
-                                 ipv4mask,
-                                 "vpn-gnunet",
-                                 start_helper_and_schedule,
-                                 message_token,
-                                 NULL);
-
-    GNUNET_free(ipv6addr);
-    GNUNET_free(ipv6prefix);
-    GNUNET_free(ipv4addr);
-    GNUNET_free(ipv4mask);
-    GNUNET_free(ifname);
-
-    /* Tell the dns-service to rehijack the dns-port
-     * The routing-table gets flushed if an interface disappears.
-     */
-    restart_hijack = 1;
-    if (NULL != dns_connection)
-      GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
-
-    GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, helper_handle->fh_to_helper, &helper_write, NULL);
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
+
+  if (cls != NULL)
+    cleanup_helper (cls);
+  cls = NULL;
+
+  char *ifname;
+  char *ipv6addr;
+  char *ipv6prefix;
+  char *ipv4addr;
+  char *ipv4mask;
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "IFNAME", &ifname))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IFNAME' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "IPV6ADDR", &ipv6addr))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV6ADDR' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "IPV6PREFIX",
+                                             &ipv6prefix))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV6PREFIX' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "IPV4ADDR", &ipv4addr))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV4ADDR' in configuration!\n");
+    exit (1);
+  }
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "IPV4MASK", &ipv4mask))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'IPV4MASK' in configuration!\n");
+    exit (1);
+  }
+
+  /* Start the helper
+   * Messages get passed to the function message_token
+   * When the helper dies, this function will be called again with the
+   * helper_handle as cls.
+   */
+  helper_handle = start_helper (ifname,
+                                ipv6addr,
+                                ipv6prefix,
+                                ipv4addr,
+                                ipv4mask,
+                                "vpn-gnunet",
+                                start_helper_and_schedule, message_token, NULL);
+
+  GNUNET_free (ipv6addr);
+  GNUNET_free (ipv6prefix);
+  GNUNET_free (ipv4addr);
+  GNUNET_free (ipv4mask);
+  GNUNET_free (ifname);
+
+  /* Tell the dns-service to rehijack the dns-port
+   * The routing-table gets flushed if an interface disappears.
+   */
+  restart_hijack = 1;
+  if (NULL != dns_connection)
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
+                                         sizeof (struct GNUNET_MessageHeader),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
+
+  GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                   helper_handle->fh_to_helper, &helper_write,
+                                   NULL);
 }
+
 /*}}}*/
 
 /**
  * Send an dns-answer-packet to the helper
  */
 void
-helper_write(void* cls __attribute__((unused)), const struct GNUNET_SCHEDULER_TaskContext* tsdkctx) {
-    if (tsdkctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)
-      return;
-
-    struct answer_packet_list* ans = answer_proc_head;
-
-    if (NULL == ans) return;
+helper_write (void *cls
+              __attribute__ ((unused)),
+              const struct GNUNET_SCHEDULER_TaskContext *tsdkctx)
+{
+  if (tsdkctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)
+    return;
+
+  struct answer_packet_list *ans = answer_proc_head;
+
+  if (NULL == ans)
+    return;
+
+  size_t len = ntohs (ans->pkt.hdr.size);
+
+  GNUNET_assert (ans->pkt.subtype == GNUNET_DNS_ANSWER_TYPE_IP);
+
+  GNUNET_assert (20 == sizeof (struct ip_hdr));
+  GNUNET_assert (8 == sizeof (struct udp_pkt));
+  size_t data_len = len - sizeof (struct answer_packet) + 1;
+  size_t net_len = sizeof (struct ip_hdr) + sizeof (struct udp_dns) + data_len;
+  size_t pkt_len =
+      sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) + net_len;
+
+  struct ip_udp_dns *pkt = alloca (pkt_len);
+
+  GNUNET_assert (pkt != NULL);
+  memset (pkt, 0, pkt_len);
+
+  /* set the gnunet-header */
+  pkt->shdr.size = htons (pkt_len);
+  pkt->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
+
+  /* set the tun-header (no flags and ethertype of IPv4) */
+  pkt->tun.flags = 0;
+  pkt->tun.type = htons (0x0800);
+
+  /* set the ip-header */
+  pkt->ip_hdr.version = 4;
+  pkt->ip_hdr.hdr_lngth = 5;
+  pkt->ip_hdr.diff_serv = 0;
+  pkt->ip_hdr.tot_lngth = htons (net_len);
+  pkt->ip_hdr.ident = 0;
+  pkt->ip_hdr.flags = 0;
+  pkt->ip_hdr.frag_off = 0;
+  pkt->ip_hdr.ttl = 255;
+  pkt->ip_hdr.proto = 0x11;     /* UDP */
+  pkt->ip_hdr.chks = 0;         /* Will be calculated later */
+  pkt->ip_hdr.sadr = ans->pkt.from;
+  pkt->ip_hdr.dadr = ans->pkt.to;
+
+  pkt->ip_hdr.chks = calculate_ip_checksum ((uint16_t *) & pkt->ip_hdr, 5 * 4);
+
+  /* set the udp-header */
+  pkt->udp_dns.udp_hdr.spt = htons (53);
+  pkt->udp_dns.udp_hdr.dpt = ans->pkt.dst_port;
+  pkt->udp_dns.udp_hdr.len = htons (net_len - sizeof (struct ip_hdr));
+  pkt->udp_dns.udp_hdr.crc = 0; /* Optional for IPv4 */
+
+  memcpy (&pkt->udp_dns.data, ans->pkt.data, data_len);
+
+  GNUNET_CONTAINER_DLL_remove (answer_proc_head, answer_proc_tail, ans);
+  GNUNET_free (ans);
+
+  if (GNUNET_DISK_file_write (helper_handle->fh_to_helper, pkt, pkt_len) < 0)
+  {
+    cleanup_helper (helper_handle);
+    GNUNET_SCHEDULER_add_now (start_helper_and_schedule, NULL);
+    return;
+  }
+
+  /* if more packets are available, reschedule */
+  if (answer_proc_head != NULL)
+    GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                     helper_handle->fh_to_helper,
+                                     &helper_write, NULL);
+}
 
-    size_t len = ntohs(ans->pkt.hdr.size);
+/**
+ * Receive packets from the helper-process
+ */
+void
+message_token (void *cls __attribute__ ((unused)),
+               void *client
+               __attribute__ ((unused)),
+               const struct GNUNET_MessageHeader *message)
+{
+  GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_HELPER);
 
-    GNUNET_assert(ans->pkt.subtype == GNUNET_DNS_ANSWER_TYPE_IP);
+  struct tun_pkt *pkt_tun = (struct tun_pkt *) message;
+  GNUNET_HashCode *key;
 
-    GNUNET_assert (20 == sizeof (struct ip_hdr));
-    GNUNET_assert (8 == sizeof (struct udp_pkt));
-    size_t data_len = len - sizeof(struct answer_packet) + 1;
-    size_t net_len = sizeof(struct ip_hdr) + sizeof(struct udp_dns) + data_len;
-    size_t pkt_len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct pkt_tun) + net_len;
+  /* ethertype is ipv6 */
+  if (ntohs (pkt_tun->tun.type) == 0x86dd)
+  {
+    struct ip6_pkt *pkt6 = (struct ip6_pkt *) message;
 
-    struct ip_udp_dns* pkt = alloca(pkt_len);
-    GNUNET_assert(pkt != NULL);
-    memset(pkt, 0, pkt_len);
+    GNUNET_assert (pkt6->ip6_hdr.version == 6);
+    struct ip6_tcp *pkt6_tcp;
+    struct ip6_udp *pkt6_udp;
+    struct ip6_icmp *pkt6_icmp;
 
-    /* set the gnunet-header */
-    pkt->shdr.size = htons(pkt_len);
-    pkt->shdr.type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER);
+    switch (pkt6->ip6_hdr.nxthdr)
+    {
+    case 0x06:                 /* TCP */
+    case 0x11:                 /* UDP */
+      pkt6_tcp = (struct ip6_tcp *) pkt6;
+      pkt6_udp = (struct ip6_udp *) pkt6;
 
-    /* set the tun-header (no flags and ethertype of IPv4) */
-    pkt->tun.flags = 0;
-    pkt->tun.type = htons(0x0800);
+      if ((key = address6_mapping_exists (pkt6->ip6_hdr.dadr)) != NULL)
+      {
+        struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
 
-    /* set the ip-header */
-    pkt->ip_hdr.version = 4;
-    pkt->ip_hdr.hdr_lngth = 5;
-    pkt->ip_hdr.diff_serv = 0;
-    pkt->ip_hdr.tot_lngth = htons(net_len);
-    pkt->ip_hdr.ident = 0;
-    pkt->ip_hdr.flags = 0;
-    pkt->ip_hdr.frag_off = 0;
-    pkt->ip_hdr.ttl = 255;
-    pkt->ip_hdr.proto = 0x11; /* UDP */
-    pkt->ip_hdr.chks = 0; /* Will be calculated later*/
-    pkt->ip_hdr.sadr = ans->pkt.from;
-    pkt->ip_hdr.dadr = ans->pkt.to;
+        GNUNET_assert (me != NULL);
+        GNUNET_free (key);
 
-    pkt->ip_hdr.chks = calculate_ip_checksum((uint16_t*)&pkt->ip_hdr, 5*4);
+        size_t size =
+            sizeof (struct GNUNET_MESH_Tunnel *) +
+            sizeof (struct GNUNET_MessageHeader) +
+            sizeof (GNUNET_HashCode) + ntohs (pkt6->ip6_hdr.paylgth);
 
-    /* set the udp-header */
-    pkt->udp_dns.udp_hdr.spt = htons(53);
-    pkt->udp_dns.udp_hdr.dpt = ans->pkt.dst_port;
-    pkt->udp_dns.udp_hdr.len = htons(net_len - sizeof(struct ip_hdr));
-    pkt->udp_dns.udp_hdr.crc = 0; /* Optional for IPv4 */
+        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(&pkt->udp_dns.data, ans->pkt.data, data_len);
+        hdr->size = htons (sizeof (struct GNUNET_MessageHeader) +
+                           sizeof (GNUNET_HashCode) +
+                           ntohs (pkt6->ip6_hdr.paylgth));
 
-    GNUNET_CONTAINER_DLL_remove (answer_proc_head, answer_proc_tail, ans);
-    GNUNET_free(ans);
+        GNUNET_MESH_ApplicationType app_type;
 
-    if (GNUNET_DISK_file_write(helper_handle->fh_to_helper, pkt, pkt_len) < 0)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "me->addrlen is %d\n",
+                    me->addrlen);
+        if (me->addrlen == 0)
+        {
+          /* This is a mapping to a gnunet-service */
+          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_VPN_SERVICE_UDP);
+
+            memcpy (hc + 1, &pkt6_udp->udp_hdr, ntohs (pkt6_udp->udp_hdr.len));
+
+          }
+          else if (0x06 == 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)))
+          {
+            hdr->type = ntohs (GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP);
+
+            memcpy (hc + 1, &pkt6_tcp->tcp_hdr, ntohs (pkt6->ip6_hdr.paylgth));
+
+          }
+          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, type %d\n",
+                        *((unsigned int *) &me->desc.peer), ntohs (hdr->type));
+          }
+        }
+        else
+        {
+          /* This is a mapping to a "real" address */
+          struct remote_addr *s = (struct remote_addr *) hc;
+
+          s->addrlen = me->addrlen;
+          memcpy (s->addr, me->addr, me->addrlen);
+          s->proto = pkt6->ip6_hdr.nxthdr;
+          if (s->proto == 0x11)
+          {
+            hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP);
+            memcpy (hc + 1, &pkt6_udp->udp_hdr, ntohs (pkt6_udp->udp_hdr.len));
+            app_type = GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY;
+            if (NULL != udp_tunnel)
+              me->tunnel = udp_tunnel;
+          }
+          else if (s->proto == 0x06)
+          {
+            hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP);
+            memcpy (hc + 1, &pkt6_tcp->tcp_hdr, ntohs (pkt6->ip6_hdr.paylgth));
+            app_type = GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY;
+            if (NULL != tcp_tunnel)
+              me->tunnel = tcp_tunnel;
+          }
+          if (me->tunnel == NULL && NULL != cls)
+          {
+            *cls = GNUNET_MESH_peer_request_connect_by_type (mesh_handle,
+                                                             GNUNET_TIME_UNIT_FOREVER_REL,
+                                                             app_type,
+                                                             send_pkt_to_peer,
+                                                             NULL, cls);
+            me->tunnel = *cls;
+            if (GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY == app_type)
+              udp_tunnel = *cls;
+            else if (GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY == app_type)
+              tcp_tunnel = *cls;
+          }
+          else if (NULL != cls)
+          {
+            *cls = me->tunnel;
+            send_pkt_to_peer (cls, (struct GNUNET_PeerIdentity *) 1, NULL);
+          }
+        }
+      }
+      else
       {
-        cleanup_helper(helper_handle);
-        GNUNET_SCHEDULER_add_now(start_helper_and_schedule, NULL);
-        return;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Packet to %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x, which has no mapping\n",
+                    pkt6->ip6_hdr.dadr[0], pkt6->ip6_hdr.dadr[1],
+                    pkt6->ip6_hdr.dadr[2], pkt6->ip6_hdr.dadr[3],
+                    pkt6->ip6_hdr.dadr[4], pkt6->ip6_hdr.dadr[5],
+                    pkt6->ip6_hdr.dadr[6], pkt6->ip6_hdr.dadr[7],
+                    pkt6->ip6_hdr.dadr[8], pkt6->ip6_hdr.dadr[9],
+                    pkt6->ip6_hdr.dadr[10], pkt6->ip6_hdr.dadr[11],
+                    pkt6->ip6_hdr.dadr[12], pkt6->ip6_hdr.dadr[13],
+                    pkt6->ip6_hdr.dadr[14], pkt6->ip6_hdr.dadr[15]);
       }
+      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 = address6_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_icmp6_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;
+    struct ip_tcp *pkt_tcp;
+    struct ip_udp *pkt_udp;
+    struct ip_icmp *pkt_icmp;
 
-    /* if more packets are available, reschedule */
-    if (answer_proc_head != NULL)
-      GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                       helper_handle->fh_to_helper,
-                                       &helper_write,
-                                       NULL);
-}
-
-/**
- * Receive packets from the helper-process
- */
-void
-message_token (void *cls __attribute__((unused)),
-               void *client __attribute__((unused)), const struct GNUNET_MessageHeader *message)
-{
-  GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_HELPER);
-
-  struct tun_pkt *pkt_tun = (struct tun_pkt *) message;
-  GNUNET_HashCode *key;
+    GNUNET_assert (pkt->ip_hdr.version == 4);
 
-  /* ethertype is ipv6 */
-  if (ntohs (pkt_tun->tun.type) == 0x86dd)
+    /* Send dns-packets to the service-dns */
+    if (pkt->ip_hdr.proto == 0x11 && ntohs (udp->udp_hdr.dpt) == 53)
     {
-      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;
+      /* 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_VPN_DNS_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);
+    }
+    else
+    {
+      uint32_t dadr = pkt->ip_hdr.dadr;
+      unsigned char *c = (unsigned char *) &dadr;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Packet to %d.%d.%d.%d, proto %x\n",
+                  c[0], c[1], c[2], c[3], pkt->ip_hdr.proto);
+      switch (pkt->ip_hdr.proto)
+      {
+      case 0x06:               /* TCP */
+      case 0x11:               /* UDP */
+        pkt_tcp = (struct ip_tcp *) pkt;
+        pkt_udp = (struct ip_udp *) pkt;
 
-      switch (pkt6->ip6_hdr.nxthdr)
+        if ((key = address4_mapping_exists (dadr)) != NULL)
         {
-        case 0x06:             /* TCP */
-        case 0x11:             /* UDP */
-          pkt6_tcp = (struct ip6_tcp *) pkt6;
-          pkt6_udp = (struct ip6_udp *) pkt6;
+          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 (pkt->ip_hdr.tot_lngth) -
+              4 * pkt->ip_hdr.hdr_lngth;
+
+          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 (pkt->ip_hdr.tot_lngth) -
+                     4 * pkt->ip_hdr.hdr_lngth);
+
+          GNUNET_MESH_ApplicationType app_type;
+
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "me->addrlen is %d\n",
+                      me->addrlen);
+          if (me->addrlen == 0)
+          {
+            /* This is a mapping to a gnunet-service */
+            memcpy (hc, &me->desc.service_descriptor, sizeof (GNUNET_HashCode));
+
+            if (0x11 == pkt->ip_hdr.proto
+                && (me->desc.service_type & htonl (GNUNET_DNS_SERVICE_TYPE_UDP))
+                && (port_in_ports (me->desc.ports, pkt_udp->udp_hdr.dpt)
+                    || testBit (me->additional_ports,
+                                ntohs (pkt_udp->udp_hdr.dpt))))
+            {
+              hdr->type = ntohs (GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP);
+
+              memcpy (hc + 1, &pkt_udp->udp_hdr, ntohs (pkt_udp->udp_hdr.len));
 
-          if ((key = address6_mapping_exists (pkt6->ip6_hdr.dadr)) != NULL)
+            }
+            else if (0x06 == pkt->ip_hdr.proto
+                     && (me->desc.service_type &
+                         htonl (GNUNET_DNS_SERVICE_TYPE_TCP)) &&
+                     (port_in_ports (me->desc.ports, pkt_tcp->tcp_hdr.dpt)))
+            {
+              hdr->type = ntohs (GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP);
+
+              memcpy (hc + 1, &pkt_tcp->tcp_hdr,
+                      ntohs (pkt->ip_hdr.tot_lngth) -
+                      4 * pkt->ip_hdr.hdr_lngth);
+
+            }
+            if (me->tunnel == NULL && NULL != cls)
             {
-              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));
-
-              GNUNET_MESH_ApplicationType app_type;
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "me->addrlen is %d\n", me->addrlen);
-              if (me->addrlen == 0)
-                {
-                  /* This is a mapping to a gnunet-service */
-                  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_VPN_SERVICE_UDP);
-
-                      memcpy (hc + 1, &pkt6_udp->udp_hdr,
-                              ntohs (pkt6_udp->udp_hdr.len));
-
-                    }
-                  else if (0x06 == 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)))
-                    {
-                      hdr->type = ntohs (GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP);
-
-                      memcpy (hc + 1, &pkt6_tcp->tcp_hdr,
-                              ntohs (pkt6->ip6_hdr.paylgth));
-
-                    }
-                  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, type %d\n",
-                                  *((unsigned int *) &me->desc.peer), ntohs(hdr->type));
-                    }
-                }
-              else
-                {
-                  /* This is a mapping to a "real" address */
-                  struct remote_addr *s = (struct remote_addr*) hc;
-                  s->addrlen = me->addrlen;
-                  memcpy(s->addr, me->addr, me->addrlen);
-                  s->proto= pkt6->ip6_hdr.nxthdr;
-                  if (s->proto == 0x11)
-                    {
-                      hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP);
-                      memcpy (hc + 1, &pkt6_udp->udp_hdr,
-                              ntohs (pkt6_udp->udp_hdr.len));
-                      app_type = GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY;
-                      if (NULL != udp_tunnel)
-                        me->tunnel = udp_tunnel;
-                    }
-                  else if (s->proto == 0x06)
-                    {
-                      hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP);
-                      memcpy (hc + 1, &pkt6_tcp->tcp_hdr,
-                              ntohs (pkt6->ip6_hdr.paylgth));
-                      app_type = GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY;
-                      if (NULL != tcp_tunnel)
-                        me->tunnel = tcp_tunnel;
-                    }
-                  if (me->tunnel == NULL && NULL != cls)
-                    {
-                      *cls = GNUNET_MESH_peer_request_connect_by_type(mesh_handle,
-                                                                      GNUNET_TIME_UNIT_FOREVER_REL,
-                                                                      app_type,
-                                                                      send_pkt_to_peer,
-                                                                      NULL,
-                                                                      cls);
-                      me->tunnel = *cls;
-                      if (GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY == app_type)
-                        udp_tunnel = *cls;
-                      else if (GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY == app_type)
-                        tcp_tunnel = *cls;
-                    }
-                  else if (NULL != cls)
-                    {
-                      *cls = me->tunnel;
-                      send_pkt_to_peer(cls, (struct GNUNET_PeerIdentity*) 1, NULL);
-                    }
-                }
+              *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, type %d\n",
+                          *((unsigned int *) &me->desc.peer),
+                          ntohs (hdr->type));
+            }
+          }
           else
+          {
+            /* This is a mapping to a "real" address */
+            struct remote_addr *s = (struct remote_addr *) hc;
+
+            s->addrlen = me->addrlen;
+            memcpy (s->addr, me->addr, me->addrlen);
+            s->proto = pkt->ip_hdr.proto;
+            if (s->proto == 0x11)
+            {
+              hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP);
+              memcpy (hc + 1, &pkt_udp->udp_hdr, ntohs (pkt_udp->udp_hdr.len));
+              app_type = GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY;
+            }
+            else if (s->proto == 0x06)
+            {
+              hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP);
+              memcpy (hc + 1, &pkt_tcp->tcp_hdr,
+                      ntohs (pkt->ip_hdr.tot_lngth) -
+                      4 * pkt->ip_hdr.hdr_lngth);
+              app_type = GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY;
+            }
+            if (me->tunnel == NULL && NULL != cls)
             {
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packet to %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x, which has no mapping\n", pkt6->ip6_hdr.dadr[0],
-                         pkt6->ip6_hdr.dadr[1],
-                         pkt6->ip6_hdr.dadr[2],
-                         pkt6->ip6_hdr.dadr[3],
-                         pkt6->ip6_hdr.dadr[4],
-                         pkt6->ip6_hdr.dadr[5],
-                         pkt6->ip6_hdr.dadr[6],
-                         pkt6->ip6_hdr.dadr[7],
-                         pkt6->ip6_hdr.dadr[8],
-                         pkt6->ip6_hdr.dadr[9],
-                         pkt6->ip6_hdr.dadr[10],
-                         pkt6->ip6_hdr.dadr[11],
-                         pkt6->ip6_hdr.dadr[12],
-                         pkt6->ip6_hdr.dadr[13],
-                         pkt6->ip6_hdr.dadr[14],
-                         pkt6->ip6_hdr.dadr[15]);
+              *cls = GNUNET_MESH_peer_request_connect_by_type (mesh_handle,
+                                                               GNUNET_TIME_UNIT_FOREVER_REL,
+                                                               app_type,
+                                                               send_pkt_to_peer,
+                                                               NULL, cls);
+              me->tunnel = *cls;
             }
-          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 = address6_mapping_exists (pkt6->ip6_hdr.dadr)) != NULL)
+            else if (NULL != cls)
             {
-              GNUNET_free (key);
-              pkt6_icmp = GNUNET_malloc (ntohs (pkt6->shdr.size));
-              memcpy (pkt6_icmp, pkt6, ntohs (pkt6->shdr.size));
-              GNUNET_SCHEDULER_add_now (&send_icmp6_response, pkt6_icmp);
+              *cls = me->tunnel;
+              send_pkt_to_peer (cls, (struct GNUNET_PeerIdentity *) 1, NULL);
             }
-          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;
-      struct ip_tcp *pkt_tcp;
-      struct ip_udp *pkt_udp;
-      struct ip_icmp *pkt_icmp;
-      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)
+        else
         {
-          /* 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_VPN_DNS_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);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Packet to %x which has no mapping\n", dadr);
         }
-      else
+        break;
+      case 0x01:
+        /* ICMP */
+        pkt_icmp = (struct ip_icmp *) pkt;
+        if (pkt_icmp->icmp_hdr.type == 0x8 &&
+            (key = address4_mapping_exists (dadr)) != NULL)
         {
-          uint32_t dadr = pkt->ip_hdr.dadr;
-          unsigned char *c = (unsigned char*)&dadr;
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packet to %d.%d.%d.%d, proto %x\n",
-                     c[0],
-                     c[1],
-                     c[2],
-                     c[3],
-                     pkt->ip_hdr.proto);
-          switch (pkt->ip_hdr.proto)
-            {
-            case 0x06: /* TCP */
-            case 0x11: /* UDP */
-              pkt_tcp = (struct ip_tcp*) pkt;
-              pkt_udp = (struct ip_udp*) pkt;
-
-              if ((key = address4_mapping_exists (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 (pkt->ip_hdr.tot_lngth) - 4*pkt->ip_hdr.hdr_lngth;
-
-                  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 (pkt->ip_hdr.tot_lngth) - 4*pkt->ip_hdr.hdr_lngth);
-
-                  GNUNET_MESH_ApplicationType app_type;
-                  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "me->addrlen is %d\n", me->addrlen);
-                  if (me->addrlen == 0)
-                    {
-                      /* This is a mapping to a gnunet-service */
-                      memcpy (hc, &me->desc.service_descriptor,
-                              sizeof (GNUNET_HashCode));
-
-                      if (0x11 == pkt->ip_hdr.proto
-                          && (me->desc.
-                              service_type & htonl (GNUNET_DNS_SERVICE_TYPE_UDP))
-                          && (port_in_ports (me->desc.ports, pkt_udp->udp_hdr.dpt)
-                              || testBit (me->additional_ports,
-                                          ntohs (pkt_udp->udp_hdr.dpt))))
-                        {
-                          hdr->type = ntohs (GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP);
-
-                          memcpy (hc + 1, &pkt_udp->udp_hdr,
-                                  ntohs (pkt_udp->udp_hdr.len));
-
-                        }
-                      else if (0x06 == pkt->ip_hdr.proto
-                               && (me->desc.
-                                   service_type & htonl (GNUNET_DNS_SERVICE_TYPE_TCP))
-                               &&
-                               (port_in_ports (me->desc.ports, pkt_tcp->tcp_hdr.dpt)))
-                        {
-                          hdr->type = ntohs (GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP);
-
-                          memcpy (hc + 1, &pkt_tcp->tcp_hdr,
-                                  ntohs (pkt->ip_hdr.tot_lngth) - 4*pkt->ip_hdr.hdr_lngth);
-
-                        }
-                      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, type %d\n",
-                                      *((unsigned int *) &me->desc.peer), ntohs(hdr->type));
-                        }
-                    }
-                  else
-                    {
-                      /* This is a mapping to a "real" address */
-                      struct remote_addr *s = (struct remote_addr*) hc;
-                      s->addrlen = me->addrlen;
-                      memcpy(s->addr, me->addr, me->addrlen);
-                      s->proto= pkt->ip_hdr.proto;
-                      if (s->proto == 0x11)
-                        {
-                          hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP);
-                          memcpy (hc + 1, &pkt_udp->udp_hdr,
-                                  ntohs (pkt_udp->udp_hdr.len));
-                          app_type = GNUNET_APPLICATION_TYPE_INTERNET_UDP_GATEWAY;
-                        }
-                      else if (s->proto == 0x06)
-                        {
-                          hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP);
-                          memcpy (hc + 1, &pkt_tcp->tcp_hdr,
-                              ntohs (pkt->ip_hdr.tot_lngth) - 4*pkt->ip_hdr.hdr_lngth);
-                          app_type = GNUNET_APPLICATION_TYPE_INTERNET_TCP_GATEWAY;
-                        }
-                      if (me->tunnel == NULL && NULL != cls)
-                        {
-                          *cls = GNUNET_MESH_peer_request_connect_by_type(mesh_handle,
-                                                                          GNUNET_TIME_UNIT_FOREVER_REL,
-                                                                          app_type,
-                                                                          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);
-                        }
-                    }
-                }
-              else
-                {
-                  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packet to %x which has no mapping\n", dadr);
-                }
-              break;
-            case 0x01:
-              /* ICMP */
-              pkt_icmp = (struct ip_icmp*)pkt;
-              if (pkt_icmp->icmp_hdr.type == 0x8 &&
-                (key = address4_mapping_exists (dadr)) != NULL)
-                {
-                  GNUNET_free(key);
-                  pkt_icmp = GNUNET_malloc(ntohs(pkt->shdr.size));
-                  memcpy(pkt_icmp, pkt, ntohs(pkt->shdr.size));
-                  GNUNET_SCHEDULER_add_now (&send_icmp4_response, pkt_icmp);
-                }
-              break;
-            }
+          GNUNET_free (key);
+          pkt_icmp = GNUNET_malloc (ntohs (pkt->shdr.size));
+          memcpy (pkt_icmp, pkt, ntohs (pkt->shdr.size));
+          GNUNET_SCHEDULER_add_now (&send_icmp4_response, pkt_icmp);
         }
+        break;
+      }
     }
+  }
 }
 
-void write_to_helper(void* buf, size_t len)
+void
+write_to_helper (void *buf, size_t len)
 {
-  (void)GNUNET_DISK_file_write(helper_handle->fh_to_helper, buf, len);
+  (void) GNUNET_DISK_file_write (helper_handle->fh_to_helper, buf, len);
 }
 
-void schedule_helper_write(struct GNUNET_TIME_Relative time, void* cls)
+void
+schedule_helper_write (struct GNUNET_TIME_Relative time, void *cls)
 {
-  if (GNUNET_SCHEDULER_NO_TASK != shs_task) return;
-  GNUNET_SCHEDULER_add_write_file (time, helper_handle->fh_to_helper, &helper_write, cls);
+  if (GNUNET_SCHEDULER_NO_TASK != shs_task)
+    return;
+  GNUNET_SCHEDULER_add_write_file (time, helper_handle->fh_to_helper,
+                                   &helper_write, cls);
 }
diff --git a/src/vpn/gnunet-daemon-vpn-helper.h b/src/vpn/gnunet-daemon-vpn-helper.h
index 85436e2cd..963fafd09 100644
--- a/src/vpn/gnunet-daemon-vpn-helper.h
+++ b/src/vpn/gnunet-daemon-vpn-helper.h
@@ -38,33 +38,35 @@ extern GNUNET_SCHEDULER_TaskIdentifier shs_task;
 /**
  * Start the helper-process
  */
-void start_helper_and_schedule(void *cls,
-                               const struct GNUNET_SCHEDULER_TaskContext *tc);
+void start_helper_and_schedule (void *cls,
+                                const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 /**
  * Restart the helper-process
  */
-void restart_helper(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tskctx);
+void restart_helper (void *cls,
+                     const struct GNUNET_SCHEDULER_TaskContext *tskctx);
 
 /**
  * Read from the helper-process
  */
-void helper_read(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tsdkctx);
+void helper_read (void *cls,
+                  const struct GNUNET_SCHEDULER_TaskContext *tsdkctx);
 
 /**
  * Send an dns-answer-packet to the helper
  */
-void helper_write(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tsdkctx);
+void helper_write (void *cls,
+                   const struct GNUNET_SCHEDULER_TaskContext *tsdkctx);
 
 /**
  * Receive packets from the helper-process
  */
-void message_token(void *cls,
-                   void *client,
-                   const struct GNUNET_MessageHeader *message);
+void message_token (void *cls,
+                    void *client, const struct GNUNET_MessageHeader *message);
 
-void write_to_helper(void* buf, size_t len);
+void write_to_helper (void *buf, size_t len);
 
-void schedule_helper_write(struct GNUNET_TIME_Relative, void* cls);
+void schedule_helper_write (struct GNUNET_TIME_Relative, void *cls);
 
 #endif /* end of include guard: GNUNET-DAEMON-VPN-HELPER_H */
diff --git a/src/vpn/gnunet-daemon-vpn.c b/src/vpn/gnunet-daemon-vpn.c
index 15ed379df..3673b72c6 100644
--- a/src/vpn/gnunet-daemon-vpn.c
+++ b/src/vpn/gnunet-daemon-vpn.c
@@ -42,15 +42,15 @@
 
 const struct GNUNET_CONFIGURATION_Handle *cfg;
 struct GNUNET_MESH_Handle *mesh_handle;
-struct GNUNET_CONTAINER_MultiHashMap* hashmap;
+struct GNUNET_CONTAINER_MultiHashMap *hashmap;
 static struct GNUNET_CONTAINER_Heap *heap;
 
 struct tunnel_notify_queue
 {
-  struct tunnel_notify_queue* next;
-  struct tunnel_notify_queue* prev;
+  struct tunnel_notify_queue *next;
+  struct tunnel_notify_queue *prev;
   size_t len;
-  void* cls;
+  void *cls;
 };
 
 /**
@@ -78,56 +78,63 @@ GNUNET_SCHEDULER_TaskIdentifier shs_task;
  *{{{
  */
 static void
-cleanup(void* cls __attribute__((unused)), const struct GNUNET_SCHEDULER_TaskContext* tskctx) {
-    GNUNET_assert (0 != (tskctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
-
-    /* stop the helper */
-    cleanup_helper(helper_handle);
-
-    /* close the connection to the service-dns */
-    if (dns_connection != NULL)
-      {
-        GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
-        dns_connection = NULL;
-      }
-
-    if (mesh_handle != NULL)
-      {
-        GNUNET_MESH_disconnect(mesh_handle);
-        mesh_handle = NULL;
-      }
-    if (GNUNET_SCHEDULER_NO_TASK != shs_task)
-      {
-        GNUNET_SCHEDULER_cancel (shs_task);
-        shs_task = GNUNET_SCHEDULER_NO_TASK;
-      }
-    if (GNUNET_SCHEDULER_NO_TASK != conn_task)
-      {
-        GNUNET_SCHEDULER_cancel (conn_task);
-        conn_task = GNUNET_SCHEDULER_NO_TASK;
-      }
+cleanup (void *cls
+         __attribute__ ((unused)),
+         const struct GNUNET_SCHEDULER_TaskContext *tskctx)
+{
+  GNUNET_assert (0 != (tskctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
+
+  /* stop the helper */
+  cleanup_helper (helper_handle);
+
+  /* close the connection to the service-dns */
+  if (dns_connection != NULL)
+  {
+    GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
+    dns_connection = NULL;
+  }
+
+  if (mesh_handle != NULL)
+  {
+    GNUNET_MESH_disconnect (mesh_handle);
+    mesh_handle = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != shs_task)
+  {
+    GNUNET_SCHEDULER_cancel (shs_task);
+    shs_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != conn_task)
+  {
+    GNUNET_SCHEDULER_cancel (conn_task);
+    conn_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 }
+
 /*}}}*/
 
 /**
  * @return the hash of the IP-Address if a mapping exists, NULL otherwise
  */
-GNUNET_HashCode*
-address6_mapping_exists(unsigned char addr[]) {
-    GNUNET_HashCode* key = GNUNET_malloc(sizeof(GNUNET_HashCode));
-    unsigned char* k = (unsigned char*)key;
-    memset(key, 0, sizeof(GNUNET_HashCode));
-    unsigned int i;
-    for (i = 0; i < 16; i++)
-        k[15-i] = addr[i];
+GNUNET_HashCode *
+address6_mapping_exists (unsigned char addr[])
+{
+  GNUNET_HashCode *key = GNUNET_malloc (sizeof (GNUNET_HashCode));
+  unsigned char *k = (unsigned char *) key;
 
-    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(hashmap, key))
-      return key;
-    else
-      {
-        GNUNET_free(key);
-        return NULL;
-      }
+  memset (key, 0, sizeof (GNUNET_HashCode));
+  unsigned int i;
+
+  for (i = 0; i < 16; i++)
+    k[15 - i] = addr[i];
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (hashmap, key))
+    return key;
+  else
+  {
+    GNUNET_free (key);
+    return NULL;
+  }
 }
 
 /**
@@ -137,10 +144,12 @@ GNUNET_HashCode *
 address4_mapping_exists (uint32_t addr)
 {
   GNUNET_HashCode *key = GNUNET_malloc (sizeof (GNUNET_HashCode));
+
   memset (key, 0, sizeof (GNUNET_HashCode));
   unsigned char *c = (unsigned char *) &addr;
   unsigned char *k = (unsigned char *) key;
   unsigned int i;
+
   for (i = 0; i < 4; i++)
     k[3 - i] = c[i];
 
@@ -151,106 +160,116 @@ address4_mapping_exists (uint32_t addr)
   if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (hashmap, key))
     return key;
   else
-    {
-      GNUNET_free (key);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Mapping not found!\n");
-      return NULL;
-    }
+  {
+    GNUNET_free (key);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Mapping not found!\n");
+    return NULL;
+  }
 }
 
 static void
-collect_mappings(void* cls __attribute__((unused)), const struct GNUNET_SCHEDULER_TaskContext* tc) {
-    if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-      return;
+collect_mappings (void *cls
+                  __attribute__ ((unused)),
+                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
 
-    struct map_entry* me = GNUNET_CONTAINER_heap_remove_root(heap);
+  struct map_entry *me = GNUNET_CONTAINER_heap_remove_root (heap);
 
-    /* This is free()ed memory! */
-    me->heap_node = NULL;
+  /* This is free()ed memory! */
+  me->heap_node = NULL;
 
-    /* FIXME! GNUNET_MESH_close_tunnel(me->tunnel); */
+  /* FIXME! GNUNET_MESH_close_tunnel(me->tunnel); */
 
-    GNUNET_CONTAINER_multihashmap_remove(hashmap, &me->hash, me);
+  GNUNET_CONTAINER_multihashmap_remove (hashmap, &me->hash, me);
 
-    GNUNET_free(me);
+  GNUNET_free (me);
 }
 
 void
-send_icmp4_response(void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc) {
-    if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-      return;
+send_icmp4_response (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
+
+  struct ip_icmp *request = cls;
 
-    struct ip_icmp* request = cls;
+  struct ip_icmp *response = alloca (ntohs (request->shdr.size));
 
-    struct ip_icmp* response = alloca(ntohs(request->shdr.size));
-    GNUNET_assert(response != NULL);
-    memset(response, 0, ntohs(request->shdr.size));
+  GNUNET_assert (response != NULL);
+  memset (response, 0, ntohs (request->shdr.size));
 
-    response->shdr.size = request->shdr.size;
-    response->shdr.type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER);
+  response->shdr.size = request->shdr.size;
+  response->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
 
-    response->tun.flags = 0;
-    response->tun.type = htons(0x0800);
+  response->tun.flags = 0;
+  response->tun.type = htons (0x0800);
 
-    response->ip_hdr.hdr_lngth = 5;
-    response->ip_hdr.version = 4;
-    response->ip_hdr.proto = 0x01;
-    response->ip_hdr.dadr = request->ip_hdr.sadr;
-    response->ip_hdr.sadr = request->ip_hdr.dadr;
-    response->ip_hdr.tot_lngth = request->ip_hdr.tot_lngth;
+  response->ip_hdr.hdr_lngth = 5;
+  response->ip_hdr.version = 4;
+  response->ip_hdr.proto = 0x01;
+  response->ip_hdr.dadr = request->ip_hdr.sadr;
+  response->ip_hdr.sadr = request->ip_hdr.dadr;
+  response->ip_hdr.tot_lngth = request->ip_hdr.tot_lngth;
 
-    response->ip_hdr.chks = calculate_ip_checksum((uint16_t*)&response->ip_hdr, 20);
+  response->ip_hdr.chks =
+      calculate_ip_checksum ((uint16_t *) & response->ip_hdr, 20);
 
-    response->icmp_hdr.code = 0;
-    response->icmp_hdr.type = 0x0;
+  response->icmp_hdr.code = 0;
+  response->icmp_hdr.type = 0x0;
 
-    /* Magic, more Magic! */
-    response->icmp_hdr.chks = request->icmp_hdr.chks + 0x8;
+  /* Magic, more Magic! */
+  response->icmp_hdr.chks = request->icmp_hdr.chks + 0x8;
 
-    /* Copy the rest of the packet */
-    memcpy(response+1, request+1, ntohs(request->shdr.size) - sizeof(struct ip_icmp));
+  /* Copy the rest of the packet */
+  memcpy (response + 1, request + 1,
+          ntohs (request->shdr.size) - sizeof (struct ip_icmp));
 
-    write_to_helper(response, ntohs(response->shdr.size));
+  write_to_helper (response, ntohs (response->shdr.size));
 
-    GNUNET_free(request);
+  GNUNET_free (request);
 }
 
 void
-send_icmp6_response(void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc) {
-    if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-      return;
+send_icmp6_response (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
+
+  struct ip6_icmp *request = cls;
 
-    struct ip6_icmp* request = cls;
+  struct ip6_icmp *response = alloca (ntohs (request->shdr.size));
 
-    struct ip6_icmp* response = alloca(ntohs(request->shdr.size));
-    GNUNET_assert(response != NULL);
-    memset(response, 0, ntohs(request->shdr.size));
+  GNUNET_assert (response != NULL);
+  memset (response, 0, ntohs (request->shdr.size));
 
-    response->shdr.size = request->shdr.size;
-    response->shdr.type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER);
+  response->shdr.size = request->shdr.size;
+  response->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
 
-    response->tun.flags = 0;
-    response->tun.type = htons(0x86dd);
+  response->tun.flags = 0;
+  response->tun.type = htons (0x86dd);
 
-    response->ip6_hdr.hoplmt = 255;
-    response->ip6_hdr.paylgth = request->ip6_hdr.paylgth;
-    response->ip6_hdr.nxthdr = 0x3a;
-    response->ip6_hdr.version = 6;
-    memcpy(&response->ip6_hdr.sadr, &request->ip6_hdr.dadr, 16);
-    memcpy(&response->ip6_hdr.dadr, &request->ip6_hdr.sadr, 16);
+  response->ip6_hdr.hoplmt = 255;
+  response->ip6_hdr.paylgth = request->ip6_hdr.paylgth;
+  response->ip6_hdr.nxthdr = 0x3a;
+  response->ip6_hdr.version = 6;
+  memcpy (&response->ip6_hdr.sadr, &request->ip6_hdr.dadr, 16);
+  memcpy (&response->ip6_hdr.dadr, &request->ip6_hdr.sadr, 16);
 
-    response->icmp_hdr.code = 0;
-    response->icmp_hdr.type = 0x81;
+  response->icmp_hdr.code = 0;
+  response->icmp_hdr.type = 0x81;
 
-    /* Magic, more Magic! */
-    response->icmp_hdr.chks = request->icmp_hdr.chks - 0x1;
+  /* Magic, more Magic! */
+  response->icmp_hdr.chks = request->icmp_hdr.chks - 0x1;
 
-    /* Copy the rest of the packet */
-    memcpy(response+1, request+1, ntohs(request->shdr.size) - sizeof(struct ip6_icmp));
+  /* Copy the rest of the packet */
+  memcpy (response + 1, request + 1,
+          ntohs (request->shdr.size) - sizeof (struct ip6_icmp));
 
-    write_to_helper(response, ntohs(response->shdr.size));
+  write_to_helper (response, ntohs (response->shdr.size));
 
-    GNUNET_free(request);
+  GNUNET_free (request);
 }
 
 /**
@@ -261,38 +280,44 @@ static size_t
 send_pkt_to_peer_notify_callback (void *cls, size_t size, void *buf)
 {
   struct GNUNET_MESH_Tunnel **tunnel = cls;
-  GNUNET_MESH_tunnel_set_data(*tunnel, NULL);
+
+  GNUNET_MESH_tunnel_set_data (*tunnel, NULL);
   struct GNUNET_MessageHeader *hdr =
-    (struct GNUNET_MessageHeader *) (tunnel + 1);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "send_pkt_to_peer_notify_callback: buf = %x; size = %u;\n", buf, size);
+      (struct GNUNET_MessageHeader *) (tunnel + 1);
+  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);
+  size = ntohs (hdr->size);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent!\n");
 
-  if (NULL != GNUNET_MESH_tunnel_get_head(*tunnel))
-    {
-      struct tunnel_notify_queue* element = GNUNET_MESH_tunnel_get_head(*tunnel);
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(*tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(*tunnel);
-
-      GNUNET_CONTAINER_DLL_remove(head, tail, element);
-
-      GNUNET_MESH_tunnel_set_head(*tunnel, head);
-      GNUNET_MESH_tunnel_set_tail(*tunnel, tail);
-
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (*tunnel,
-                                                                                 GNUNET_NO,
-                                                                                 42,
-                                                                                 GNUNET_TIME_relative_divide
-                                                                                 (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                                                                 (const struct GNUNET_PeerIdentity *)
-                                                                                 NULL, element->len,
-                                                                                 send_pkt_to_peer_notify_callback, element->cls);
-      /* save the handle */
-      GNUNET_MESH_tunnel_set_data(*tunnel, th);
-      GNUNET_free(element);
-    }
+  if (NULL != GNUNET_MESH_tunnel_get_head (*tunnel))
+  {
+    struct tunnel_notify_queue *element = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *head = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *tail = GNUNET_MESH_tunnel_get_tail (*tunnel);
+
+    GNUNET_CONTAINER_DLL_remove (head, tail, element);
+
+    GNUNET_MESH_tunnel_set_head (*tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (*tunnel, tail);
+
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (*tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL, element->len,
+                                           send_pkt_to_peer_notify_callback,
+                                           element->cls);
+
+    /* save the handle */
+    GNUNET_MESH_tunnel_set_data (*tunnel, th);
+    GNUNET_free (element);
+  }
   GNUNET_free (cls);
 
   return size;
@@ -302,77 +327,95 @@ unsigned int
 port_in_ports (uint64_t ports, uint16_t port)
 {
   uint16_t *ps = (uint16_t *) & ports;
+
   return ps[0] == port || ps[1] == port || ps[2] == port || ps[3] == port;
 }
 
 void
-send_pkt_to_peer (void *cls, 
-                  const struct GNUNET_PeerIdentity *peer,
-                  const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+send_pkt_to_peer (void *cls,
+                  const struct GNUNET_PeerIdentity *peer,
+                  const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                  __attribute__ ((unused)))
 {
   /* peer == NULL means that all peers in this request are connected */
-  if (peer == NULL) return;
+  if (peer == NULL)
+    return;
   struct GNUNET_MESH_Tunnel **tunnel = cls;
   struct GNUNET_MessageHeader *hdr =
-    (struct GNUNET_MessageHeader *) (tunnel + 1);
-
-  GNUNET_assert(NULL != tunnel);
-  GNUNET_assert(NULL != *tunnel);
-
-  if (NULL == GNUNET_MESH_tunnel_get_data(*tunnel))
-    {
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (*tunnel,
-                                                                                 GNUNET_NO,
-                                                                                 42,
-                                                                                 GNUNET_TIME_relative_divide(GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                                                                 (const struct GNUNET_PeerIdentity *)NULL,
-                                                                                 ntohs(hdr->size),
-                                                                                 send_pkt_to_peer_notify_callback,
-                                                                                 cls);
-      GNUNET_MESH_tunnel_set_data(*tunnel, th);
-    }
+      (struct GNUNET_MessageHeader *) (tunnel + 1);
+
+  GNUNET_assert (NULL != tunnel);
+  GNUNET_assert (NULL != *tunnel);
+
+  if (NULL == GNUNET_MESH_tunnel_get_data (*tunnel))
+  {
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (*tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL,
+                                           ntohs (hdr->size),
+                                           send_pkt_to_peer_notify_callback,
+                                           cls);
+
+    GNUNET_MESH_tunnel_set_data (*tunnel, th);
+  }
   else
-    {
-     struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(*tunnel);
-     struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(*tunnel);
-     struct tunnel_notify_queue* element = GNUNET_malloc(sizeof *element);
+  {
+    struct tunnel_notify_queue *head = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *tail = GNUNET_MESH_tunnel_get_tail (*tunnel);
+    struct tunnel_notify_queue *element = GNUNET_malloc (sizeof *element);
 
-     element->cls = cls;
-     element->len = ntohs(hdr->size);
+    element->cls = cls;
+    element->len = ntohs (hdr->size);
 
-     GNUNET_CONTAINER_DLL_insert_tail(head, tail, element);
+    GNUNET_CONTAINER_DLL_insert_tail (head, tail, element);
 
-     GNUNET_MESH_tunnel_set_head(*tunnel, head);
-     GNUNET_MESH_tunnel_set_tail(*tunnel, tail);
-    }
+    GNUNET_MESH_tunnel_set_head (*tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (*tunnel, tail);
+  }
 }
 
 /**
  * Create a new Address from an answer-packet
  */
 void
-new_ip6addr(unsigned char* buf, const GNUNET_HashCode *peer, const GNUNET_HashCode *service_desc) { /* {{{ */
-    char* ipv6addr;
-    unsigned long long ipv6prefix;
-    GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IPV6ADDR", &ipv6addr));
-    GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "vpn", "IPV6PREFIX", &ipv6prefix));
-    GNUNET_assert(ipv6prefix < 127);
-    ipv6prefix = (ipv6prefix + 7)/8;
-
-    inet_pton (AF_INET6, ipv6addr, buf);
-    GNUNET_free(ipv6addr);
-
-    int peer_length = 16 - ipv6prefix - 6;
-    if (peer_length <= 0)
-      peer_length = 0;
-
-    int service_length = 16 - ipv6prefix - peer_length;
-    if (service_length <= 0)
-      service_length = 0;
-
-    memcpy(buf+ipv6prefix, service_desc, service_length);
-    memcpy(buf+ipv6prefix+service_length, peer, peer_length);
+new_ip6addr (unsigned char *buf, const GNUNET_HashCode * peer,
+             const GNUNET_HashCode * service_desc)
+{                               /* {{{ */
+  char *ipv6addr;
+  unsigned long long ipv6prefix;
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "IPV6ADDR",
+                                                        &ipv6addr));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_number (cfg, "vpn",
+                                                        "IPV6PREFIX",
+                                                        &ipv6prefix));
+  GNUNET_assert (ipv6prefix < 127);
+  ipv6prefix = (ipv6prefix + 7) / 8;
+
+  inet_pton (AF_INET6, ipv6addr, buf);
+  GNUNET_free (ipv6addr);
+
+  int peer_length = 16 - ipv6prefix - 6;
+
+  if (peer_length <= 0)
+    peer_length = 0;
+
+  int service_length = 16 - ipv6prefix - peer_length;
+
+  if (service_length <= 0)
+    service_length = 0;
+
+  memcpy (buf + ipv6prefix, service_desc, service_length);
+  memcpy (buf + ipv6prefix + service_length, peer, peer_length);
 }
+
 /*}}}*/
 
 
@@ -384,10 +427,10 @@ new_ip6addr_remote (unsigned char *buf, unsigned char *addr, char addrlen)
 {                               /* {{{ */
   char *ipv6addr;
   unsigned long long ipv6prefix;
+
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                        "IPV6ADDR",
-                                                        &ipv6addr));
+                                                        "IPV6ADDR", &ipv6addr));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_number (cfg, "vpn",
                                                         "IPV6PREFIX",
@@ -402,6 +445,7 @@ new_ip6addr_remote (unsigned char *buf, unsigned char *addr, char addrlen)
 
   memcpy (buf + ipv6prefix, addr, GNUNET_MIN (addrlen, local_length));
 }
+
 /*}}}*/
 
 /**
@@ -412,49 +456,53 @@ new_ip4addr_remote (unsigned char *buf, unsigned char *addr, char addrlen)
 {                               /* {{{ */
   char *ipv4addr;
   char *ipv4mask;
+
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                        "IPV4ADDR",
-                                                        &ipv4addr));
+                                                        "IPV4ADDR", &ipv4addr));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                        "IPV4MASK",
-                                                        &ipv4mask));
+                                                        "IPV4MASK", &ipv4mask));
   uint32_t mask;
+
   inet_pton (AF_INET, ipv4addr, buf);
   int r = inet_pton (AF_INET, ipv4mask, &mask);
-  mask = htonl(mask);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "inet_pton: %d; %m; mask: %08x\n", r, mask);
+
+  mask = htonl (mask);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "inet_pton: %d; %m; mask: %08x\n", r,
+              mask);
 
   GNUNET_free (ipv4addr);
 
   int c;
 
   if (mask)
+  {
+    mask = (mask ^ (mask - 1)) >> 1;
+    for (c = 0; mask; c++)
     {
-      mask = (mask ^ (mask - 1)) >> 1;
-      for (c = 0; mask; c++)
-        {
-          mask >>= 1;
-        }
+      mask >>= 1;
     }
+  }
   else
-    {
-      c = CHAR_BIT * sizeof(mask);
-    }
+  {
+    c = CHAR_BIT * sizeof (mask);
+  }
 
-  c = 32-c;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "The mask %s has %d leading 1s.\n", ipv4mask, c);
+  c = 32 - c;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "The mask %s has %d leading 1s.\n",
+              ipv4mask, c);
 
   GNUNET_free (ipv4mask);
 
   if (c % 8 == 0)
     c = c / 8;
   else
-    GNUNET_assert(0);
+    GNUNET_assert (0);
 
-  memcpy (buf + c, addr, GNUNET_MIN (addrlen, 4-c));
+  memcpy (buf + c, addr, GNUNET_MIN (addrlen, 4 - c));
 }
+
 /*}}}*/
 
 /**
@@ -465,262 +513,281 @@ new_ip4addr_remote (unsigned char *buf, unsigned char *addr, char addrlen)
  * doing nothing for "real" services.
  */
 void
-process_answer(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tc) {
-    if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-      return;
+process_answer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
 
-    struct answer_packet* pkt = cls;
-    struct answer_packet_list* list;
+  struct answer_packet *pkt = cls;
+  struct answer_packet_list *list;
 
-    /* This answer is about a .gnunet-service
-     *
-     * It contains an almost complete DNS-Response, we have to fill in the ip
-     * at the offset pkt->addroffset
+  /* This answer is about a .gnunet-service
+   *
+   * It contains an almost complete DNS-Response, we have to fill in the ip
+   * at the offset pkt->addroffset
+   */
+  if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_SERVICE)
+  {
+    pkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
+
+    GNUNET_HashCode key;
+
+    memset (&key, 0, sizeof (GNUNET_HashCode));
+
+    unsigned char *c = ((unsigned char *) pkt) + ntohs (pkt->addroffset);
+    unsigned char *k = (unsigned char *) &key;
+
+    new_ip6addr (c, &pkt->service_descr.peer,
+                 &pkt->service_descr.service_descriptor);
+    /*
+     * Copy the newly generated ip-address to the key backwarts (as only the first part is hashed)
      */
-    if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_SERVICE)
-      {
-        pkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
+    unsigned int i;
 
-        GNUNET_HashCode key;
-        memset(&key, 0, sizeof(GNUNET_HashCode));
+    for (i = 0; i < 16; i++)
+      k[15 - i] = c[i];
 
-        unsigned char* c = ((unsigned char*)pkt)+ntohs(pkt->addroffset);
-        unsigned char* k = (unsigned char*)&key;
-        new_ip6addr(c, &pkt->service_descr.peer, &pkt->service_descr.service_descriptor);
-        /*
-         * Copy the newly generated ip-address to the key backwarts (as only the first part is hashed)
-         */
-        unsigned int i;
-        for (i = 0; i < 16; i++)
-            k[15-i] = c[i];
+    uint16_t namelen = strlen ((char *) pkt->data + 12) + 1;
 
-        uint16_t namelen = strlen((char*)pkt->data+12)+1;
+    struct map_entry *value =
+        GNUNET_malloc (sizeof (struct map_entry) + namelen);
+    char *name = (char *) (value + 1);
 
-        struct map_entry* value = GNUNET_malloc(sizeof(struct map_entry) + namelen);
-        char* name = (char*)(value +1);
+    value->namelen = namelen;
+    memcpy (name, pkt->data + 12, namelen);
 
-        value->namelen = namelen;
-        memcpy(name, pkt->data+12, namelen);
+    memcpy (&value->desc, &pkt->service_descr,
+            sizeof (struct GNUNET_vpn_service_descriptor));
 
-        memcpy(&value->desc, &pkt->service_descr, sizeof(struct GNUNET_vpn_service_descriptor));
+    memset (value->additional_ports, 0, 8192);
 
-        memset(value->additional_ports, 0, 8192);
+    memcpy (&value->hash, &key, sizeof (GNUNET_HashCode));
 
-        memcpy(&value->hash, &key, sizeof(GNUNET_HashCode));
+    if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (hashmap, &key))
+    {
+      GNUNET_CONTAINER_multihashmap_put (hashmap, &key, value,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+
+      value->heap_node = GNUNET_CONTAINER_heap_insert (heap, value,
+                                                       GNUNET_TIME_absolute_get
+                                                       ().abs_value);
+      if (GNUNET_CONTAINER_heap_get_size (heap) > max_mappings)
+        GNUNET_SCHEDULER_add_now (collect_mappings, NULL);
+    }
+    else
+      GNUNET_free (value);
 
-        if (GNUNET_NO ==
-            GNUNET_CONTAINER_multihashmap_contains (hashmap, &key))
-          {
-            GNUNET_CONTAINER_multihashmap_put (hashmap, &key, value,
-                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 
-            value->heap_node = GNUNET_CONTAINER_heap_insert (heap, value,
-                                                             GNUNET_TIME_absolute_get ().abs_value);
-            if (GNUNET_CONTAINER_heap_get_size(heap) > max_mappings)
-              GNUNET_SCHEDULER_add_now(collect_mappings, NULL);
-          }
-        else
-          GNUNET_free(value);
+    list =
+        GNUNET_malloc (htons (pkt->hdr.size) +
+                       2 * sizeof (struct answer_packet_list *));
 
+    memcpy (&list->pkt, pkt, htons (pkt->hdr.size));
 
-        list = GNUNET_malloc(htons(pkt->hdr.size) + 2*sizeof(struct answer_packet_list*));
+  }
+  else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_REV)
+  {
+    GNUNET_HashCode key;
 
-        memcpy(&list->pkt, pkt, htons(pkt->hdr.size));
+    memset (&key, 0, sizeof key);
+    unsigned char *k = (unsigned char *) &key;
+    unsigned char *s = pkt->data + 12;
+    int i = 0;
 
-      }
-    else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_REV)
-      {
-        GNUNET_HashCode key;
-        memset(&key, 0, sizeof key);
-        unsigned char* k = (unsigned char*)&key;
-        unsigned char* s = pkt->data+12;
-        int i = 0;
-        /* Whoever designed the reverse IPv6-lookup is batshit insane */
-        for (i = 0; i < 16; i++)
-          {
-            unsigned char c1 = s[(4*i)+1];
-            unsigned char c2 = s[(4*i)+3];
-            if (c1 <= '9')
-              k[i] = c1 - '0';
-            else
-              k[i] = c1 - 87; /* 87 is the difference between 'a' and 10 */
-            if (c2 <= '9')
-              k[i] += 16*(c2 - '0');
-            else
-              k[i] += 16*(c2 - 87);
-          }
-
-        struct map_entry* map_entry = GNUNET_CONTAINER_multihashmap_get(hashmap, &key);
-        uint16_t offset = ntohs(pkt->addroffset);
-
-        if (map_entry == NULL)
-          {
-            GNUNET_free(pkt);
-            return;
-          }
-
-        GNUNET_CONTAINER_heap_update_cost (heap, map_entry->heap_node,
-                                           GNUNET_TIME_absolute_get ().abs_value);
-
-
-        unsigned short namelen = htons(map_entry->namelen);
-        char* name = (char*)(map_entry + 1);
-
-        list = GNUNET_malloc(2*sizeof(struct answer_packet_list*) + offset + 2 + ntohs(namelen));
-
-        struct answer_packet* rpkt = &list->pkt;
-
-        /* The offset points to the first byte belonging to the address */
-        memcpy(rpkt, pkt, offset - 1);
-
-        rpkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
-        rpkt->hdr.size = ntohs(offset + 2 + ntohs(namelen));
-
-        memcpy(((char*)rpkt)+offset, &namelen, 2);
-        memcpy(((char*)rpkt)+offset+2, name, ntohs(namelen));
+    /* Whoever designed the reverse IPv6-lookup is batshit insane */
+    for (i = 0; i < 16; i++)
+    {
+      unsigned char c1 = s[(4 * i) + 1];
+      unsigned char c2 = s[(4 * i) + 3];
 
-      }
-    else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_IP)
-      {
-        list = GNUNET_malloc(htons(pkt->hdr.size) + 2*sizeof(struct answer_packet_list*));
-        memcpy(&list->pkt, pkt, htons(pkt->hdr.size));
-      }
-    else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_REMOTE_AAAA)
-      {
-        pkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
-
-        GNUNET_HashCode key;
-        memset(&key, 0, sizeof(GNUNET_HashCode));
-
-        unsigned char* c = ((unsigned char*)pkt)+ntohs(pkt->addroffset);
-        new_ip6addr_remote(c, pkt->addr, pkt->addrsize);
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New mapping to %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
-                   c[0],
-                   c[1],
-                   c[2],
-                   c[3],
-                   c[4],
-                   c[5],
-                   c[6],
-                   c[7],
-                   c[8],
-                   c[9],
-                   c[10],
-                   c[11],
-                   c[12],
-                   c[13],
-                   c[14],
-                   c[15]);
-        unsigned char* k = (unsigned char*)&key;
-        /*
-         * Copy the newly generated ip-address to the key backwards (as only the first part is used in the hash-table)
-         */
-        unsigned int i;
-        for (i = 0; i < 16; i++)
-            k[15-i] = c[i];
-
-        uint16_t namelen = strlen((char*)pkt->data+12)+1;
-
-        struct map_entry* value = GNUNET_malloc(sizeof(struct map_entry) + namelen);
-        char* name = (char*)(value +1);
-
-        value->namelen = namelen;
-        memcpy(name, pkt->data+12, namelen);
-
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting addrlen to %d\n", pkt->addrsize);
-        value->addrlen = pkt->addrsize;
-        memcpy(&value->addr, &pkt->addr, pkt->addrsize);
-        memset(value->additional_ports, 0, 8192);
-
-        memcpy(&value->hash, &key, sizeof(GNUNET_HashCode));
-
-        if (GNUNET_NO ==
-            GNUNET_CONTAINER_multihashmap_contains (hashmap, &key))
-          {
-            GNUNET_CONTAINER_multihashmap_put (hashmap, &key, value,
-                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-            value->heap_node = GNUNET_CONTAINER_heap_insert (heap, value,
-                                                             GNUNET_TIME_absolute_get ().abs_value);
-            if (GNUNET_CONTAINER_heap_get_size(heap) > max_mappings)
-              GNUNET_SCHEDULER_add_now(collect_mappings, NULL);
-          }
-        else
-          GNUNET_free(value);
-
-        list = GNUNET_malloc(htons(pkt->hdr.size) + 2*sizeof(struct answer_packet_list*));
-
-        memcpy(&list->pkt, pkt, htons(pkt->hdr.size));
-      }
-    else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_REMOTE_A)
-      {
-        pkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
-
-        GNUNET_HashCode key;
-        memset(&key, 0, sizeof(GNUNET_HashCode));
-
-        unsigned char* c = ((unsigned char*)pkt)+ntohs(pkt->addroffset);
-        new_ip4addr_remote(c, pkt->addr, pkt->addrsize);
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New mapping to %d.%d.%d.%d\n",
-                   c[0],
-                   c[1],
-                   c[2],
-                   c[3]);
-        unsigned char* k = (unsigned char*)&key;
-        /*
-         * Copy the newly generated ip-address to the key backwards (as only the first part is used in the hash-table)
-         */
-        unsigned int i;
-        for (i = 0; i < 4; i++)
-            k[3-i] = c[i];
-
-        uint16_t namelen = strlen((char*)pkt->data+12)+1;
-
-        struct map_entry* value = GNUNET_malloc(sizeof(struct map_entry) + namelen);
-        char* name = (char*)(value +1);
-
-        value->namelen = namelen;
-        memcpy(name, pkt->data+12, namelen);
-
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting addrlen to %d\n", pkt->addrsize);
-        value->addrlen = pkt->addrsize;
-        memcpy(&value->addr, &pkt->addr, pkt->addrsize);
-        memset(value->additional_ports, 0, 8192);
-
-        memcpy(&value->hash, &key, sizeof(GNUNET_HashCode));
-
-        if (GNUNET_NO ==
-            GNUNET_CONTAINER_multihashmap_contains (hashmap, &key))
-          {
-            GNUNET_CONTAINER_multihashmap_put (hashmap, &key, value,
-                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-            value->heap_node = GNUNET_CONTAINER_heap_insert (heap, value,
-                                                             GNUNET_TIME_absolute_get ().abs_value);
-            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Mapping is saved in the hashmap with key %08x.\n",
-                       *((uint32_t*)(&key)));
-            if (GNUNET_CONTAINER_heap_get_size(heap) > max_mappings)
-              GNUNET_SCHEDULER_add_now(collect_mappings, NULL);
-          }
-        else
-          GNUNET_free(value);
-
-        list = GNUNET_malloc(htons(pkt->hdr.size) + 2*sizeof(struct answer_packet_list*));
-
-        memcpy(&list->pkt, pkt, htons(pkt->hdr.size));
-      }
+      if (c1 <= '9')
+        k[i] = c1 - '0';
+      else
+        k[i] = c1 - 87;         /* 87 is the difference between 'a' and 10 */
+      if (c2 <= '9')
+        k[i] += 16 * (c2 - '0');
+      else
+        k[i] += 16 * (c2 - 87);
+    }
+
+    struct map_entry *map_entry =
+        GNUNET_CONTAINER_multihashmap_get (hashmap, &key);
+    uint16_t offset = ntohs (pkt->addroffset);
+
+    if (map_entry == NULL)
+    {
+      GNUNET_free (pkt);
+      return;
+    }
+
+    GNUNET_CONTAINER_heap_update_cost (heap, map_entry->heap_node,
+                                       GNUNET_TIME_absolute_get ().abs_value);
+
+
+    unsigned short namelen = htons (map_entry->namelen);
+    char *name = (char *) (map_entry + 1);
+
+    list =
+        GNUNET_malloc (2 * sizeof (struct answer_packet_list *) + offset + 2 +
+                       ntohs (namelen));
+
+    struct answer_packet *rpkt = &list->pkt;
+
+    /* The offset points to the first byte belonging to the address */
+    memcpy (rpkt, pkt, offset - 1);
+
+    rpkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
+    rpkt->hdr.size = ntohs (offset + 2 + ntohs (namelen));
+
+    memcpy (((char *) rpkt) + offset, &namelen, 2);
+    memcpy (((char *) rpkt) + offset + 2, name, ntohs (namelen));
+
+  }
+  else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_IP)
+  {
+    list =
+        GNUNET_malloc (htons (pkt->hdr.size) +
+                       2 * sizeof (struct answer_packet_list *));
+    memcpy (&list->pkt, pkt, htons (pkt->hdr.size));
+  }
+  else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_REMOTE_AAAA)
+  {
+    pkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
+
+    GNUNET_HashCode key;
+
+    memset (&key, 0, sizeof (GNUNET_HashCode));
+
+    unsigned char *c = ((unsigned char *) pkt) + ntohs (pkt->addroffset);
+
+    new_ip6addr_remote (c, pkt->addr, pkt->addrsize);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "New mapping to %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
+                c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9],
+                c[10], c[11], c[12], c[13], c[14], c[15]);
+    unsigned char *k = (unsigned char *) &key;
+
+    /*
+     * Copy the newly generated ip-address to the key backwards (as only the first part is used in the hash-table)
+     */
+    unsigned int i;
+
+    for (i = 0; i < 16; i++)
+      k[15 - i] = c[i];
+
+    uint16_t namelen = strlen ((char *) pkt->data + 12) + 1;
+
+    struct map_entry *value =
+        GNUNET_malloc (sizeof (struct map_entry) + namelen);
+    char *name = (char *) (value + 1);
+
+    value->namelen = namelen;
+    memcpy (name, pkt->data + 12, namelen);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting addrlen to %d\n",
+                pkt->addrsize);
+    value->addrlen = pkt->addrsize;
+    memcpy (&value->addr, &pkt->addr, pkt->addrsize);
+    memset (value->additional_ports, 0, 8192);
+
+    memcpy (&value->hash, &key, sizeof (GNUNET_HashCode));
+
+    if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (hashmap, &key))
+    {
+      GNUNET_CONTAINER_multihashmap_put (hashmap, &key, value,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+      value->heap_node = GNUNET_CONTAINER_heap_insert (heap, value,
+                                                       GNUNET_TIME_absolute_get
+                                                       ().abs_value);
+      if (GNUNET_CONTAINER_heap_get_size (heap) > max_mappings)
+        GNUNET_SCHEDULER_add_now (collect_mappings, NULL);
+    }
     else
-      {
-        GNUNET_break(0);
-        GNUNET_free(pkt);
-        return;
-      }
+      GNUNET_free (value);
+
+    list =
+        GNUNET_malloc (htons (pkt->hdr.size) +
+                       2 * sizeof (struct answer_packet_list *));
+
+    memcpy (&list->pkt, pkt, htons (pkt->hdr.size));
+  }
+  else if (pkt->subtype == GNUNET_DNS_ANSWER_TYPE_REMOTE_A)
+  {
+    pkt->subtype = GNUNET_DNS_ANSWER_TYPE_IP;
 
-    GNUNET_free(pkt);
+    GNUNET_HashCode key;
 
-    GNUNET_CONTAINER_DLL_insert_after(answer_proc_head, answer_proc_tail, answer_proc_tail, list);
+    memset (&key, 0, sizeof (GNUNET_HashCode));
 
-    schedule_helper_write(GNUNET_TIME_UNIT_FOREVER_REL, NULL);
+    unsigned char *c = ((unsigned char *) pkt) + ntohs (pkt->addroffset);
 
+    new_ip4addr_remote (c, pkt->addr, pkt->addrsize);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New mapping to %d.%d.%d.%d\n",
+                c[0], c[1], c[2], c[3]);
+    unsigned char *k = (unsigned char *) &key;
+
+    /*
+     * Copy the newly generated ip-address to the key backwards (as only the first part is used in the hash-table)
+     */
+    unsigned int i;
+
+    for (i = 0; i < 4; i++)
+      k[3 - i] = c[i];
+
+    uint16_t namelen = strlen ((char *) pkt->data + 12) + 1;
+
+    struct map_entry *value =
+        GNUNET_malloc (sizeof (struct map_entry) + namelen);
+    char *name = (char *) (value + 1);
+
+    value->namelen = namelen;
+    memcpy (name, pkt->data + 12, namelen);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting addrlen to %d\n",
+                pkt->addrsize);
+    value->addrlen = pkt->addrsize;
+    memcpy (&value->addr, &pkt->addr, pkt->addrsize);
+    memset (value->additional_ports, 0, 8192);
+
+    memcpy (&value->hash, &key, sizeof (GNUNET_HashCode));
+
+    if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (hashmap, &key))
+    {
+      GNUNET_CONTAINER_multihashmap_put (hashmap, &key, value,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+      value->heap_node = GNUNET_CONTAINER_heap_insert (heap, value,
+                                                       GNUNET_TIME_absolute_get
+                                                       ().abs_value);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Mapping is saved in the hashmap with key %08x.\n",
+                  *((uint32_t *) (&key)));
+      if (GNUNET_CONTAINER_heap_get_size (heap) > max_mappings)
+        GNUNET_SCHEDULER_add_now (collect_mappings, NULL);
+    }
+    else
+      GNUNET_free (value);
+
+    list =
+        GNUNET_malloc (htons (pkt->hdr.size) +
+                       2 * sizeof (struct answer_packet_list *));
+
+    memcpy (&list->pkt, pkt, htons (pkt->hdr.size));
+  }
+  else
+  {
+    GNUNET_break (0);
+    GNUNET_free (pkt);
     return;
+  }
+
+  GNUNET_free (pkt);
+
+  GNUNET_CONTAINER_DLL_insert_after (answer_proc_head, answer_proc_tail,
+                                     answer_proc_tail, list);
+
+  schedule_helper_write (GNUNET_TIME_UNIT_FOREVER_REL, NULL);
+
+  return;
 }
 
 /**
@@ -787,16 +854,18 @@ testBit (char *bitArray, unsigned int bitIdx)
 static void
 add_additional_port (struct map_entry *me, uint16_t port)
 {
-  setBit(me->additional_ports, port);
+  setBit (me->additional_ports, port);
 }
 
 static int
 receive_udp_back (void *cls
                   __attribute__ ((unused)), struct GNUNET_MESH_Tunnel *tunnel,
                   void **tunnel_ctx __attribute__ ((unused)),
-                  const struct GNUNET_PeerIdentity *sender __attribute__ ((unused)),
+                  const struct GNUNET_PeerIdentity *sender
+                  __attribute__ ((unused)),
                   const struct GNUNET_MessageHeader *message,
-                  const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__ ((unused)))
+                  const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                  __attribute__ ((unused)))
 {
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1);
   struct remote_addr *s = (struct remote_addr *) desc;
@@ -804,167 +873,178 @@ receive_udp_back (void *cls
   const struct GNUNET_PeerIdentity *other = GNUNET_MESH_get_peer (tunnel);
 
   if (16 == s->addrlen)
-    {
-      size_t size =
-        sizeof (struct ip6_udp) + ntohs (pkt->len) - 1 - sizeof (struct udp_pkt);
+  {
+    size_t size =
+        sizeof (struct ip6_udp) + ntohs (pkt->len) - 1 -
+        sizeof (struct udp_pkt);
 
-      struct ip6_udp *pkt6 = alloca (size);
+    struct ip6_udp *pkt6 = alloca (size);
 
-      GNUNET_assert (pkt6 != NULL);
+    GNUNET_assert (pkt6 != NULL);
 
-      if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK)
-        new_ip6addr (pkt6->ip6_hdr.sadr, &other->hashPubKey, desc);
-      else
-        new_ip6addr_remote (pkt6->ip6_hdr.sadr, s->addr, s->addrlen);
+    if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK)
+      new_ip6addr (pkt6->ip6_hdr.sadr, &other->hashPubKey, desc);
+    else
+      new_ip6addr_remote (pkt6->ip6_hdr.sadr, s->addr, s->addrlen);
 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Relaying calc:%d gnu:%d udp:%d bytes!\n", size,
-                  ntohs (message->size), ntohs (pkt->len));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Relaying calc:%d gnu:%d udp:%d bytes!\n", size,
+                ntohs (message->size), ntohs (pkt->len));
+
+    pkt6->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
+    pkt6->shdr.size = htons (size);
 
-      pkt6->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
-      pkt6->shdr.size = htons (size);
+    pkt6->tun.flags = 0;
+    pkt6->tun.type = htons (0x86dd);
 
-      pkt6->tun.flags = 0;
-      pkt6->tun.type = htons (0x86dd);
+    pkt6->ip6_hdr.version = 6;
+    pkt6->ip6_hdr.tclass_h = 0;
+    pkt6->ip6_hdr.tclass_l = 0;
+    pkt6->ip6_hdr.flowlbl = 0;
+    pkt6->ip6_hdr.paylgth = pkt->len;
+    pkt6->ip6_hdr.nxthdr = 0x11;
+    pkt6->ip6_hdr.hoplmt = 0xff;
+
+    {
+      char *ipv6addr;
+
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
+                                                            "IPV6ADDR",
+                                                            &ipv6addr));
+      inet_pton (AF_INET6, ipv6addr, pkt6->ip6_hdr.dadr);
+      GNUNET_free (ipv6addr);
+    }
+    memcpy (&pkt6->udp_hdr, pkt, ntohs (pkt->len));
 
-      pkt6->ip6_hdr.version = 6;
-      pkt6->ip6_hdr.tclass_h = 0;
-      pkt6->ip6_hdr.tclass_l = 0;
-      pkt6->ip6_hdr.flowlbl = 0;
-      pkt6->ip6_hdr.paylgth = pkt->len;
-      pkt6->ip6_hdr.nxthdr = 0x11;
-      pkt6->ip6_hdr.hoplmt = 0xff;
+    GNUNET_HashCode *key = address6_mapping_exists (pkt6->ip6_hdr.sadr);
 
+    GNUNET_assert (key != NULL);
+
+    struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
+
+    GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
+                                       GNUNET_TIME_absolute_get ().abs_value);
+
+    GNUNET_free (key);
+
+    GNUNET_assert (me != NULL);
+    if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK)
+    {
+      GNUNET_assert (me->desc.
+                     service_type & htonl (GNUNET_DNS_SERVICE_TYPE_UDP));
+      if (!port_in_ports (me->desc.ports, pkt6->udp_hdr.spt) &&
+          !testBit (me->additional_ports, ntohs (pkt6->udp_hdr.spt)))
       {
-        char *ipv6addr;
-        GNUNET_assert (GNUNET_OK ==
-                       GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                              "IPV6ADDR",
-                                                              &ipv6addr));
-        inet_pton (AF_INET6, ipv6addr, pkt6->ip6_hdr.dadr);
-        GNUNET_free (ipv6addr);
+        add_additional_port (me, ntohs (pkt6->udp_hdr.spt));
       }
-      memcpy (&pkt6->udp_hdr, pkt, ntohs (pkt->len));
-
-      GNUNET_HashCode *key = address6_mapping_exists (pkt6->ip6_hdr.sadr);
-      GNUNET_assert (key != NULL);
-
-      struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
-      GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
-                                         GNUNET_TIME_absolute_get ().
-                                         abs_value);
-
-      GNUNET_free (key);
-
-      GNUNET_assert (me != NULL);
-      if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK)
-        {
-          GNUNET_assert (me->desc.
-                         service_type & htonl (GNUNET_DNS_SERVICE_TYPE_UDP));
-          if (!port_in_ports (me->desc.ports, pkt6->udp_hdr.spt)
-              && !testBit (me->additional_ports, ntohs (pkt6->udp_hdr.spt)))
-            {
-              add_additional_port (me, ntohs (pkt6->udp_hdr.spt));
-            }
-        }
-
-      pkt6->udp_hdr.crc = 0;
-      uint32_t sum = 0;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.sadr,
-                                   16);
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.dadr,
-                                   16);
-      uint32_t tmp = (pkt6->udp_hdr.len & 0xffff);
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-      tmp = htons (((pkt6->ip6_hdr.nxthdr & 0x00ff)));
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-
-      sum =
+    }
+
+    pkt6->udp_hdr.crc = 0;
+    uint32_t sum = 0;
+
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.sadr, 16);
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.dadr, 16);
+    uint32_t tmp = (pkt6->udp_hdr.len & 0xffff);
+
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = htons (((pkt6->ip6_hdr.nxthdr & 0x00ff)));
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+
+    sum =
         calculate_checksum_update (sum, (uint16_t *) & pkt6->udp_hdr,
                                    ntohs (pkt->len));
-      pkt6->udp_hdr.crc = calculate_checksum_end (sum);
+    pkt6->udp_hdr.crc = calculate_checksum_end (sum);
 
-      write_to_helper (pkt6, size);
-    }
+    write_to_helper (pkt6, size);
+  }
   else
-    {
-      size_t size =
+  {
+    size_t size =
         sizeof (struct ip_udp) + ntohs (pkt->len) - 1 - sizeof (struct udp_pkt);
 
-      struct ip_udp *pkt4 = alloca (size);
+    struct ip_udp *pkt4 = alloca (size);
 
-      GNUNET_assert (pkt4 != NULL);
+    GNUNET_assert (pkt4 != NULL);
 
-      GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP_BACK);
-      uint32_t sadr;
-      new_ip4addr_remote ((unsigned char*)&sadr, s->addr, s->addrlen);
-      pkt4->ip_hdr.sadr = sadr;
+    GNUNET_assert (ntohs (message->type) ==
+                   GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP_BACK);
+    uint32_t sadr;
 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Relaying calc:%d gnu:%d udp:%d bytes!\n", size,
-                  ntohs (message->size), ntohs (pkt->len));
-
-      pkt4->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
-      pkt4->shdr.size = htons (size);
-
-      pkt4->tun.flags = 0;
-      pkt4->tun.type = htons (0x0800);
-
-      pkt4->ip_hdr.version = 4;
-      pkt4->ip_hdr.hdr_lngth = 5;
-      pkt4->ip_hdr.diff_serv = 0;
-      pkt4->ip_hdr.tot_lngth = htons (20 + ntohs(pkt->len));
-      pkt4->ip_hdr.ident = 0;
-      pkt4->ip_hdr.flags = 0;
-      pkt4->ip_hdr.frag_off = 0;
-      pkt4->ip_hdr.ttl = 255;
-      pkt4->ip_hdr.proto = 0x11;
-      pkt4->ip_hdr.chks = 0;        /* Will be calculated later */
+    new_ip4addr_remote ((unsigned char *) &sadr, s->addr, s->addrlen);
+    pkt4->ip_hdr.sadr = sadr;
 
-      {
-        char *ipv4addr;
-        uint32_t dadr;
-        GNUNET_assert (GNUNET_OK ==
-                       GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                              "IPV4ADDR",
-                                                              &ipv4addr));
-        inet_pton (AF_INET, ipv4addr, &dadr);
-        GNUNET_free (ipv4addr);
-        pkt4->ip_hdr.dadr = dadr;
-      }
-      memcpy (&pkt4->udp_hdr, pkt, ntohs (pkt->len));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Relaying calc:%d gnu:%d udp:%d bytes!\n", size,
+                ntohs (message->size), ntohs (pkt->len));
 
-      GNUNET_HashCode *key = address4_mapping_exists (pkt4->ip_hdr.sadr);
-      GNUNET_assert (key != NULL);
+    pkt4->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
+    pkt4->shdr.size = htons (size);
 
-      struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
-      GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
-                                         GNUNET_TIME_absolute_get ().
-                                         abs_value);
+    pkt4->tun.flags = 0;
+    pkt4->tun.type = htons (0x0800);
 
-      GNUNET_free (key);
+    pkt4->ip_hdr.version = 4;
+    pkt4->ip_hdr.hdr_lngth = 5;
+    pkt4->ip_hdr.diff_serv = 0;
+    pkt4->ip_hdr.tot_lngth = htons (20 + ntohs (pkt->len));
+    pkt4->ip_hdr.ident = 0;
+    pkt4->ip_hdr.flags = 0;
+    pkt4->ip_hdr.frag_off = 0;
+    pkt4->ip_hdr.ttl = 255;
+    pkt4->ip_hdr.proto = 0x11;
+    pkt4->ip_hdr.chks = 0;      /* Will be calculated later */
 
-      GNUNET_assert (me != NULL);
+    {
+      char *ipv4addr;
+      uint32_t dadr;
+
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
+                                                            "IPV4ADDR",
+                                                            &ipv4addr));
+      inet_pton (AF_INET, ipv4addr, &dadr);
+      GNUNET_free (ipv4addr);
+      pkt4->ip_hdr.dadr = dadr;
+    }
+    memcpy (&pkt4->udp_hdr, pkt, ntohs (pkt->len));
+
+    GNUNET_HashCode *key = address4_mapping_exists (pkt4->ip_hdr.sadr);
+
+    GNUNET_assert (key != NULL);
+
+    struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
+
+    GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
+                                       GNUNET_TIME_absolute_get ().abs_value);
+
+    GNUNET_free (key);
 
-      pkt4->udp_hdr.crc = 0; /* Optional for IPv4 */
+    GNUNET_assert (me != NULL);
 
-      pkt4->ip_hdr.chks =
+    pkt4->udp_hdr.crc = 0;      /* Optional for IPv4 */
+
+    pkt4->ip_hdr.chks =
         calculate_ip_checksum ((uint16_t *) & pkt4->ip_hdr, 5 * 4);
 
-      write_to_helper (pkt4, size);
-    }
+    write_to_helper (pkt4, size);
+  }
 
   return GNUNET_OK;
 }
 
 static int
-receive_tcp_back (void *cls __attribute__((unused)), struct GNUNET_MESH_Tunnel* tunnel,
-                  void **tunnel_ctx __attribute__((unused)),
-                  const struct GNUNET_PeerIdentity *sender __attribute__((unused)),
-                  const struct GNUNET_MessageHeader *message,
-                  const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+receive_tcp_back (void *cls
+                  __attribute__ ((unused)), struct GNUNET_MESH_Tunnel *tunnel,
+                  void **tunnel_ctx
+                  __attribute__ ((unused)),
+                  const struct GNUNET_PeerIdentity *sender
+                  __attribute__ ((unused)),
+                  const struct GNUNET_MessageHeader *message,
+                  const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                  __attribute__ ((unused)))
 {
   GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1);
   struct remote_addr *s = (struct remote_addr *) desc;
@@ -972,164 +1052,169 @@ receive_tcp_back (void *cls __attribute__((unused)), struct GNUNET_MESH_Tunnel*
   const struct GNUNET_PeerIdentity *other = GNUNET_MESH_get_peer (tunnel);
 
   size_t pktlen =
-    ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) -
-    sizeof (GNUNET_HashCode);
+      ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) -
+      sizeof (GNUNET_HashCode);
 
   if (s->addrlen == 16)
+  {
+    size_t size = pktlen + sizeof (struct ip6_tcp) - 1;
+
+    struct ip6_tcp *pkt6 = alloca (size);
+
+    memset (pkt6, 0, size);
+
+    GNUNET_assert (pkt6 != NULL);
+
+    if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP_BACK)
+      new_ip6addr (pkt6->ip6_hdr.sadr, &other->hashPubKey, desc);
+    else
+      new_ip6addr_remote (pkt6->ip6_hdr.sadr, s->addr, s->addrlen);
+
+    pkt6->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
+    pkt6->shdr.size = htons (size);
+
+    pkt6->tun.flags = 0;
+    pkt6->tun.type = htons (0x86dd);
+
+    pkt6->ip6_hdr.version = 6;
+    pkt6->ip6_hdr.tclass_h = 0;
+    pkt6->ip6_hdr.tclass_l = 0;
+    pkt6->ip6_hdr.flowlbl = 0;
+    pkt6->ip6_hdr.paylgth = htons (pktlen);
+    pkt6->ip6_hdr.nxthdr = 0x06;
+    pkt6->ip6_hdr.hoplmt = 0xff;
+
     {
-      size_t size = pktlen + sizeof (struct ip6_tcp) - 1;
+      char *ipv6addr;
+
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
+                                                            "IPV6ADDR",
+                                                            &ipv6addr));
+      inet_pton (AF_INET6, ipv6addr, pkt6->ip6_hdr.dadr);
+      GNUNET_free (ipv6addr);
+    }
+    memcpy (&pkt6->tcp_hdr, pkt, pktlen);
 
-      struct ip6_tcp *pkt6 = alloca (size);
-      memset (pkt6, 0, size);
+    GNUNET_HashCode *key = address6_mapping_exists (pkt6->ip6_hdr.sadr);
 
-      GNUNET_assert (pkt6 != NULL);
+    GNUNET_assert (key != NULL);
 
-      if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP_BACK)
-        new_ip6addr (pkt6->ip6_hdr.sadr, &other->hashPubKey, desc);
-      else
-        new_ip6addr_remote (pkt6->ip6_hdr.sadr, s->addr, s->addrlen);
+    struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
 
-      pkt6->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
-      pkt6->shdr.size = htons (size);
+    GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
+                                       GNUNET_TIME_absolute_get ().abs_value);
 
-      pkt6->tun.flags = 0;
-      pkt6->tun.type = htons (0x86dd);
+    GNUNET_free (key);
 
-      pkt6->ip6_hdr.version = 6;
-      pkt6->ip6_hdr.tclass_h = 0;
-      pkt6->ip6_hdr.tclass_l = 0;
-      pkt6->ip6_hdr.flowlbl = 0;
-      pkt6->ip6_hdr.paylgth = htons (pktlen);
-      pkt6->ip6_hdr.nxthdr = 0x06;
-      pkt6->ip6_hdr.hoplmt = 0xff;
+    GNUNET_assert (me != NULL);
+    if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK)
+      GNUNET_assert (me->desc.
+                     service_type & htonl (GNUNET_DNS_SERVICE_TYPE_TCP));
 
-      {
-        char *ipv6addr;
-        GNUNET_assert (GNUNET_OK ==
-                       GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                              "IPV6ADDR",
-                                                              &ipv6addr));
-        inet_pton (AF_INET6, ipv6addr, pkt6->ip6_hdr.dadr);
-        GNUNET_free (ipv6addr);
-      }
-      memcpy (&pkt6->tcp_hdr, pkt, pktlen);
-
-      GNUNET_HashCode *key = address6_mapping_exists (pkt6->ip6_hdr.sadr);
-      GNUNET_assert (key != NULL);
-
-      struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
-      GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
-                                         GNUNET_TIME_absolute_get ().
-                                         abs_value);
-
-      GNUNET_free (key);
-
-      GNUNET_assert (me != NULL);
-      if (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK)
-        GNUNET_assert (me->desc.
-                       service_type & htonl (GNUNET_DNS_SERVICE_TYPE_TCP));
-
-      pkt6->tcp_hdr.crc = 0;
-      uint32_t sum = 0;
-      uint32_t tmp;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.sadr,
-                                   16);
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.dadr,
-                                   16);
-      tmp = htonl (pktlen);
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-      tmp = htonl (((pkt6->ip6_hdr.nxthdr & 0x000000ff)));
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-
-      sum =
+    pkt6->tcp_hdr.crc = 0;
+    uint32_t sum = 0;
+    uint32_t tmp;
+
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.sadr, 16);
+    sum =
+        calculate_checksum_update (sum, (uint16_t *) & pkt6->ip6_hdr.dadr, 16);
+    tmp = htonl (pktlen);
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = htonl (((pkt6->ip6_hdr.nxthdr & 0x000000ff)));
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+
+    sum =
         calculate_checksum_update (sum, (uint16_t *) & pkt6->tcp_hdr,
                                    ntohs (pkt6->ip6_hdr.paylgth));
-      pkt6->tcp_hdr.crc = calculate_checksum_end (sum);
+    pkt6->tcp_hdr.crc = calculate_checksum_end (sum);
 
-      write_to_helper (pkt6, size);
-    }
+    write_to_helper (pkt6, size);
+  }
   else
+  {
+    size_t size = pktlen + sizeof (struct ip_tcp) - 1;
+
+    struct ip_tcp *pkt4 = alloca (size);
+
+    GNUNET_assert (pkt4 != NULL);
+    memset (pkt4, 0, size);
+
+    GNUNET_assert (ntohs (message->type) ==
+                   GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP_BACK);
+    uint32_t sadr;
+
+    new_ip4addr_remote ((unsigned char *) &sadr, s->addr, s->addrlen);
+    pkt4->ip_hdr.sadr = sadr;
+
+    pkt4->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
+    pkt4->shdr.size = htons (size);
+
+    pkt4->tun.flags = 0;
+    pkt4->tun.type = htons (0x0800);
+
+    pkt4->ip_hdr.version = 4;
+    pkt4->ip_hdr.hdr_lngth = 5;
+    pkt4->ip_hdr.diff_serv = 0;
+    pkt4->ip_hdr.tot_lngth = htons (20 + pktlen);
+    pkt4->ip_hdr.ident = 0;
+    pkt4->ip_hdr.flags = 0;
+    pkt4->ip_hdr.frag_off = 0;
+    pkt4->ip_hdr.ttl = 255;
+    pkt4->ip_hdr.proto = 0x06;
+    pkt4->ip_hdr.chks = 0;      /* Will be calculated later */
+
     {
-      size_t size = pktlen + sizeof (struct ip_tcp) - 1;
-
-      struct ip_tcp *pkt4 = alloca (size);
-      GNUNET_assert (pkt4 != NULL);
-      memset (pkt4, 0, size);
-
-      GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP_BACK);
-      uint32_t sadr;
-      new_ip4addr_remote ((unsigned char*)&sadr, s->addr, s->addrlen);
-      pkt4->ip_hdr.sadr = sadr;
-
-      pkt4->shdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
-      pkt4->shdr.size = htons (size);
-
-      pkt4->tun.flags = 0;
-      pkt4->tun.type = htons (0x0800);
-
-      pkt4->ip_hdr.version = 4;
-      pkt4->ip_hdr.hdr_lngth = 5;
-      pkt4->ip_hdr.diff_serv = 0;
-      pkt4->ip_hdr.tot_lngth = htons (20 + pktlen);
-      pkt4->ip_hdr.ident = 0;
-      pkt4->ip_hdr.flags = 0;
-      pkt4->ip_hdr.frag_off = 0;
-      pkt4->ip_hdr.ttl = 255;
-      pkt4->ip_hdr.proto = 0x06;
-      pkt4->ip_hdr.chks = 0;        /* Will be calculated later */
+      char *ipv4addr;
+      uint32_t dadr;
+
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
+                                                            "IPV4ADDR",
+                                                            &ipv4addr));
+      inet_pton (AF_INET, ipv4addr, &dadr);
+      GNUNET_free (ipv4addr);
+      pkt4->ip_hdr.dadr = dadr;
+    }
 
-      {
-        char *ipv4addr;
-        uint32_t dadr;
-        GNUNET_assert (GNUNET_OK ==
-                       GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
-                                                              "IPV4ADDR",
-                                                              &ipv4addr));
-        inet_pton (AF_INET, ipv4addr, &dadr);
-        GNUNET_free (ipv4addr);
-        pkt4->ip_hdr.dadr = dadr;
-      }
+    memcpy (&pkt4->tcp_hdr, pkt, pktlen);
+
+    GNUNET_HashCode *key = address4_mapping_exists (pkt4->ip_hdr.sadr);
+
+    GNUNET_assert (key != NULL);
 
-      memcpy (&pkt4->tcp_hdr, pkt, pktlen);
+    struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
 
-      GNUNET_HashCode *key = address4_mapping_exists (pkt4->ip_hdr.sadr);
-      GNUNET_assert (key != NULL);
+    GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
+                                       GNUNET_TIME_absolute_get ().abs_value);
 
-      struct map_entry *me = GNUNET_CONTAINER_multihashmap_get (hashmap, key);
-      GNUNET_CONTAINER_heap_update_cost (heap, me->heap_node,
-                                         GNUNET_TIME_absolute_get ().
-                                         abs_value);
+    GNUNET_free (key);
 
-      GNUNET_free (key);
+    GNUNET_assert (me != NULL);
+    pkt4->tcp_hdr.crc = 0;
+    uint32_t sum = 0;
+    uint32_t tmp;
 
-      GNUNET_assert (me != NULL);
-      pkt4->tcp_hdr.crc = 0;
-      uint32_t sum = 0;
-      uint32_t tmp;
-      tmp = pkt4->ip_hdr.sadr;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
-      tmp = pkt4->ip_hdr.dadr;
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = pkt4->ip_hdr.sadr;
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    tmp = pkt4->ip_hdr.dadr;
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
 
-      tmp = (0x06 << 16) | (0xffff & pktlen);
+    tmp = (0x06 << 16) | (0xffff & pktlen);
 
-      tmp = htonl(tmp);
+    tmp = htonl (tmp);
 
-      sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
+    sum = calculate_checksum_update (sum, (uint16_t *) & tmp, 4);
 
-      sum =
-        calculate_checksum_update (sum, (uint16_t *) & pkt4->tcp_hdr, pktlen);
-      pkt4->tcp_hdr.crc = calculate_checksum_end (sum);
+    sum = calculate_checksum_update (sum, (uint16_t *) & pkt4->tcp_hdr, pktlen);
+    pkt4->tcp_hdr.crc = calculate_checksum_end (sum);
 
-      pkt4->ip_hdr.chks =
+    pkt4->ip_hdr.chks =
         calculate_ip_checksum ((uint16_t *) & pkt4->ip_hdr, 5 * 4);
 
-      write_to_helper (pkt4, size);
-    }
+    write_to_helper (pkt4, size);
+  }
 
   return GNUNET_OK;
 }
@@ -1144,37 +1229,34 @@ receive_tcp_back (void *cls __attribute__((unused)), struct GNUNET_MESH_Tunnel*
  */
 static void
 run (void *cls,
-     char *const *args __attribute__((unused)),
-     const char *cfgfilep __attribute__((unused)),
+     char *const *args __attribute__ ((unused)),
+     const char *cfgfilep __attribute__ ((unused)),
      const struct GNUNET_CONFIGURATION_Handle *cfg_)
 {
-    static const struct GNUNET_MESH_MessageHandler handlers[] = {
-          {receive_udp_back, GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK, 0},
-          {receive_tcp_back, GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP_BACK, 0},
-          {receive_udp_back, GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP_BACK, 0},
-          {receive_tcp_back, GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP_BACK, 0},
-          {NULL, 0, 0}
-    };
-
-    static const GNUNET_MESH_ApplicationType types[] = {
-        GNUNET_APPLICATION_TYPE_END
-    };
-
-    mesh_handle = GNUNET_MESH_connect(cfg_,
-                                      NULL,
-                                      NULL,
-                                      handlers,
-                                      types);
-    cfg = cfg_;
-    restart_hijack = 0;
-    hashmap = GNUNET_CONTAINER_multihashmap_create(65536);
-    heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-    GNUNET_CONFIGURATION_get_value_number (cfg, "vpn", "MAX_MAPPINGg",
-                                           &max_mappings);
-    udp_connections = GNUNET_CONTAINER_multihashmap_create(65536);
-    conn_task = GNUNET_SCHEDULER_add_now (connect_to_service_dns, NULL);
-    shs_task = GNUNET_SCHEDULER_add_after (conn_task, start_helper_and_schedule, NULL);
-    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_FOREVER_REL, &cleanup, cls);
+  static const struct GNUNET_MESH_MessageHandler handlers[] = {
+    {receive_udp_back, GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP_BACK, 0},
+    {receive_tcp_back, GNUNET_MESSAGE_TYPE_VPN_SERVICE_TCP_BACK, 0},
+    {receive_udp_back, GNUNET_MESSAGE_TYPE_VPN_REMOTE_UDP_BACK, 0},
+    {receive_tcp_back, GNUNET_MESSAGE_TYPE_VPN_REMOTE_TCP_BACK, 0},
+    {NULL, 0, 0}
+  };
+
+  static const GNUNET_MESH_ApplicationType types[] = {
+    GNUNET_APPLICATION_TYPE_END
+  };
+
+  mesh_handle = GNUNET_MESH_connect (cfg_, NULL, NULL, handlers, types);
+  cfg = cfg_;
+  restart_hijack = 0;
+  hashmap = GNUNET_CONTAINER_multihashmap_create (65536);
+  heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  GNUNET_CONFIGURATION_get_value_number (cfg, "vpn", "MAX_MAPPINGg",
+                                         &max_mappings);
+  udp_connections = GNUNET_CONTAINER_multihashmap_create (65536);
+  conn_task = GNUNET_SCHEDULER_add_now (connect_to_service_dns, NULL);
+  shs_task =
+      GNUNET_SCHEDULER_add_after (conn_task, start_helper_and_schedule, NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup, cls);
 }
 
 /**
@@ -1185,18 +1267,18 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv) {
-    static const struct GNUNET_GETOPT_CommandLineOption options[] = {
-        GNUNET_GETOPT_OPTION_END
-    };
-
-    return (GNUNET_OK ==
-            GNUNET_PROGRAM_run (argc,
-                                argv,
-                                "vpn",
-                                gettext_noop ("help text"),
-                                options, &run, NULL)) ? ret : 1;
+main (int argc, char *const *argv)
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "vpn",
+                              gettext_noop ("help text"),
+                              options, &run, NULL)) ? ret : 1;
 }
 
 /* end of gnunet-daemon-vpn.c */
-
diff --git a/src/vpn/gnunet-daemon-vpn.h b/src/vpn/gnunet-daemon-vpn.h
index 7643a6e4d..ac6e50c72 100644
--- a/src/vpn/gnunet-daemon-vpn.h
+++ b/src/vpn/gnunet-daemon-vpn.h
@@ -35,24 +35,25 @@
  * At the moment this means "inventing" and IPv6-Address for .gnunet-services and
  * doing nothing for "real" services.
  */
-void
-process_answer(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tc);
+void process_answer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
-void send_icmp6_response(void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
-void send_icmp4_response(void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+void send_icmp6_response (void *cls,
+                          const struct GNUNET_SCHEDULER_TaskContext *tc);
+void send_icmp4_response (void *cls,
+                          const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 size_t
-send_udp_service (void *cls, size_t size, void *buf);
+                      send_udp_service (void *cls, size_t size, void *buf);
 
-GNUNET_HashCode* address6_mapping_exists(unsigned char addr[]);
-GNUNET_HashCode* address4_mapping_exists(uint32_t addr);
+GNUNET_HashCode *address6_mapping_exists (unsigned char addr[]);
+GNUNET_HashCode *address4_mapping_exists (uint32_t addr);
 
 unsigned int port_in_ports (uint64_t ports, uint16_t port);
 
 void
 send_pkt_to_peer (void *cls,
-                  const struct GNUNET_PeerIdentity *peer,
-                  const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+                  const struct GNUNET_PeerIdentity *peer,
+                  const struct GNUNET_TRANSPORT_ATS_Information *atsi);
 
 /**
  * The configuration to use
@@ -67,22 +68,23 @@ extern struct GNUNET_MESH_Handle *mesh_handle;
 /**
  * The hashmap containing the mappings from ipv6-addresses to gnunet-descriptors
  */
-extern struct GNUNET_CONTAINER_MultiHashMap* hashmap;
+extern struct GNUNET_CONTAINER_MultiHashMap *hashmap;
 
-struct map_entry {
+struct map_entry
+{
     /** The description of the service (used for service) */
-    struct GNUNET_vpn_service_descriptor desc;
+  struct GNUNET_vpn_service_descriptor desc;
 
     /** The real address of the service (used for remote) */
-    char addrlen;
-    char addr[16];
+  char addrlen;
+  char addr[16];
 
-    struct GNUNET_MESH_Tunnel *tunnel;
-    uint16_t namelen;
-    char additional_ports[8192];
+  struct GNUNET_MESH_Tunnel *tunnel;
+  uint16_t namelen;
+  char additional_ports[8192];
 
-    struct GNUNET_CONTAINER_HeapNode* heap_node;
-    GNUNET_HashCode hash;
+  struct GNUNET_CONTAINER_HeapNode *heap_node;
+  GNUNET_HashCode hash;
     /**
      * After this struct the name is located in DNS-Format!
      */
diff --git a/src/vpn/gnunet-dns-parser.c b/src/vpn/gnunet-dns-parser.c
index e26638141..70551af52 100644
--- a/src/vpn/gnunet-dns-parser.c
+++ b/src/vpn/gnunet-dns-parser.c
@@ -11,29 +11,33 @@
  * @returns The offset of the first unparsed byte (the byte right behind the name)
  */
 static unsigned int
-parse_dns_name(char* d, const unsigned char* src, unsigned short idx) {/*{{{*/
-    char* dest = d;
-
-    int len = src[idx++];
-    while (len != 0)
-      {
-        if (len & 0xC0)
-          { /* Compressed name, offset in this and the next octet */
-            unsigned short offset = ((len & 0x3F) << 8) | src[idx++];
-            parse_dns_name(dest, src, offset - 12); /* 12 for the Header of the DNS-Packet, idx starts at 0 which is 12 bytes from the start of the packet */
-            return idx;
-          }
-        memcpy(dest, src+idx, len);
-        idx += len;
-        dest += len;
-        *dest = '.';
-        dest++;
-        len = src[idx++];
-      };
-    *dest = 0;
-
-    return idx;
+parse_dns_name (char *d, const unsigned char *src, unsigned short idx)
+{                               /*{{{ */
+  char *dest = d;
+
+  int len = src[idx++];
+
+  while (len != 0)
+  {
+    if (len & 0xC0)
+    {                           /* Compressed name, offset in this and the next octet */
+      unsigned short offset = ((len & 0x3F) << 8) | src[idx++];
+
+      parse_dns_name (dest, src, offset - 12);  /* 12 for the Header of the DNS-Packet, idx starts at 0 which is 12 bytes from the start of the packet */
+      return idx;
+    }
+    memcpy (dest, src + idx, len);
+    idx += len;
+    dest += len;
+    *dest = '.';
+    dest++;
+    len = src[idx++];
+  };
+  *dest = 0;
+
+  return idx;
 }
+
 /*}}}*/
 
 /**
@@ -46,116 +50,127 @@ parse_dns_name(char* d, const unsigned char* src, unsigned short idx) {/*{{{*/
  * @returns The offset of the first unparsed byte (the byte right behind the last record)
  */
 static unsigned short
-parse_dns_record(unsigned char* data, /*{{{*/
-                 struct dns_record** dst,
-                 unsigned short count,
-                 unsigned short idx) {
-    int i;
-    unsigned short _idx;
-    for (i = 0; i < count; i++) {
-        dst[i] = GNUNET_malloc(sizeof(struct dns_record));
-        dst[i]->name = alloca(255); // see RFC1035, no name can be longer than this.
-        char* name = dst[i]->name;
-
-        _idx = parse_dns_name(name, data, idx);
-        dst[i]->namelen = _idx - idx;
-
-        dst[i]->name = GNUNET_malloc(dst[i]->namelen);
-        memcpy(dst[i]->name, name, dst[i]->namelen);
-
-        idx = _idx;
-
-        dst[i]->type = *((unsigned short*)(data+idx));
-        idx += 2;
-        dst[i]->class = *((unsigned short*)(data+idx));
-        idx += 2;
-        dst[i]->ttl = *((unsigned int*)(data+idx));
-        idx += 4;
-        dst[i]->data_len = *((unsigned short*)(data+idx));
-        idx += 2;
-        dst[i]->data = GNUNET_malloc(ntohs(dst[i]->data_len));
-        memcpy(dst[i]->data, data+idx, ntohs(dst[i]->data_len));
-        idx += ntohs(dst[i]->data_len);
-    }
-    return idx;
-}/*}}}*/
+parse_dns_record (unsigned char *data,  /*{{{ */
+                  struct dns_record **dst,
+                  unsigned short count, unsigned short idx)
+{
+  int i;
+  unsigned short _idx;
+
+  for (i = 0; i < count; i++)
+  {
+    dst[i] = GNUNET_malloc (sizeof (struct dns_record));
+    dst[i]->name = alloca (255);        // see RFC1035, no name can be longer than this.
+    char *name = dst[i]->name;
+
+    _idx = parse_dns_name (name, data, idx);
+    dst[i]->namelen = _idx - idx;
+
+    dst[i]->name = GNUNET_malloc (dst[i]->namelen);
+    memcpy (dst[i]->name, name, dst[i]->namelen);
+
+    idx = _idx;
+
+    dst[i]->type = *((unsigned short *) (data + idx));
+    idx += 2;
+    dst[i]->class = *((unsigned short *) (data + idx));
+    idx += 2;
+    dst[i]->ttl = *((unsigned int *) (data + idx));
+    idx += 4;
+    dst[i]->data_len = *((unsigned short *) (data + idx));
+    idx += 2;
+    dst[i]->data = GNUNET_malloc (ntohs (dst[i]->data_len));
+    memcpy (dst[i]->data, data + idx, ntohs (dst[i]->data_len));
+    idx += ntohs (dst[i]->data_len);
+  }
+  return idx;
+}                               /*}}} */
 
 /**
  * Parse a raw DNS-Packet into an usable struct
  */
-struct dns_pkt_parsed*
-parse_dns_packet(struct dns_pkt* pkt) {/*{{{*/
-    struct dns_pkt_parsed* ppkt = GNUNET_malloc(sizeof(struct dns_pkt_parsed));
-    memcpy(&ppkt->s, &pkt->s, sizeof pkt->s);
-
-    unsigned short qdcount = ntohs(ppkt->s.qdcount);
-    unsigned short ancount = ntohs(ppkt->s.ancount);
-    unsigned short nscount = ntohs(ppkt->s.nscount);
-    unsigned short arcount = ntohs(ppkt->s.arcount);
-
-    ppkt->queries = GNUNET_malloc(qdcount*sizeof(struct dns_query*));
-    ppkt->answers = GNUNET_malloc(ancount*sizeof(struct dns_record*));
-    ppkt->nameservers = GNUNET_malloc(nscount*sizeof(struct dns_record*));
-    ppkt->additional = GNUNET_malloc(arcount*sizeof(struct dns_record*));
-
-    unsigned short idx = 0, _idx; /* This keeps track how far we have parsed the data */
-
-    /* Parse the Query */
-    int i;
-    for (i = 0; i < qdcount; i++)
-      { /*{{{*/
-        ppkt->queries[i] = GNUNET_malloc(sizeof(struct dns_query));
-        char* name = alloca(255); /* see RFC1035, it can't be more than this. */
-
-        _idx = parse_dns_name(name, pkt->data, idx);
-        ppkt->queries[i]->namelen = _idx - idx;
-        idx = _idx;
-
-        ppkt->queries[i]->name = GNUNET_malloc(ppkt->queries[i]->namelen);
-        memcpy(ppkt->queries[i]->name, name, ppkt->queries[i]->namelen);
-
-        ppkt->queries[i]->qtype = *((unsigned short*)(pkt->data+idx));
-        idx += 2;
-        ppkt->queries[i]->qclass = *((unsigned short*)(pkt->data+idx));
-        idx += 2;
-    }
-    /*}}}*/
-    idx = parse_dns_record(pkt->data, ppkt->answers, ancount, idx);
-    idx = parse_dns_record(pkt->data, ppkt->nameservers, nscount, idx);
-    idx = parse_dns_record(pkt->data, ppkt->additional, arcount, idx);
-    return ppkt;
-}/*}}}*/
+struct dns_pkt_parsed *
+parse_dns_packet (struct dns_pkt *pkt)
+{                               /*{{{ */
+  struct dns_pkt_parsed *ppkt = GNUNET_malloc (sizeof (struct dns_pkt_parsed));
+
+  memcpy (&ppkt->s, &pkt->s, sizeof pkt->s);
+
+  unsigned short qdcount = ntohs (ppkt->s.qdcount);
+  unsigned short ancount = ntohs (ppkt->s.ancount);
+  unsigned short nscount = ntohs (ppkt->s.nscount);
+  unsigned short arcount = ntohs (ppkt->s.arcount);
+
+  ppkt->queries = GNUNET_malloc (qdcount * sizeof (struct dns_query *));
+  ppkt->answers = GNUNET_malloc (ancount * sizeof (struct dns_record *));
+  ppkt->nameservers = GNUNET_malloc (nscount * sizeof (struct dns_record *));
+  ppkt->additional = GNUNET_malloc (arcount * sizeof (struct dns_record *));
+
+  unsigned short idx = 0, _idx; /* This keeps track how far we have parsed the data */
+
+  /* Parse the Query */
+  int i;
+
+  for (i = 0; i < qdcount; i++)
+  {                             /*{{{ */
+    ppkt->queries[i] = GNUNET_malloc (sizeof (struct dns_query));
+    char *name = alloca (255);  /* see RFC1035, it can't be more than this. */
+
+    _idx = parse_dns_name (name, pkt->data, idx);
+    ppkt->queries[i]->namelen = _idx - idx;
+    idx = _idx;
+
+    ppkt->queries[i]->name = GNUNET_malloc (ppkt->queries[i]->namelen);
+    memcpy (ppkt->queries[i]->name, name, ppkt->queries[i]->namelen);
+
+    ppkt->queries[i]->qtype = *((unsigned short *) (pkt->data + idx));
+    idx += 2;
+    ppkt->queries[i]->qclass = *((unsigned short *) (pkt->data + idx));
+    idx += 2;
+  }
+  /*}}} */
+  idx = parse_dns_record (pkt->data, ppkt->answers, ancount, idx);
+  idx = parse_dns_record (pkt->data, ppkt->nameservers, nscount, idx);
+  idx = parse_dns_record (pkt->data, ppkt->additional, arcount, idx);
+  return ppkt;
+}                               /*}}} */
 
 void
-free_parsed_dns_packet(struct dns_pkt_parsed* ppkt) {
-    unsigned short qdcount = ntohs(ppkt->s.qdcount);
-    unsigned short ancount = ntohs(ppkt->s.ancount);
-    unsigned short nscount = ntohs(ppkt->s.nscount);
-    unsigned short arcount = ntohs(ppkt->s.arcount);
-
-    int i;
-    for (i = 0; i < qdcount; i++) {
-        GNUNET_free(ppkt->queries[i]->name);
-        GNUNET_free(ppkt->queries[i]);
-    }
-    GNUNET_free(ppkt->queries);
-    for (i = 0; i < ancount; i++) {
-        GNUNET_free(ppkt->answers[i]->name);
-        GNUNET_free(ppkt->answers[i]->data);
-        GNUNET_free(ppkt->answers[i]);
-    }
-    GNUNET_free(ppkt->answers);
-    for (i = 0; i < nscount; i++) {
-        GNUNET_free(ppkt->nameservers[i]->name);
-        GNUNET_free(ppkt->nameservers[i]->data);
-        GNUNET_free(ppkt->nameservers[i]);
-    }
-    GNUNET_free(ppkt->nameservers);
-    for (i = 0; i < arcount; i++) {
-        GNUNET_free(ppkt->additional[i]->name);
-        GNUNET_free(ppkt->additional[i]->data);
-        GNUNET_free(ppkt->additional[i]);
-    }
-    GNUNET_free(ppkt->additional);
-    GNUNET_free(ppkt);
+free_parsed_dns_packet (struct dns_pkt_parsed *ppkt)
+{
+  unsigned short qdcount = ntohs (ppkt->s.qdcount);
+  unsigned short ancount = ntohs (ppkt->s.ancount);
+  unsigned short nscount = ntohs (ppkt->s.nscount);
+  unsigned short arcount = ntohs (ppkt->s.arcount);
+
+  int i;
+
+  for (i = 0; i < qdcount; i++)
+  {
+    GNUNET_free (ppkt->queries[i]->name);
+    GNUNET_free (ppkt->queries[i]);
+  }
+  GNUNET_free (ppkt->queries);
+  for (i = 0; i < ancount; i++)
+  {
+    GNUNET_free (ppkt->answers[i]->name);
+    GNUNET_free (ppkt->answers[i]->data);
+    GNUNET_free (ppkt->answers[i]);
+  }
+  GNUNET_free (ppkt->answers);
+  for (i = 0; i < nscount; i++)
+  {
+    GNUNET_free (ppkt->nameservers[i]->name);
+    GNUNET_free (ppkt->nameservers[i]->data);
+    GNUNET_free (ppkt->nameservers[i]);
+  }
+  GNUNET_free (ppkt->nameservers);
+  for (i = 0; i < arcount; i++)
+  {
+    GNUNET_free (ppkt->additional[i]->name);
+    GNUNET_free (ppkt->additional[i]->data);
+    GNUNET_free (ppkt->additional[i]);
+  }
+  GNUNET_free (ppkt->additional);
+  GNUNET_free (ppkt);
 }
diff --git a/src/vpn/gnunet-dns-parser.h b/src/vpn/gnunet-dns-parser.h
index ea1a5765c..cf9d55e8a 100644
--- a/src/vpn/gnunet-dns-parser.h
+++ b/src/vpn/gnunet-dns-parser.h
@@ -4,8 +4,8 @@
 #include "platform.h"
 #include "gnunet-vpn-packet.h"
 
-struct dns_pkt_parsed* parse_dns_packet(struct dns_pkt* pkt);
+struct dns_pkt_parsed *parse_dns_packet (struct dns_pkt *pkt);
 
-void free_parsed_dns_packet(struct dns_pkt_parsed* ppkt);
+void free_parsed_dns_packet (struct dns_pkt_parsed *ppkt);
 
 #endif
diff --git a/src/vpn/gnunet-helper-hijack-dns.c b/src/vpn/gnunet-helper-hijack-dns.c
index ee7ae1873..e6912323b 100644
--- a/src/vpn/gnunet-helper-hijack-dns.c
+++ b/src/vpn/gnunet-helper-hijack-dns.c
@@ -27,75 +27,130 @@
 
 #include "gnunet_common.h"
 
-int fork_and_exec(char* file, char* cmd[]) {
-        pid_t pid = fork();
-        if (pid < 0) {
-                fprintf(stderr, "could not fork: %s\n", strerror(errno));
-                return GNUNET_SYSERR;
-        }
-
-        int st = 0;
-
-        if (pid == 0) {
-                execv(file, cmd);
-        } else {
-                waitpid(pid, &st, 0);
-        }
-        return WIFEXITED(st) && (WEXITSTATUS(st) == 0);
+int
+fork_and_exec (char *file, char *cmd[])
+{
+  pid_t pid = fork ();
+
+  if (pid < 0)
+  {
+    fprintf (stderr, "could not fork: %s\n", strerror (errno));
+    return GNUNET_SYSERR;
+  }
+
+  int st = 0;
+
+  if (pid == 0)
+  {
+    execv (file, cmd);
+  }
+  else
+  {
+    waitpid (pid, &st, 0);
+  }
+  return WIFEXITED (st) && (WEXITSTATUS (st) == 0);
 }
 
-int main(int argc, char** argv) {
-        int delete = 0;
-        int port = 0;
-        char* virt_dns;
-        if (argc < 3) return GNUNET_SYSERR;
-
-        if (strncmp(argv[1], "-d", 2) == 0) {
-                if (argc < 3) return GNUNET_SYSERR;
-                delete = 1;
-                port = atoi(argv[2]);
-                virt_dns = argv[3];
-        } else {
-                port = atoi(argv[1]);
-                virt_dns = argv[2];
-        }
-
-        if (port == 0) return GNUNET_SYSERR;
-
-        struct stat s;
-        if (stat("/sbin/iptables", &s) < 0) {
-                fprintf(stderr, "stat on /sbin/iptables failed: %s\n", strerror(errno));
-                return GNUNET_SYSERR;
-        }
-        if (stat("/sbin/ip", &s) < 0) {
-                fprintf(stderr, "stat on /sbin/ip failed: %s\n", strerror(errno));
-                return GNUNET_SYSERR;
-        }
-
-        char localport[7];
-        snprintf(localport, 7, "%d", port);
-
-        int r;
-        if (delete) {
+int
+main (int argc, char **argv)
+{
+  int delete = 0;
+  int port = 0;
+  char *virt_dns;
+
+  if (argc < 3)
+    return GNUNET_SYSERR;
+
+  if (strncmp (argv[1], "-d", 2) == 0)
+  {
+    if (argc < 3)
+      return GNUNET_SYSERR;
+    delete = 1;
+    port = atoi (argv[2]);
+    virt_dns = argv[3];
+  }
+  else
+  {
+    port = atoi (argv[1]);
+    virt_dns = argv[2];
+  }
+
+  if (port == 0)
+    return GNUNET_SYSERR;
+
+  struct stat s;
+
+  if (stat ("/sbin/iptables", &s) < 0)
+  {
+    fprintf (stderr, "stat on /sbin/iptables failed: %s\n", strerror (errno));
+    return GNUNET_SYSERR;
+  }
+  if (stat ("/sbin/ip", &s) < 0)
+  {
+    fprintf (stderr, "stat on /sbin/ip failed: %s\n", strerror (errno));
+    return GNUNET_SYSERR;
+  }
+
+  char localport[7];
+
+  snprintf (localport, 7, "%d", port);
+
+  int r;
+
+  if (delete)
+  {
 e4:
-                r = fork_and_exec("/sbin/ip", (char*[]){"ip", "route", "del", "default", "via", virt_dns,"table","2", NULL});
+    r = fork_and_exec ("/sbin/ip", (char *[])
+                       {
+                       "ip", "route", "del", "default", "via", virt_dns,
+                       "table", "2", NULL});
 e3:
-                r = fork_and_exec("/sbin/ip", (char*[]){"ip", "rule", "del", "fwmark", "3", "table","2", NULL});
+    r = fork_and_exec ("/sbin/ip", (char *[])
+                       {
+                       "ip", "rule", "del", "fwmark", "3", "table", "2", NULL});
 e2:
-                r = fork_and_exec("/sbin/iptables", (char*[]){"iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", "--dport", "53", "-j", "MARK", "--set-mark", "3", NULL});
+    r = fork_and_exec ("/sbin/iptables", (char *[])
+                       {
+                       "iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp",
+                       "--dport", "53", "-j", "MARK", "--set-mark", "3", NULL});
 e1:
-                r = fork_and_exec("/sbin/iptables", (char*[]){"iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", "--sport", localport, "--dport", "53", "-j", "ACCEPT", NULL});
-                if (!delete) r = 0;
-        } else {
-                r = fork_and_exec("/sbin/iptables", (char*[]){"iptables", "-t", "mangle", "-I", "OUTPUT", "1", "-p", "udp", "--sport", localport, "--dport", "53", "-j", "ACCEPT", NULL});
-                if (!r) goto e1;
-                r = fork_and_exec("/sbin/iptables", (char*[]){"iptables", "-t", "mangle", "-I", "OUTPUT", "2", "-p", "udp", "--dport", "53", "-j", "MARK", "--set-mark", "3", NULL});
-                if (!r) goto e2;
-                r = fork_and_exec("/sbin/ip", (char*[]){"ip", "rule", "add", "fwmark", "3", "table","2", NULL});
-                if (!r) goto e3;
-                r = fork_and_exec("/sbin/ip", (char*[]){"ip", "route", "add", "default", "via", virt_dns, "table","2", NULL});
-                if (!r) goto e4;
-        }
-        if (r) return GNUNET_YES;
-        return GNUNET_SYSERR;
+    r = fork_and_exec ("/sbin/iptables", (char *[])
+                       {
+                       "iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp",
+                       "--sport", localport, "--dport", "53", "-j", "ACCEPT",
+                       NULL});
+    if (!delete)
+      r = 0;
+  }
+  else
+  {
+    r = fork_and_exec ("/sbin/iptables", (char *[])
+                       {
+                       "iptables", "-t", "mangle", "-I", "OUTPUT", "1", "-p",
+                       "udp", "--sport", localport, "--dport", "53", "-j",
+                       "ACCEPT", NULL});
+    if (!r)
+      goto e1;
+    r = fork_and_exec ("/sbin/iptables", (char *[])
+                       {
+                       "iptables", "-t", "mangle", "-I", "OUTPUT", "2", "-p",
+                       "udp", "--dport", "53", "-j", "MARK", "--set-mark", "3",
+                       NULL});
+    if (!r)
+      goto e2;
+    r = fork_and_exec ("/sbin/ip", (char *[])
+                       {
+                       "ip", "rule", "add", "fwmark", "3", "table", "2", NULL});
+    if (!r)
+      goto e3;
+    r = fork_and_exec ("/sbin/ip", (char *[])
+                       {
+                       "ip", "route", "add", "default", "via", virt_dns,
+                       "table", "2", NULL});
+    if (!r)
+      goto e4;
+  }
+  if (r)
+    return GNUNET_YES;
+  return GNUNET_SYSERR;
 }
diff --git a/src/vpn/gnunet-helper-vpn-api.c b/src/vpn/gnunet-helper-vpn-api.c
index 1022d54e9..16bfcbd2e 100644
--- a/src/vpn/gnunet-helper-vpn-api.c
+++ b/src/vpn/gnunet-helper-vpn-api.c
@@ -45,7 +45,7 @@ stop_helper (struct GNUNET_VPN_HELPER_Handle *handle)
   GNUNET_DISK_pipe_close (handle->helper_in);
   GNUNET_DISK_pipe_close (handle->helper_out);
 
-  GNUNET_SERVER_mst_destroy(handle->mst);
+  GNUNET_SERVER_mst_destroy (handle->mst);
 }
 
 extern GNUNET_SCHEDULER_TaskIdentifier shs_task;
@@ -57,6 +57,7 @@ static void
 helper_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tsdkctx)
 {
   struct GNUNET_VPN_HELPER_Handle *handle = cls;
+
   /* no message can be bigger then 64k */
   char buf[65535];
 
@@ -67,34 +68,32 @@ helper_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tsdkctx)
 
   /* On read-error, restart the helper */
   if (t <= 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Read error for header from vpn-helper: %m\n");
-      stop_helper (handle);
-
-      /* Restart the helper */
-      shs_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                    handle->restart_task, handle);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Read error for header from vpn-helper: %m\n");
+    stop_helper (handle);
+
+    /* Restart the helper */
+    shs_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                             handle->restart_task, handle);
+    return;
+  }
 
   if (GNUNET_SYSERR ==
       GNUNET_SERVER_mst_receive (handle->mst, handle->client, buf, t, 0, 0))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "SYSERR from mst\n");
-      stop_helper (handle);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "SYSERR from mst\n");
+    stop_helper (handle);
 
-      /* Restart the helper */
-      shs_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                    handle->restart_task, handle);
-      return;
+    /* Restart the helper */
+    shs_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                             handle->restart_task, handle);
+    return;
 
-    }
+  }
 
   GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  handle->fh_from_helper, &helper_read,
-                                  handle);
+                                  handle->fh_from_helper, &helper_read, handle);
 }
 
 void
@@ -114,7 +113,7 @@ start_helper (const char *ifname,
               GNUNET_SERVER_MessageTokenizerCallback cb, void *cb_cls)
 {
   struct GNUNET_VPN_HELPER_Handle *handle =
-    GNUNET_malloc (sizeof (struct GNUNET_VPN_HELPER_Handle));
+      GNUNET_malloc (sizeof (struct GNUNET_VPN_HELPER_Handle));
 
   handle->helper_in = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO);
   handle->helper_out = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_NO, GNUNET_YES);
@@ -122,20 +121,20 @@ start_helper (const char *ifname,
   handle->restart_task = restart_task;
 
   if (handle->helper_in == NULL || handle->helper_out == NULL)
-    {
-      GNUNET_free (handle);
-      return NULL;
-    }
+  {
+    GNUNET_free (handle);
+    return NULL;
+  }
 
   handle->helper_proc =
-    GNUNET_OS_start_process (handle->helper_in, handle->helper_out,
-                             "gnunet-helper-vpn", process_name, ifname,
-                             ipv6addr, ipv6prefix, ipv4addr, ipv4mask, NULL);
+      GNUNET_OS_start_process (handle->helper_in, handle->helper_out,
+                               "gnunet-helper-vpn", process_name, ifname,
+                               ipv6addr, ipv6prefix, ipv4addr, ipv4mask, NULL);
 
   handle->fh_from_helper =
-    GNUNET_DISK_pipe_handle (handle->helper_out, GNUNET_DISK_PIPE_END_READ);
+      GNUNET_DISK_pipe_handle (handle->helper_out, GNUNET_DISK_PIPE_END_READ);
   handle->fh_to_helper =
-    GNUNET_DISK_pipe_handle (handle->helper_in, GNUNET_DISK_PIPE_END_WRITE);
+      GNUNET_DISK_pipe_handle (handle->helper_in, GNUNET_DISK_PIPE_END_WRITE);
 
   GNUNET_DISK_pipe_close_end (handle->helper_out, GNUNET_DISK_PIPE_END_WRITE);
   GNUNET_DISK_pipe_close_end (handle->helper_in, GNUNET_DISK_PIPE_END_READ);
@@ -143,8 +142,7 @@ start_helper (const char *ifname,
   handle->mst = GNUNET_SERVER_mst_create (cb, cb_cls);
 
   GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  handle->fh_from_helper, &helper_read,
-                                  handle);
+                                  handle->fh_from_helper, &helper_read, handle);
 
   return handle;
 }
diff --git a/src/vpn/gnunet-helper-vpn.c b/src/vpn/gnunet-helper-vpn.c
index 554019d7c..698c46f1d 100644
--- a/src/vpn/gnunet-helper-vpn.c
+++ b/src/vpn/gnunet-helper-vpn.c
@@ -74,23 +74,23 @@ init_tun (char *dev)
   int fd;
 
   if (NULL == dev)
-    {
-      errno = EINVAL;
-      return -1;
-    }
+  {
+    errno = EINVAL;
+    return -1;
+  }
 
   if (-1 == (fd = open ("/dev/net/tun", O_RDWR)))
-    {
-      fprintf (stderr,
-               "Error opening `%s': %s\n", "/dev/net/tun", strerror (errno));
-      return -1;
-    }
+  {
+    fprintf (stderr,
+             "Error opening `%s': %s\n", "/dev/net/tun", strerror (errno));
+    return -1;
+  }
 
   if (fd >= FD_SETSIZE)
-    {
-      fprintf (stderr, "File descriptor to large: %d", fd);
-      return -1;
-    }
+  {
+    fprintf (stderr, "File descriptor to large: %d", fd);
+    return -1;
+  }
 
   memset (&ifr, 0, sizeof (ifr));
   ifr.ifr_flags = IFF_TUN;
@@ -99,13 +99,13 @@ init_tun (char *dev)
     strncpy (ifr.ifr_name, dev, IFNAMSIZ);
 
   if (-1 == ioctl (fd, TUNSETIFF, (void *) &ifr))
-    {
-      fprintf (stderr,
-               "Error with ioctl on `%s': %s\n",
-               "/dev/net/tun", strerror (errno));
-      close (fd);
-      return -1;
-    }
+  {
+    fprintf (stderr,
+             "Error with ioctl on `%s': %s\n",
+             "/dev/net/tun", strerror (errno));
+    close (fd);
+    return -1;
+  }
   strcpy (dev, ifr.ifr_name);
   return fd;
 }
@@ -119,9 +119,7 @@ init_tun (char *dev)
  * @param prefix_len the length of the network-prefix
  */
 static void
-set_address6 (const char *dev, 
-              const char *address, 
-              unsigned long prefix_len)
+set_address6 (const char *dev, const char *address, unsigned long prefix_len)
 {
   struct ifreq ifr;
   struct in6_ifreq ifr6;
@@ -133,25 +131,20 @@ set_address6 (const char *dev,
    */
   memset (&sa6, 0, sizeof (struct sockaddr_in6));
   if (1 != inet_pton (AF_INET6, address, sa6.sin6_addr.s6_addr))
-    {
-      fprintf (stderr,
-               "Failed to parse address `%s': %s\n",
-               address, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "Failed to parse address `%s': %s\n", address, strerror (errno));
+    exit (1);
+  }
 
   if (-1 == (fd = socket (PF_INET6, SOCK_DGRAM, 0)))
-    {
-      fprintf (stderr,
-               "Error creating socket: %s\n", 
-               strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr, "Error creating socket: %s\n", strerror (errno));
+    exit (1);
+  }
 
   sa6.sin6_family = AF_INET6;
-  memcpy (&ifr6.ifr6_addr, 
-          &sa6.sin6_addr, 
-          sizeof (struct in6_addr));
+  memcpy (&ifr6.ifr6_addr, &sa6.sin6_addr, sizeof (struct in6_addr));
 
 
   /*
@@ -159,13 +152,10 @@ set_address6 (const char *dev,
    */
   strncpy (ifr.ifr_name, dev, IFNAMSIZ);
   if (-1 == ioctl (fd, SIOGIFINDEX, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at %d: %s\n",
-               __LINE__, 
-               strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
   ifr6.ifr6_ifindex = ifr.ifr_ifindex;
 
   ifr6.ifr6_prefixlen = prefix_len;
@@ -174,38 +164,38 @@ set_address6 (const char *dev,
    * Set the address
    */
   if (-1 == ioctl (fd, SIOCSIFADDR, &ifr6))
-    {
-      fprintf (stderr,
-               "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   /*
    * Get the flags
    */
   if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   /*
    * Add the UP and RUNNING flags
    */
   ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
   if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   if (0 != close (fd))
-    {
-      fprintf (stderr, "close failed: %s\n", strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr, "close failed: %s\n", strerror (errno));
+    exit (1);
+  }
 }
 
 
@@ -217,9 +207,7 @@ set_address6 (const char *dev,
  * @param mask the netmask
  */
 static void
-set_address4 (const char *dev, 
-              const char *address, 
-              const char *mask)
+set_address4 (const char *dev, const char *address, const char *mask)
 {
   int fd;
   struct sockaddr_in *addr;
@@ -235,21 +223,18 @@ set_address4 (const char *dev,
    * Parse the address
    */
   if (1 != inet_pton (AF_INET, address, &addr->sin_addr.s_addr))
-    {
-      fprintf (stderr,
-               "Failed to parse address `%s': %s\n",
-               address, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "Failed to parse address `%s': %s\n", address, strerror (errno));
+    exit (1);
+  }
+
 
-  
   if (-1 == (fd = socket (PF_INET, SOCK_DGRAM, 0)))
-    {
-      fprintf (stderr, 
-               "Error creating socket: %s\n", 
-               strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr, "Error creating socket: %s\n", strerror (errno));
+    exit (1);
+  }
 
   strncpy (ifr.ifr_name, dev, IFNAMSIZ);
 
@@ -257,63 +242,58 @@ set_address4 (const char *dev,
    * Set the address
    */
   if (-1 == ioctl (fd, SIOCSIFADDR, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at %d: %s\n",
-               __LINE__, 
-               strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   /*
    * Parse the netmask
    */
   addr = (struct sockaddr_in *) &(ifr.ifr_netmask);
   if (1 != inet_pton (AF_INET, mask, &addr->sin_addr.s_addr))
-    {
-      fprintf (stderr,
-               "Failed to parse address `%s': %s\n",
-               mask, 
-               strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "Failed to parse address `%s': %s\n", mask, strerror (errno));
+    exit (1);
+  }
 
   /*
    * Set the netmask
    */
   if (-1 == ioctl (fd, SIOCSIFNETMASK, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   /*
    * Get the flags
    */
   if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   /*
    * Add the UP and RUNNING flags
    */
   ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
   if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr,
+             "ioctl failed at line %d: %s\n", __LINE__, strerror (errno));
+    exit (1);
+  }
 
   if (0 != close (fd))
-    {
-      fprintf (stderr, "close failed: %s\n", strerror (errno));
-      exit (1);
-    }
+  {
+    fprintf (stderr, "close failed: %s\n", strerror (errno));
+    exit (1);
+  }
 }
 
 
@@ -340,188 +320,182 @@ run (int fd_tun)
 
   /* read refers to reading from fd_tun, writing to stdout */
   int read_open = 1;
+
   /* write refers to reading from stdin, writing to fd_tun */
   int write_open = 1;
 
   while ((1 == read_open) || (1 == write_open))
+  {
+    FD_ZERO (&fds_w);
+    FD_ZERO (&fds_r);
+
+    /*
+     * We are supposed to read and the buffer is empty
+     * -> select on read from tun
+     */
+    if (read_open && (0 == buftun_size))
+      FD_SET (fd_tun, &fds_r);
+
+    /*
+     * We are supposed to read and the buffer is not empty
+     * -> select on write to stdout
+     */
+    if (read_open && (0 != buftun_size))
+      FD_SET (1, &fds_w);
+
+    /*
+     * We are supposed to write and the buffer is empty
+     * -> select on read from stdin
+     */
+    if (write_open && (NULL == bufin_read))
+      FD_SET (0, &fds_r);
+
+    /*
+     * We are supposed to write and the buffer is not empty
+     * -> select on write to tun
+     */
+    if (write_open && (NULL != bufin_read))
+      FD_SET (fd_tun, &fds_w);
+
+    int r = select (fd_tun + 1, &fds_r, &fds_w, NULL, NULL);
+
+    if (-1 == r)
     {
-      FD_ZERO (&fds_w);
-      FD_ZERO (&fds_r);
-
-      /*
-       * We are supposed to read and the buffer is empty
-       * -> select on read from tun
-       */
-      if (read_open && (0 == buftun_size))
-        FD_SET (fd_tun, &fds_r);        
-
-      /*
-       * We are supposed to read and the buffer is not empty
-       * -> select on write to stdout
-       */
-      if (read_open && (0 != buftun_size))
-        FD_SET (1, &fds_w);
-
-      /*
-       * We are supposed to write and the buffer is empty
-       * -> select on read from stdin
-       */
-      if (write_open && (NULL == bufin_read))
-        FD_SET (0, &fds_r);
-
-      /*
-       * We are supposed to write and the buffer is not empty
-       * -> select on write to tun
-       */
-      if (write_open && (NULL != bufin_read))
-        FD_SET (fd_tun, &fds_w);        
-
-      int r = select (fd_tun + 1, &fds_r, &fds_w, NULL, NULL);
-      if (-1 == r)
-        {
-          if (EINTR == errno)
-            continue;
-          fprintf (stderr, "select failed: %s\n", strerror (errno));
-          exit (1);
-        }
-
-      if (r > 0)
-        {
-          if (FD_ISSET (fd_tun, &fds_r))
-            {
-              buftun_size =
-                read (fd_tun, buftun + sizeof (struct GNUNET_MessageHeader),
-                      MAX_SIZE - sizeof (struct GNUNET_MessageHeader));
-              if (-1 == buftun_size)
-                {
-                  fprintf (stderr, "read-error: %s\n", strerror (errno));
-                  shutdown (fd_tun, SHUT_RD);
-                  shutdown (1, SHUT_WR);
-                  read_open = 0;
-                  buftun_size = 0;
-                }
-              else if (0 == buftun_size)
-                {
-                  fprintf (stderr, "EOF on tun\n");
-                  shutdown (fd_tun, SHUT_RD);
-                  shutdown (1, SHUT_WR);
-                  read_open = 0;
-                  buftun_size = 0;
-                }
-              else
-                {
-                  buftun_read = buftun;
-                  struct GNUNET_MessageHeader *hdr =
-                    (struct GNUNET_MessageHeader *) buftun;
-                  buftun_size += sizeof (struct GNUNET_MessageHeader);
-                  hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
-                  hdr->size = htons (buftun_size);
-                }
-            }
-          else if (FD_ISSET (1, &fds_w))
-            {
-              ssize_t written = write (1, buftun_read, buftun_size);
-              if (-1 == written)
-                {
-                  fprintf (stderr, 
-                           "write-error to stdout: %s\n",
-                           strerror (errno));
-                  shutdown (fd_tun, SHUT_RD);
-                  shutdown (1, SHUT_WR);
-                  read_open = 0;
-                  buftun_size = 0;
-                }
-              else if (0 == written)
-                {
-                  fprintf (stderr, 
-                           "write returned 0!?\n");
-                  exit (1);
-                }
-              else
-                {
-                  buftun_size -= written;
-                  buftun_read += written;
-                }
-            }
-
-          if (FD_ISSET (0, &fds_r))
-            {
-              bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos);
-              if (-1 == bufin_size)
-                {
-                  fprintf (stderr, 
-                           "read-error: %s\n", 
-                           strerror (errno));
-                  shutdown (0, SHUT_RD);
-                  shutdown (fd_tun, SHUT_WR);
-                  write_open = 0;
-                  bufin_size = 0;
-                }
-              else if (0 == bufin_size)
-                {
-                  fprintf (stderr, 
-                           "EOF on stdin\n");
-                  shutdown (0, SHUT_RD);
-                  shutdown (fd_tun, SHUT_WR);
-                  write_open = 0;
-                  bufin_size = 0;
-                }
-              else
-                {
-                  struct GNUNET_MessageHeader *hdr;
-
-                PROCESS_BUFFER:
-                  bufin_rpos += bufin_size;
-                  if (bufin_rpos < sizeof (struct GNUNET_MessageHeader))
-                    continue;
-                  hdr = (struct GNUNET_MessageHeader *) bufin;
-                  if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
-                    {
-                      fprintf (stderr, "protocol violation!\n");
-                      exit (1);
-                    }
-                  if (ntohs (hdr->size) > bufin_rpos)
-                    continue;
-                  bufin_read = bufin + sizeof (struct GNUNET_MessageHeader);
-                  bufin_size = ntohs (hdr->size) - sizeof (struct GNUNET_MessageHeader);
-                  bufin_rpos -= bufin_size + sizeof (struct GNUNET_MessageHeader);
-                }
-            }
-          else if (FD_ISSET (fd_tun, &fds_w))
-            {
-              ssize_t written = write (fd_tun, bufin_read, bufin_size);
-              if (-1 == written)
-                {
-                  fprintf (stderr, "write-error to tun: %s\n",
-                           strerror (errno));
-                  shutdown (0, SHUT_RD);
-                  shutdown (fd_tun, SHUT_WR);
-                  write_open = 0;
-                  bufin_size = 0;
-                }
-              else if (0 == written)
-                {
-                  fprintf (stderr, 
-                           "write returned 0!?\n");
-                  exit (1);
-                }
-              else
-                {
-                  bufin_size -= written;
-                  bufin_read += written;
-                  if (0 == bufin_size)
-                    {
-                      memmove (bufin, 
-                               bufin_read,
-                               bufin_rpos);
-                      bufin_read = NULL; /* start reading again */
-                      bufin_size = 0;
-                      goto PROCESS_BUFFER;
-                    }
-                }
-            }
-        }
+      if (EINTR == errno)
+        continue;
+      fprintf (stderr, "select failed: %s\n", strerror (errno));
+      exit (1);
+    }
+
+    if (r > 0)
+    {
+      if (FD_ISSET (fd_tun, &fds_r))
+      {
+        buftun_size =
+            read (fd_tun, buftun + sizeof (struct GNUNET_MessageHeader),
+                  MAX_SIZE - sizeof (struct GNUNET_MessageHeader));
+        if (-1 == buftun_size)
+        {
+          fprintf (stderr, "read-error: %s\n", strerror (errno));
+          shutdown (fd_tun, SHUT_RD);
+          shutdown (1, SHUT_WR);
+          read_open = 0;
+          buftun_size = 0;
+        }
+        else if (0 == buftun_size)
+        {
+          fprintf (stderr, "EOF on tun\n");
+          shutdown (fd_tun, SHUT_RD);
+          shutdown (1, SHUT_WR);
+          read_open = 0;
+          buftun_size = 0;
+        }
+        else
+        {
+          buftun_read = buftun;
+          struct GNUNET_MessageHeader *hdr =
+              (struct GNUNET_MessageHeader *) buftun;
+          buftun_size += sizeof (struct GNUNET_MessageHeader);
+          hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
+          hdr->size = htons (buftun_size);
+        }
+      }
+      else if (FD_ISSET (1, &fds_w))
+      {
+        ssize_t written = write (1, buftun_read, buftun_size);
+
+        if (-1 == written)
+        {
+          fprintf (stderr, "write-error to stdout: %s\n", strerror (errno));
+          shutdown (fd_tun, SHUT_RD);
+          shutdown (1, SHUT_WR);
+          read_open = 0;
+          buftun_size = 0;
+        }
+        else if (0 == written)
+        {
+          fprintf (stderr, "write returned 0!?\n");
+          exit (1);
+        }
+        else
+        {
+          buftun_size -= written;
+          buftun_read += written;
+        }
+      }
+
+      if (FD_ISSET (0, &fds_r))
+      {
+        bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos);
+        if (-1 == bufin_size)
+        {
+          fprintf (stderr, "read-error: %s\n", strerror (errno));
+          shutdown (0, SHUT_RD);
+          shutdown (fd_tun, SHUT_WR);
+          write_open = 0;
+          bufin_size = 0;
+        }
+        else if (0 == bufin_size)
+        {
+          fprintf (stderr, "EOF on stdin\n");
+          shutdown (0, SHUT_RD);
+          shutdown (fd_tun, SHUT_WR);
+          write_open = 0;
+          bufin_size = 0;
+        }
+        else
+        {
+          struct GNUNET_MessageHeader *hdr;
+
+PROCESS_BUFFER:
+          bufin_rpos += bufin_size;
+          if (bufin_rpos < sizeof (struct GNUNET_MessageHeader))
+            continue;
+          hdr = (struct GNUNET_MessageHeader *) bufin;
+          if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
+          {
+            fprintf (stderr, "protocol violation!\n");
+            exit (1);
+          }
+          if (ntohs (hdr->size) > bufin_rpos)
+            continue;
+          bufin_read = bufin + sizeof (struct GNUNET_MessageHeader);
+          bufin_size = ntohs (hdr->size) - sizeof (struct GNUNET_MessageHeader);
+          bufin_rpos -= bufin_size + sizeof (struct GNUNET_MessageHeader);
+        }
+      }
+      else if (FD_ISSET (fd_tun, &fds_w))
+      {
+        ssize_t written = write (fd_tun, bufin_read, bufin_size);
+
+        if (-1 == written)
+        {
+          fprintf (stderr, "write-error to tun: %s\n", strerror (errno));
+          shutdown (0, SHUT_RD);
+          shutdown (fd_tun, SHUT_WR);
+          write_open = 0;
+          bufin_size = 0;
+        }
+        else if (0 == written)
+        {
+          fprintf (stderr, "write returned 0!?\n");
+          exit (1);
+        }
+        else
+        {
+          bufin_size -= written;
+          bufin_read += written;
+          if (0 == bufin_size)
+          {
+            memmove (bufin, bufin_read, bufin_rpos);
+            bufin_read = NULL;  /* start reading again */
+            bufin_size = 0;
+            goto PROCESS_BUFFER;
+          }
+        }
+      }
     }
+  }
 }
 
 
@@ -532,35 +506,33 @@ main (int argc, char **argv)
   int fd_tun;
 
   if (6 != argc)
-    {
-      fprintf (stderr, 
-               "Fatal: must supply 5 arguments!\n");
-      return 1;
-    }
+  {
+    fprintf (stderr, "Fatal: must supply 5 arguments!\n");
+    return 1;
+  }
 
-  strncpy(dev, argv[1], IFNAMSIZ);
+  strncpy (dev, argv[1], IFNAMSIZ);
   dev[IFNAMSIZ - 1] = '\0';
 
   if (-1 == (fd_tun = init_tun (dev)))
-    {
-      fprintf (stderr, 
-               "Fatal: could not initialize tun-interface\n");
-      return 1;
-    }
+  {
+    fprintf (stderr, "Fatal: could not initialize tun-interface\n");
+    return 1;
+  }
 
   {
     const char *address = argv[2];
-    long prefix_len = atol(argv[3]);
+    long prefix_len = atol (argv[3]);
 
-    if ( (prefix_len < 1) || (prefix_len > 127) )
-      {
-        fprintf(stderr, "Fatal: prefix_len out of range\n");
-        return 1;
-      }
+    if ((prefix_len < 1) || (prefix_len > 127))
+    {
+      fprintf (stderr, "Fatal: prefix_len out of range\n");
+      return 1;
+    }
 
     set_address6 (dev, address, prefix_len);
   }
-  
+
   {
     const char *address = argv[4];
     const char *mask = argv[5];
@@ -569,14 +541,12 @@ main (int argc, char **argv)
   }
 
   uid_t uid = getuid ();
+
   if (0 != setresuid (uid, uid, uid))
-    fprintf (stderr, 
-             "Failed to setresuid: %s\n",
-             strerror (errno));
+    fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
   if (SIG_ERR == signal (SIGPIPE, SIG_IGN))
-    fprintf (stderr, 
-             "Failed to protect against SIGPIPE: %s\n", 
-             strerror (errno));
+    fprintf (stderr,
+             "Failed to protect against SIGPIPE: %s\n", strerror (errno));
   run (fd_tun);
   close (fd_tun);
   return 0;
diff --git a/src/vpn/gnunet-service-dns-p.h b/src/vpn/gnunet-service-dns-p.h
index 6ffc2e58b..c48786d66 100644
--- a/src/vpn/gnunet-service-dns-p.h
+++ b/src/vpn/gnunet-service-dns-p.h
@@ -3,102 +3,108 @@
 
 #include "gnunet_common.h"
 
-struct query_packet {
-        struct GNUNET_MessageHeader hdr;
+struct query_packet
+{
+  struct GNUNET_MessageHeader hdr;
 
-        /**
+        /**
          * The IP-Address this query was originally sent to
          */
-        unsigned orig_to:32 GNUNET_PACKED;
-        /**
+  unsigned orig_to:32 GNUNET_PACKED;
+        /**
          * The IP-Address this query was originally sent from
          */
-        unsigned orig_from:32 GNUNET_PACKED;
-        /**
+  unsigned orig_from:32 GNUNET_PACKED;
+        /**
          * The UDP-Portthis query was originally sent from
          */
-        unsigned src_port:16 GNUNET_PACKED;
+  unsigned src_port:16 GNUNET_PACKED;
 
-        unsigned char data[1]; /* The DNS-Packet */
+  unsigned char data[1];        /* The DNS-Packet */
 };
 
-struct query_packet_list {
-        struct query_packet_list* next GNUNET_PACKED;
-        struct query_packet_list* prev GNUNET_PACKED;
-        struct query_packet pkt;
+struct query_packet_list
+{
+  struct query_packet_list *next GNUNET_PACKED;
+  struct query_packet_list *prev GNUNET_PACKED;
+  struct query_packet pkt;
 };
 
-enum GNUNET_DNS_ANSWER_Subtype {
+enum GNUNET_DNS_ANSWER_Subtype
+{
     /**
      * Answers of this type contain a dns-packet that just has to be transmitted
      */
-    GNUNET_DNS_ANSWER_TYPE_IP,
+  GNUNET_DNS_ANSWER_TYPE_IP,
 
     /**
      * Answers of this type contain an incomplete dns-packet. The IP-Address
      * is all 0s. The addroffset points to it.
      */
-    GNUNET_DNS_ANSWER_TYPE_SERVICE,
+  GNUNET_DNS_ANSWER_TYPE_SERVICE,
 
     /**
      * Answers of this type contain an incomplete dns-packet as answer to a
      * PTR-Query. The resolved name is not allocated. The addroffset points to it.
      */
-    GNUNET_DNS_ANSWER_TYPE_REV,
+  GNUNET_DNS_ANSWER_TYPE_REV,
 
     /**
      * Answers of this type contains an IP6-Address but traffic to this IP should
      * be routed through the GNUNet.
      */
-    GNUNET_DNS_ANSWER_TYPE_REMOTE_AAAA,
+  GNUNET_DNS_ANSWER_TYPE_REMOTE_AAAA,
 
     /**
      * Answers of this type contains an IP4-Address but traffic to this IP should
      * be routed through the GNUNet.
      */
-    GNUNET_DNS_ANSWER_TYPE_REMOTE_A
+  GNUNET_DNS_ANSWER_TYPE_REMOTE_A
 };
 
-struct GNUNET_vpn_service_descriptor {
-    GNUNET_HashCode peer GNUNET_PACKED;
-    GNUNET_HashCode service_descriptor GNUNET_PACKED;
-    uint64_t ports GNUNET_PACKED;
-    uint32_t service_type GNUNET_PACKED;
+struct GNUNET_vpn_service_descriptor
+{
+  GNUNET_HashCode peer GNUNET_PACKED;
+  GNUNET_HashCode service_descriptor GNUNET_PACKED;
+  uint64_t ports GNUNET_PACKED;
+  uint32_t service_type GNUNET_PACKED;
 };
 
-struct answer_packet {
-    /* General data */
-    struct GNUNET_MessageHeader hdr;
-    enum GNUNET_DNS_ANSWER_Subtype subtype GNUNET_PACKED;
-
-    unsigned from:32 GNUNET_PACKED;
-    unsigned to:32 GNUNET_PACKED;
-    unsigned dst_port:16 GNUNET_PACKED;
-    /* -- */
-
-    /* Data for GNUNET_DNS_ANSWER_TYPE_SERVICE */
-    struct GNUNET_vpn_service_descriptor service_descr;
-    /* -- */
-
-    /* Data for GNUNET_DNS_ANSWER_TYPE_REV */
-    /* The offsett in octets from the beginning of the struct to the field
-     * in data where the IP-Address has to go. */
-    uint16_t addroffset GNUNET_PACKED;
-    /* -- */
-
-    /* Data for GNUNET_DNS_ANSWER_TYPE_REMOTE */
-    /* either 4 or 16 */
-    char addrsize;
-    unsigned char addr[16];
-    /* -- */
-
-    unsigned char data[1];
+struct answer_packet
+{
+  /* General data */
+  struct GNUNET_MessageHeader hdr;
+  enum GNUNET_DNS_ANSWER_Subtype subtype GNUNET_PACKED;
+
+  unsigned from:32 GNUNET_PACKED;
+  unsigned to:32 GNUNET_PACKED;
+  unsigned dst_port:16 GNUNET_PACKED;
+  /* -- */
+
+  /* Data for GNUNET_DNS_ANSWER_TYPE_SERVICE */
+  struct GNUNET_vpn_service_descriptor service_descr;
+  /* -- */
+
+  /* Data for GNUNET_DNS_ANSWER_TYPE_REV */
+  /* The offsett in octets from the beginning of the struct to the field
+   * in data where the IP-Address has to go. */
+  uint16_t addroffset GNUNET_PACKED;
+  /* -- */
+
+  /* Data for GNUNET_DNS_ANSWER_TYPE_REMOTE */
+  /* either 4 or 16 */
+  char addrsize;
+  unsigned char addr[16];
+  /* -- */
+
+  unsigned char data[1];
 };
 
-struct answer_packet_list {
-        struct answer_packet_list* next GNUNET_PACKED;
-        struct answer_packet_list* prev GNUNET_PACKED;
-        struct answer_packet pkt;
+struct answer_packet_list
+{
+  struct answer_packet_list *next GNUNET_PACKED;
+  struct answer_packet_list *prev GNUNET_PACKED;
+  struct answer_packet pkt;
 };
 
 #endif
diff --git a/src/vpn/gnunet-service-dns.c b/src/vpn/gnunet-service-dns.c
index fca21ee4d..9959e9564 100644
--- a/src/vpn/gnunet-service-dns.c
+++ b/src/vpn/gnunet-service-dns.c
@@ -83,31 +83,33 @@ static struct answer_packet_list *tail;
  * = 17 MiB on 64 bit.
  * = 11 MiB on 32 bit.
  */
-static struct {
-    unsigned valid:1;
-    struct GNUNET_SERVER_Client* client;
-    struct GNUNET_MESH_Tunnel *tunnel;
-    uint32_t local_ip;
-    uint32_t remote_ip;
-    uint16_t local_port;
-    char* name;
-    uint8_t namelen;
+static struct
+{
+  unsigned valid:1;
+  struct GNUNET_SERVER_Client *client;
+  struct GNUNET_MESH_Tunnel *tunnel;
+  uint32_t local_ip;
+  uint32_t remote_ip;
+  uint16_t local_port;
+  char *name;
+  uint8_t namelen;
 } query_states[UINT16_MAX];
 
 /**
  * A struct used to give more than one value as
  * closure to receive_dht
  */
-struct receive_dht_cls {
-    uint16_t id;
-    struct GNUNET_DHT_GetHandle* handle;
+struct receive_dht_cls
+{
+  uint16_t id;
+  struct GNUNET_DHT_GetHandle *handle;
 };
 
 struct tunnel_notify_queue
 {
-  struct tunnel_notify_queue* next;
-  struct tunnel_notify_queue* prev;
-  void* cls;
+  struct tunnel_notify_queue *next;
+  struct tunnel_notify_queue *prev;
+  void *cls;
   size_t len;
   GNUNET_CONNECTION_TransmitReadyNotify cb;
 };
@@ -116,30 +118,31 @@ struct tunnel_notify_queue
  * Hijack all outgoing DNS-Traffic but for traffic leaving "our" port.
  */
 static void
-hijack (void *cls __attribute__((unused)), const struct GNUNET_SCHEDULER_TaskContext *tc)
+hijack (void *cls
+        __attribute__ ((unused)), const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
   if (0 == dnsoutport)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Delaying the hijacking, port is still %d!\n", dnsoutport);
-      GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Delaying the hijacking, port is still %d!\n", dnsoutport);
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
+    return;
+  }
 
   char port_s[6];
   char *virt_dns;
   struct GNUNET_OS_Process *proc;
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "VIRTDNS",
-                                             &virt_dns))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "No entry 'VIRTDNS' in configuration!\n");
-      exit (1);
-    }
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "VIRTDNS", &virt_dns))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'VIRTDNS' in configuration!\n");
+    exit (1);
+  }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hijacking, port is %d\n", dnsoutport);
   snprintf (port_s, 6, "%d", dnsoutport);
@@ -163,13 +166,12 @@ unhijack (unsigned short port)
   struct GNUNET_OS_Process *proc;
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "VIRTDNS",
-                                             &virt_dns))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "No entry 'VIRTDNS' in configuration!\n");
-      exit (1);
-    }
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "VIRTDNS", &virt_dns))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'VIRTDNS' in configuration!\n");
+    exit (1);
+  }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "unHijacking, port is %d\n", port);
   snprintf (port_s, 6, "%d", port);
@@ -187,33 +189,34 @@ unhijack (unsigned short port)
  * system.
  */
 static size_t
-send_answer(void* cls, size_t size, void* buf) {
-    struct answer_packet_list* query = head;
-    size_t len = ntohs(query->pkt.hdr.size);
+send_answer (void *cls, size_t size, void *buf)
+{
+  struct answer_packet_list *query = head;
+  size_t len = ntohs (query->pkt.hdr.size);
 
-    GNUNET_assert(len <= size);
+  GNUNET_assert (len <= size);
 
-    memcpy(buf, &query->pkt.hdr, len);
+  memcpy (buf, &query->pkt.hdr, len);
 
-    GNUNET_CONTAINER_DLL_remove (head, tail, query);
+  GNUNET_CONTAINER_DLL_remove (head, tail, query);
 
-    GNUNET_free(query);
+  GNUNET_free (query);
 
-    /* When more data is to be sent, reschedule */
-    if (head != NULL)
-      GNUNET_SERVER_notify_transmit_ready(cls,
-                                          ntohs(head->pkt.hdr.size),
-                                          GNUNET_TIME_UNIT_FOREVER_REL,
-                                          &send_answer,
-                                          cls);
+  /* When more data is to be sent, reschedule */
+  if (head != NULL)
+    GNUNET_SERVER_notify_transmit_ready (cls,
+                                         ntohs (head->pkt.hdr.size),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         &send_answer, cls);
 
-    return len;
+  return len;
 }
 
-struct tunnel_cls {
-    struct GNUNET_MESH_Tunnel *tunnel GNUNET_PACKED;
-    struct GNUNET_MessageHeader hdr;
-    struct dns_pkt dns;
+struct tunnel_cls
+{
+  struct GNUNET_MESH_Tunnel *tunnel GNUNET_PACKED;
+  struct GNUNET_MessageHeader hdr;
+  struct dns_pkt dns;
 };
 
 struct tunnel_cls *remote_pending[UINT16_MAX];
@@ -224,8 +227,9 @@ mesh_send_response (void *cls, size_t size, void *buf)
   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   struct GNUNET_MessageHeader *hdr = buf;
   uint32_t *sz = cls;
-  struct GNUNET_MESH_Tunnel **tunnel = (struct GNUNET_MESH_Tunnel**)(sz+1);
+  struct GNUNET_MESH_Tunnel **tunnel = (struct GNUNET_MESH_Tunnel **) (sz + 1);
   struct dns_pkt *dns = (struct dns_pkt *) (tunnel + 1);
+
   hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_REMOTE_ANSWER_DNS);
   hdr->size = htons (*sz + sizeof (struct GNUNET_MessageHeader));
 
@@ -237,27 +241,29 @@ mesh_send_response (void *cls, size_t size, void *buf)
 
   memcpy (hdr + 1, dns, *sz);
 
-  if (NULL != GNUNET_MESH_tunnel_get_head(*tunnel))
-    {
-      struct tunnel_notify_queue* element = GNUNET_MESH_tunnel_get_head(*tunnel);
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(*tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(*tunnel);
-
-      GNUNET_CONTAINER_DLL_remove(head, tail, element);
-
-      GNUNET_MESH_tunnel_set_head(*tunnel, head);
-      GNUNET_MESH_tunnel_set_tail(*tunnel, tail);
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (*tunnel,
-                                                                                 GNUNET_NO,
-                                                                                 42,
-                                                                                 GNUNET_TIME_relative_divide
-                                                                                 (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                                                                 (const struct GNUNET_PeerIdentity *)
-                                                                                 NULL, element->len,
-                                                                                 element->cb, element->cls);
-      /* save the handle */
-      GNUNET_MESH_tunnel_set_data(*tunnel, th);
-    }
+  if (NULL != GNUNET_MESH_tunnel_get_head (*tunnel))
+  {
+    struct tunnel_notify_queue *element = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *head = GNUNET_MESH_tunnel_get_head (*tunnel);
+    struct tunnel_notify_queue *tail = GNUNET_MESH_tunnel_get_tail (*tunnel);
+
+    GNUNET_CONTAINER_DLL_remove (head, tail, element);
+
+    GNUNET_MESH_tunnel_set_head (*tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (*tunnel, tail);
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (*tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL, element->len,
+                                           element->cb, element->cls);
+
+    /* save the handle */
+    GNUNET_MESH_tunnel_set_data (*tunnel, th);
+  }
 
   GNUNET_free (cls);
 
@@ -268,37 +274,43 @@ static size_t
 mesh_send (void *cls, size_t size, void *buf)
 {
   struct tunnel_cls *cls_ = (struct tunnel_cls *) cls;
-  GNUNET_MESH_tunnel_set_data(cls_->tunnel, NULL);
 
-  GNUNET_assert(cls_->hdr.size <= size);
+  GNUNET_MESH_tunnel_set_data (cls_->tunnel, NULL);
+
+  GNUNET_assert (cls_->hdr.size <= size);
 
   size = cls_->hdr.size;
-  cls_->hdr.size = htons(cls_->hdr.size);
+  cls_->hdr.size = htons (cls_->hdr.size);
 
-  memcpy(buf, &cls_->hdr, size);
+  memcpy (buf, &cls_->hdr, size);
 
-  if (NULL != GNUNET_MESH_tunnel_get_head(cls_->tunnel))
-    {
-      struct tunnel_notify_queue* element = GNUNET_MESH_tunnel_get_head(cls_->tunnel);
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(cls_->tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(cls_->tunnel);
-
-      GNUNET_CONTAINER_DLL_remove(head, tail, element);
-
-      GNUNET_MESH_tunnel_set_head(cls_->tunnel, head);
-      GNUNET_MESH_tunnel_set_tail(cls_->tunnel, tail);
-      struct GNUNET_MESH_TransmitHandle* th = GNUNET_MESH_notify_transmit_ready (cls_->tunnel,
-                                                                                 GNUNET_NO,
-                                                                                 42,
-                                                                                 GNUNET_TIME_relative_divide
-                                                                                 (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
-                                                                                 (const struct GNUNET_PeerIdentity *)
-                                                                                 NULL, element->len,
-                                                                                 element->cb, element->cls);
-      /* save the handle */
-      GNUNET_MESH_tunnel_set_data(cls_->tunnel, th);
-      GNUNET_free(element);
-    }
+  if (NULL != GNUNET_MESH_tunnel_get_head (cls_->tunnel))
+  {
+    struct tunnel_notify_queue *element =
+        GNUNET_MESH_tunnel_get_head (cls_->tunnel);
+    struct tunnel_notify_queue *head =
+        GNUNET_MESH_tunnel_get_head (cls_->tunnel);
+    struct tunnel_notify_queue *tail =
+        GNUNET_MESH_tunnel_get_tail (cls_->tunnel);
+
+    GNUNET_CONTAINER_DLL_remove (head, tail, element);
+
+    GNUNET_MESH_tunnel_set_head (cls_->tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (cls_->tunnel, tail);
+    struct GNUNET_MESH_TransmitHandle *th =
+        GNUNET_MESH_notify_transmit_ready (cls_->tunnel,
+                                           GNUNET_NO,
+                                           42,
+                                           GNUNET_TIME_relative_divide
+                                           (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2),
+                                           (const struct GNUNET_PeerIdentity *)
+                                           NULL, element->len,
+                                           element->cb, element->cls);
+
+    /* save the handle */
+    GNUNET_MESH_tunnel_set_data (cls_->tunnel, th);
+    GNUNET_free (element);
+  }
 
   return size;
 }
@@ -312,13 +324,14 @@ mesh_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
   if (NULL == peer)
     return;
   struct tunnel_cls *cls_ = (struct tunnel_cls *) cls;
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Connected to peer %s, %x, sending query with id %d\n",
               GNUNET_i2s (peer), peer, ntohs (cls_->dns.s.id));
 
   if (NULL == GNUNET_MESH_tunnel_get_data (cls_->tunnel))
-    {
-      struct GNUNET_MESH_TransmitHandle *th =
+  {
+    struct GNUNET_MESH_TransmitHandle *th =
         GNUNET_MESH_notify_transmit_ready (cls_->tunnel,
                                            GNUNET_YES,
                                            42,
@@ -328,22 +341,25 @@ mesh_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
                                            mesh_send,
                                            cls);
 
-      GNUNET_MESH_tunnel_set_data (cls_->tunnel, th);
-    }
+    GNUNET_MESH_tunnel_set_data (cls_->tunnel, th);
+  }
   else
-    {
-      struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(cls_->tunnel);
-      struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(cls_->tunnel);
-
-      struct tunnel_notify_queue* element = GNUNET_malloc(sizeof(struct tunnel_notify_queue));
-      element->cls = cls;
-      element->len = cls_->hdr.size;
-      element->cb = mesh_send;
-
-      GNUNET_CONTAINER_DLL_insert_tail(head, tail, element);
-      GNUNET_MESH_tunnel_set_head(cls_->tunnel, head);
-      GNUNET_MESH_tunnel_set_tail(cls_->tunnel, tail);
-    }
+  {
+    struct tunnel_notify_queue *head =
+        GNUNET_MESH_tunnel_get_head (cls_->tunnel);
+    struct tunnel_notify_queue *tail =
+        GNUNET_MESH_tunnel_get_tail (cls_->tunnel);
+
+    struct tunnel_notify_queue *element =
+        GNUNET_malloc (sizeof (struct tunnel_notify_queue));
+    element->cls = cls;
+    element->len = cls_->hdr.size;
+    element->cb = mesh_send;
+
+    GNUNET_CONTAINER_DLL_insert_tail (head, tail, element);
+    GNUNET_MESH_tunnel_set_head (cls_->tunnel, head);
+    GNUNET_MESH_tunnel_set_tail (cls_->tunnel, tail);
+  }
 }
 
 
@@ -353,54 +369,58 @@ send_mesh_query (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
-  struct tunnel_cls *cls_ = (struct tunnel_cls*)cls;
+  struct tunnel_cls *cls_ = (struct tunnel_cls *) cls;
 
-  cls_->tunnel = GNUNET_MESH_peer_request_connect_by_type(mesh_handle,
-                                           GNUNET_TIME_UNIT_HOURS,
-                                           GNUNET_APPLICATION_TYPE_INTERNET_RESOLVER,
-                                           mesh_connect,
-                                           NULL,
-                                           cls_);
+  cls_->tunnel = GNUNET_MESH_peer_request_connect_by_type (mesh_handle,
+                                                           GNUNET_TIME_UNIT_HOURS,
+                                                           GNUNET_APPLICATION_TYPE_INTERNET_RESOLVER,
+                                                           mesh_connect,
+                                                           NULL, cls_);
 
   remote_pending[cls_->dns.s.id] = cls_;
 }
 
 static int
-receive_mesh_query (void *cls __attribute__((unused)),
+receive_mesh_query (void *cls __attribute__ ((unused)),
                     struct GNUNET_MESH_Tunnel *tunnel,
-                    void **ctx __attribute__((unused)),
-                    const struct GNUNET_PeerIdentity *sender __attribute__((unused)),
+                    void **ctx __attribute__ ((unused)),
+                    const struct GNUNET_PeerIdentity *sender
+                    __attribute__ ((unused)),
                     const struct GNUNET_MessageHeader *message,
-                    const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+                    const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                    __attribute__ ((unused)))
 {
-  struct dns_pkt *dns = (struct dns_pkt*)(message + 1);
+  struct dns_pkt *dns = (struct dns_pkt *) (message + 1);
 
   struct sockaddr_in dest;
-  memset(&dest, 0, sizeof dest);
-  dest.sin_port = htons(53);
+
+  memset (&dest, 0, sizeof dest);
+  dest.sin_port = htons (53);
   /* TODO: read from config */
-  inet_pton(AF_INET, "8.8.8.8", &dest.sin_addr);
+  inet_pton (AF_INET, "8.8.8.8", &dest.sin_addr);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Querying for remote, id=%d\n", ntohs(dns->s.id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Querying for remote, id=%d\n",
+              ntohs (dns->s.id));
   query_states[dns->s.id].tunnel = tunnel;
   query_states[dns->s.id].valid = GNUNET_YES;
 
-  GNUNET_NETWORK_socket_sendto(dnsout,
-                               dns,
-                               ntohs(message->size) - sizeof(struct GNUNET_MessageHeader),
-                               (struct sockaddr*) &dest,
-                               sizeof dest);
+  GNUNET_NETWORK_socket_sendto (dnsout,
+                                dns,
+                                ntohs (message->size) -
+                                sizeof (struct GNUNET_MessageHeader),
+                                (struct sockaddr *) &dest, sizeof dest);
 
   return GNUNET_SYSERR;
 }
 
 static int
-receive_mesh_answer (void *cls __attribute__((unused)),
+receive_mesh_answer (void *cls __attribute__ ((unused)),
                      struct GNUNET_MESH_Tunnel *tunnel,
-                     void **ctx __attribute__((unused)),
+                     void **ctx __attribute__ ((unused)),
                      const struct GNUNET_PeerIdentity *sender,
                      const struct GNUNET_MessageHeader *message,
-                     const struct GNUNET_TRANSPORT_ATS_Information *atsi __attribute__((unused)))
+                     const struct GNUNET_TRANSPORT_ATS_Information *atsi
+                     __attribute__ ((unused)))
 {
   /* TODo: size check */
   struct dns_pkt *dns = (struct dns_pkt *) (message + 1);
@@ -410,37 +430,42 @@ receive_mesh_answer (void *cls __attribute__((unused)),
       || remote_pending[dns->s.id]->tunnel != tunnel)
     return GNUNET_OK;
 
-  GNUNET_free(remote_pending[dns->s.id]);
+  GNUNET_free (remote_pending[dns->s.id]);
   remote_pending[dns->s.id] = NULL;
 
   if (query_states[dns->s.id].valid != GNUNET_YES)
     return GNUNET_SYSERR;
   query_states[dns->s.id].valid = GNUNET_NO;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received answer from peer %s, dns-id %d\n", GNUNET_i2s(sender), ntohs(dns->s.id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received answer from peer %s, dns-id %d\n", GNUNET_i2s (sender),
+              ntohs (dns->s.id));
 
   size_t len = sizeof (struct answer_packet) - 1 + sizeof (struct dns_static) + query_states[dns->s.id].namelen + sizeof (struct dns_query_line) + 2    /* To hold the pointer (as defined in RFC1035) to the name */
-    + sizeof (struct dns_record_line) - 1 + 16; /* To hold the IPv6-Address */
+      + sizeof (struct dns_record_line) - 1 + 16;       /* To hold the IPv6-Address */
 
   struct answer_packet_list *answer =
-    GNUNET_malloc (len + 2 * sizeof (struct answer_packet_list *));
+      GNUNET_malloc (len + 2 * sizeof (struct answer_packet_list *));
   memset (answer, 0, len + 2 * sizeof (struct answer_packet_list *));
 
   answer->pkt.hdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
   answer->pkt.hdr.size = htons (len);
 
-  struct dns_pkt_parsed* pdns = parse_dns_packet(dns);
+  struct dns_pkt_parsed *pdns = parse_dns_packet (dns);
 
-  if (ntohs(pdns->s.ancount) < 1)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Answer only contains %d answers.\n", ntohs(pdns->s.ancount));
-      free_parsed_dns_packet(pdns);
-      return GNUNET_OK;
-    }
+  if (ntohs (pdns->s.ancount) < 1)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Answer only contains %d answers.\n",
+                ntohs (pdns->s.ancount));
+    free_parsed_dns_packet (pdns);
+    return GNUNET_OK;
+  }
 
-  answer->pkt.addrsize = ntohs(pdns->answers[0]->data_len);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "The first answer has the addrlen %d\n", answer->pkt.addrsize);
-  memcpy(answer->pkt.addr, pdns->answers[0]->data, ntohs(pdns->answers[0]->data_len));
+  answer->pkt.addrsize = ntohs (pdns->answers[0]->data_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "The first answer has the addrlen %d\n",
+              answer->pkt.addrsize);
+  memcpy (answer->pkt.addr, pdns->answers[0]->data,
+          ntohs (pdns->answers[0]->data_len));
 
   answer->pkt.from = query_states[dns->s.id].remote_ip;
 
@@ -462,32 +487,32 @@ receive_mesh_answer (void *cls __attribute__((unused)),
   query_states[dns->s.id].name = NULL;
 
   struct dns_query_line *dque =
-    (struct dns_query_line *) (dpkt->data +
-                               (query_states[dns->s.id].namelen));
+      (struct dns_query_line *) (dpkt->data +
+                                 (query_states[dns->s.id].namelen));
 
   struct dns_record_line *drec_data =
-    (struct dns_record_line *) (dpkt->data +
-                                (query_states[dns->s.id].namelen) +
-                                sizeof (struct dns_query_line) + 2);
+      (struct dns_record_line *) (dpkt->data +
+                                  (query_states[dns->s.id].namelen) +
+                                  sizeof (struct dns_query_line) + 2);
   if (16 == answer->pkt.addrsize)
-    {
-      answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REMOTE_AAAA;
-      dque->type = htons (28);      /* AAAA */
-      drec_data->type = htons (28); /* AAAA */
-      drec_data->data_len = htons (16);
-    }
+  {
+    answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REMOTE_AAAA;
+    dque->type = htons (28);    /* AAAA */
+    drec_data->type = htons (28);       /* AAAA */
+    drec_data->data_len = htons (16);
+  }
   else
-    {
-      answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REMOTE_A;
-      dque->type = htons (1);      /* A */
-      drec_data->type = htons (1); /* A*/
-      drec_data->data_len = htons (4);
-    }
+  {
+    answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REMOTE_A;
+    dque->type = htons (1);     /* A */
+    drec_data->type = htons (1);        /* A */
+    drec_data->data_len = htons (4);
+  }
   dque->class = htons (1);      /* IN */
 
   char *anname =
-    (char *) (dpkt->data + (query_states[dns->s.id].namelen) +
-              sizeof (struct dns_query_line));
+      (char *) (dpkt->data + (query_states[dns->s.id].namelen) +
+                sizeof (struct dns_query_line));
   memcpy (anname, "\xc0\x0c", 2);
   drec_data->class = htons (1); /* IN */
 
@@ -496,8 +521,8 @@ receive_mesh_answer (void *cls __attribute__((unused)),
   /* Calculate at which offset in the packet the IPv6-Address belongs, it is
    * filled in by the daemon-vpn */
   answer->pkt.addroffset =
-    htons ((unsigned short) ((unsigned long) (&drec_data->data) -
-                             (unsigned long) (&answer->pkt)));
+      htons ((unsigned short) ((unsigned long) (&drec_data->data) -
+                               (unsigned long) (&answer->pkt)));
 
   GNUNET_CONTAINER_DLL_insert_after (head, tail, tail, answer);
 
@@ -507,378 +532,408 @@ receive_mesh_answer (void *cls __attribute__((unused)),
                                        &send_answer,
                                        query_states[dns->s.id].client);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sent answer of length %d on to client, addroffset = %d\n", len, answer->pkt.addroffset);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sent answer of length %d on to client, addroffset = %d\n", len,
+              answer->pkt.addroffset);
 
-  free_parsed_dns_packet(pdns);
+  free_parsed_dns_packet (pdns);
   return GNUNET_OK;
 }
 
 
 static void
-send_rev_query(void * cls, const struct GNUNET_SCHEDULER_TaskContext *tc) {
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      return;
-
-    struct dns_pkt_parsed* pdns = (struct dns_pkt_parsed*) cls;
+send_rev_query (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
 
-    unsigned short id = pdns->s.id;
+  struct dns_pkt_parsed *pdns = (struct dns_pkt_parsed *) cls;
 
-    free_parsed_dns_packet(pdns);
+  unsigned short id = pdns->s.id;
 
-    if (query_states[id].valid != GNUNET_YES) return;
-    query_states[id].valid = GNUNET_NO;
+  free_parsed_dns_packet (pdns);
 
-    GNUNET_assert(query_states[id].namelen == 74);
+  if (query_states[id].valid != GNUNET_YES)
+    return;
+  query_states[id].valid = GNUNET_NO;
 
-    size_t len = sizeof(struct answer_packet) - 1 \
-                 + sizeof(struct dns_static) \
-                 + 74 /* this is the length of a reverse ipv6-lookup */ \
-                 + sizeof(struct dns_query_line) \
-                 + 2 /* To hold the pointer (as defined in RFC1035) to the name */ \
-                 + sizeof(struct dns_record_line) - 1 \
-                 - 2 /* We do not know the lenght of the answer yet*/;
+  GNUNET_assert (query_states[id].namelen == 74);
 
-    struct answer_packet_list* answer = GNUNET_malloc(len + 2*sizeof(struct answer_packet_list*));
-    memset(answer, 0, len + 2*sizeof(struct answer_packet_list*));
+  size_t len = sizeof (struct answer_packet) - 1 + sizeof (struct dns_static) + 74      /* this is the length of a reverse ipv6-lookup */
+      + sizeof (struct dns_query_line) + 2      /* To hold the pointer (as defined in RFC1035) to the name */
+      + sizeof (struct dns_record_line) - 1
+      - 2 /* We do not know the lenght of the answer yet */ ;
 
-    answer->pkt.hdr.type = htons(GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
-    answer->pkt.hdr.size = htons(len);
-    answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REV;
+  struct answer_packet_list *answer =
+      GNUNET_malloc (len + 2 * sizeof (struct answer_packet_list *));
+  memset (answer, 0, len + 2 * sizeof (struct answer_packet_list *));
 
-    answer->pkt.from = query_states[id].remote_ip;
+  answer->pkt.hdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
+  answer->pkt.hdr.size = htons (len);
+  answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REV;
 
-    answer->pkt.to = query_states[id].local_ip;
-    answer->pkt.dst_port = query_states[id].local_port;
+  answer->pkt.from = query_states[id].remote_ip;
 
-    struct dns_pkt *dpkt = (struct dns_pkt*)answer->pkt.data;
+  answer->pkt.to = query_states[id].local_ip;
+  answer->pkt.dst_port = query_states[id].local_port;
 
-    dpkt->s.id = id;
-    dpkt->s.aa = 1;
-    dpkt->s.qr = 1;
-    dpkt->s.ra = 1;
-    dpkt->s.qdcount = htons(1);
-    dpkt->s.ancount = htons(1);
+  struct dns_pkt *dpkt = (struct dns_pkt *) answer->pkt.data;
 
-    memcpy(dpkt->data, query_states[id].name, query_states[id].namelen);
-    GNUNET_free(query_states[id].name);
+  dpkt->s.id = id;
+  dpkt->s.aa = 1;
+  dpkt->s.qr = 1;
+  dpkt->s.ra = 1;
+  dpkt->s.qdcount = htons (1);
+  dpkt->s.ancount = htons (1);
 
-    struct dns_query_line* dque = (struct dns_query_line*)(dpkt->data+(query_states[id].namelen));
-    dque->type = htons(12); /* PTR */
-    dque->class = htons(1); /* IN */
+  memcpy (dpkt->data, query_states[id].name, query_states[id].namelen);
+  GNUNET_free (query_states[id].name);
 
-    char* anname = (char*)(dpkt->data+(query_states[id].namelen)+sizeof(struct dns_query_line));
-    memcpy(anname, "\xc0\x0c", 2);
+  struct dns_query_line *dque =
+      (struct dns_query_line *) (dpkt->data + (query_states[id].namelen));
+  dque->type = htons (12);      /* PTR */
+  dque->class = htons (1);      /* IN */
 
-    struct dns_record_line *drec_data = (struct dns_record_line*)(dpkt->data+(query_states[id].namelen)+sizeof(struct dns_query_line)+2);
-    drec_data->type = htons(12); /* AAAA */
-    drec_data->class = htons(1); /* IN */
-    /* FIXME: read the TTL from block:
-     * GNUNET_TIME_absolute_get_remaining(rec->expiration_time)
-     *
-     * But how to get the seconds out of this?
-     */
-    drec_data->ttl = htonl(3600);
+  char *anname =
+      (char *) (dpkt->data + (query_states[id].namelen) +
+                sizeof (struct dns_query_line));
+  memcpy (anname, "\xc0\x0c", 2);
 
-    /* Calculate at which offset in the packet the length of the name and the
-     * name, it is filled in by the daemon-vpn */
-    answer->pkt.addroffset = htons((unsigned short)((unsigned long)(&drec_data->data_len)-(unsigned long)(&answer->pkt)));
+  struct dns_record_line *drec_data =
+      (struct dns_record_line *) (dpkt->data + (query_states[id].namelen) +
+                                  sizeof (struct dns_query_line) + 2);
+  drec_data->type = htons (12); /* AAAA */
+  drec_data->class = htons (1); /* IN */
+  /* FIXME: read the TTL from block:
+   * GNUNET_TIME_absolute_get_remaining(rec->expiration_time)
+   *
+   * But how to get the seconds out of this?
+   */
+  drec_data->ttl = htonl (3600);
+
+  /* Calculate at which offset in the packet the length of the name and the
+   * name, it is filled in by the daemon-vpn */
+  answer->pkt.addroffset =
+      htons ((unsigned short) ((unsigned long) (&drec_data->data_len) -
+                               (unsigned long) (&answer->pkt)));
 
-    GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, answer);
+  GNUNET_CONTAINER_DLL_insert_after (head, tail, tail, answer);
 
-    GNUNET_SERVER_notify_transmit_ready(query_states[id].client,
-                                        len,
-                                        GNUNET_TIME_UNIT_FOREVER_REL,
-                                        &send_answer,
-                                        query_states[id].client);
+  GNUNET_SERVER_notify_transmit_ready (query_states[id].client,
+                                       len,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &send_answer, query_states[id].client);
 }
 
 /**
  * Receive a block from the dht.
  */
 static void
-receive_dht(void *cls,
-            struct GNUNET_TIME_Absolute exp __attribute__((unused)),
-            const GNUNET_HashCode *key __attribute__((unused)),
-            const struct GNUNET_PeerIdentity *const *get_path __attribute__((unused)),
-            const struct GNUNET_PeerIdentity *const *put_path __attribute__((unused)),
-            enum GNUNET_BLOCK_Type type,
-            size_t size,
-            const void *data) {
-
-    unsigned short id = ((struct receive_dht_cls*)cls)->id;
-    struct GNUNET_DHT_GetHandle* handle = ((struct receive_dht_cls*)cls)->handle;
-    GNUNET_free(cls);
-
-    GNUNET_assert(type == GNUNET_BLOCK_TYPE_DNS);
-
-    /* If no query with this id is pending, ignore the block */
-    if (query_states[id].valid != GNUNET_YES) return;
-    query_states[id].valid = GNUNET_NO;
-
-    const struct GNUNET_DNS_Record* rec = data;
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Got block of size %d, peer: %08x, desc: %08x\n",
-               size,
-               *((unsigned int*)&rec->peer),
-               *((unsigned int*)&rec->service_descriptor));
-
-    size_t len = sizeof(struct answer_packet) - 1 \
-                 + sizeof(struct dns_static) \
-                 + query_states[id].namelen \
-                 + sizeof(struct dns_query_line) \
-                 + 2 /* To hold the pointer (as defined in RFC1035) to the name */ \
-                 + sizeof(struct dns_record_line) - 1 \
-                 + 16; /* To hold the IPv6-Address */
-
-    struct answer_packet_list* answer = GNUNET_malloc(len + 2*sizeof(struct answer_packet_list*));
-    memset(answer, 0, len + 2*sizeof(struct answer_packet_list*));
-
-    answer->pkt.hdr.type = htons(GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
-    answer->pkt.hdr.size = htons(len);
-    answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_SERVICE;
-
-    GNUNET_CRYPTO_hash(&rec->peer,
-                       sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                       &answer->pkt.service_descr.peer);
-
-    memcpy(&answer->pkt.service_descr.service_descriptor,
-           &rec->service_descriptor,
-           sizeof(GNUNET_HashCode));
-    memcpy(&answer->pkt.service_descr.service_type,
-           &rec->service_type,
-           sizeof(answer->pkt.service_descr.service_type));
-    memcpy(&answer->pkt.service_descr.ports, &rec->ports, sizeof(answer->pkt.service_descr.ports));
-
-    answer->pkt.from = query_states[id].remote_ip;
-
-    answer->pkt.to = query_states[id].local_ip;
-    answer->pkt.dst_port = query_states[id].local_port;
-
-    struct dns_pkt *dpkt = (struct dns_pkt*)answer->pkt.data;
-
-    dpkt->s.id = id;
-    dpkt->s.aa = 1;
-    dpkt->s.qr = 1;
-    dpkt->s.ra = 1;
-    dpkt->s.qdcount = htons(1);
-    dpkt->s.ancount = htons(1);
-
-    memcpy(dpkt->data, query_states[id].name, query_states[id].namelen);
-    GNUNET_free(query_states[id].name);
-
-    struct dns_query_line* dque = (struct dns_query_line*)(dpkt->data+(query_states[id].namelen));
-    dque->type = htons(28); /* AAAA */
-    dque->class = htons(1); /* IN */
-
-    char* anname = (char*)(dpkt->data+(query_states[id].namelen)+sizeof(struct dns_query_line));
-    memcpy(anname, "\xc0\x0c", 2);
-
-    struct dns_record_line *drec_data = (struct dns_record_line*)(dpkt->data+(query_states[id].namelen)+sizeof(struct dns_query_line)+2);
-    drec_data->type = htons(28); /* AAAA */
-    drec_data->class = htons(1); /* IN */
-
-    /* FIXME: read the TTL from block:
-     * GNUNET_TIME_absolute_get_remaining(rec->expiration_time)
-     *
-     * But how to get the seconds out of this?
-     */
-    drec_data->ttl = htonl(3600);
-    drec_data->data_len = htons(16);
+receive_dht (void *cls,
+             struct GNUNET_TIME_Absolute exp __attribute__ ((unused)),
+             const GNUNET_HashCode * key __attribute__ ((unused)),
+             const struct GNUNET_PeerIdentity *const *get_path
+             __attribute__ ((unused)),
+             const struct GNUNET_PeerIdentity *const *put_path
+             __attribute__ ((unused)), enum GNUNET_BLOCK_Type type, size_t size,
+             const void *data)
+{
+
+  unsigned short id = ((struct receive_dht_cls *) cls)->id;
+  struct GNUNET_DHT_GetHandle *handle =
+      ((struct receive_dht_cls *) cls)->handle;
+  GNUNET_free (cls);
+
+  GNUNET_assert (type == GNUNET_BLOCK_TYPE_DNS);
+
+  /* If no query with this id is pending, ignore the block */
+  if (query_states[id].valid != GNUNET_YES)
+    return;
+  query_states[id].valid = GNUNET_NO;
+
+  const struct GNUNET_DNS_Record *rec = data;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got block of size %d, peer: %08x, desc: %08x\n",
+              size,
+              *((unsigned int *) &rec->peer),
+              *((unsigned int *) &rec->service_descriptor));
+
+  size_t len = sizeof (struct answer_packet) - 1 + sizeof (struct dns_static) + query_states[id].namelen + sizeof (struct dns_query_line) + 2   /* To hold the pointer (as defined in RFC1035) to the name */
+      + sizeof (struct dns_record_line) - 1 + 16;       /* To hold the IPv6-Address */
 
-    /* Calculate at which offset in the packet the IPv6-Address belongs, it is
-     * filled in by the daemon-vpn */
-    answer->pkt.addroffset = htons((unsigned short)((unsigned long)(&drec_data->data)-(unsigned long)(&answer->pkt)));
+  struct answer_packet_list *answer =
+      GNUNET_malloc (len + 2 * sizeof (struct answer_packet_list *));
+  memset (answer, 0, len + 2 * sizeof (struct answer_packet_list *));
+
+  answer->pkt.hdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
+  answer->pkt.hdr.size = htons (len);
+  answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_SERVICE;
+
+  GNUNET_CRYPTO_hash (&rec->peer,
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &answer->pkt.service_descr.peer);
+
+  memcpy (&answer->pkt.service_descr.service_descriptor,
+          &rec->service_descriptor, sizeof (GNUNET_HashCode));
+  memcpy (&answer->pkt.service_descr.service_type,
+          &rec->service_type, sizeof (answer->pkt.service_descr.service_type));
+  memcpy (&answer->pkt.service_descr.ports, &rec->ports,
+          sizeof (answer->pkt.service_descr.ports));
+
+  answer->pkt.from = query_states[id].remote_ip;
+
+  answer->pkt.to = query_states[id].local_ip;
+  answer->pkt.dst_port = query_states[id].local_port;
+
+  struct dns_pkt *dpkt = (struct dns_pkt *) answer->pkt.data;
+
+  dpkt->s.id = id;
+  dpkt->s.aa = 1;
+  dpkt->s.qr = 1;
+  dpkt->s.ra = 1;
+  dpkt->s.qdcount = htons (1);
+  dpkt->s.ancount = htons (1);
 
-    GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, answer);
+  memcpy (dpkt->data, query_states[id].name, query_states[id].namelen);
+  GNUNET_free (query_states[id].name);
 
-    GNUNET_SERVER_notify_transmit_ready(query_states[id].client,
-                                        len,
-                                        GNUNET_TIME_UNIT_FOREVER_REL,
-                                        &send_answer,
-                                        query_states[id].client);
+  struct dns_query_line *dque =
+      (struct dns_query_line *) (dpkt->data + (query_states[id].namelen));
+  dque->type = htons (28);      /* AAAA */
+  dque->class = htons (1);      /* IN */
+
+  char *anname =
+      (char *) (dpkt->data + (query_states[id].namelen) +
+                sizeof (struct dns_query_line));
+  memcpy (anname, "\xc0\x0c", 2);
+
+  struct dns_record_line *drec_data =
+      (struct dns_record_line *) (dpkt->data + (query_states[id].namelen) +
+                                  sizeof (struct dns_query_line) + 2);
+  drec_data->type = htons (28); /* AAAA */
+  drec_data->class = htons (1); /* IN */
+
+  /* FIXME: read the TTL from block:
+   * GNUNET_TIME_absolute_get_remaining(rec->expiration_time)
+   *
+   * But how to get the seconds out of this?
+   */
+  drec_data->ttl = htonl (3600);
+  drec_data->data_len = htons (16);
+
+  /* Calculate at which offset in the packet the IPv6-Address belongs, it is
+   * filled in by the daemon-vpn */
+  answer->pkt.addroffset =
+      htons ((unsigned short) ((unsigned long) (&drec_data->data) -
+                               (unsigned long) (&answer->pkt)));
+
+  GNUNET_CONTAINER_DLL_insert_after (head, tail, tail, answer);
+
+  GNUNET_SERVER_notify_transmit_ready (query_states[id].client,
+                                       len,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &send_answer, query_states[id].client);
 
-    GNUNET_DHT_get_stop(handle);
+  GNUNET_DHT_get_stop (handle);
 }
 
 /**
  * This receives a GNUNET_MESSAGE_TYPE_REHIJACK and rehijacks the DNS
  */
 static void
-rehijack(void *cls __attribute__((unused)),
-         struct GNUNET_SERVER_Client *client,
-         const struct GNUNET_MessageHeader *message __attribute__((unused))) {
-    unhijack(dnsoutport);
-    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
+rehijack (void *cls __attribute__ ((unused)),
+          struct GNUNET_SERVER_Client *client,
+          const struct GNUNET_MessageHeader *message __attribute__ ((unused)))
+{
+  unhijack (dnsoutport);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
 
-    GNUNET_SERVER_receive_done(client, GNUNET_OK);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 /**
  * This receives the dns-payload from the daemon-vpn and sends it on over the udp-socket
  */
 static void
-receive_query(void *cls __attribute__((unused)),
-              struct GNUNET_SERVER_Client *client,
-              const struct GNUNET_MessageHeader *message) {
-    struct query_packet* pkt = (struct query_packet*)message;
-    struct dns_pkt* dns = (struct dns_pkt*)pkt->data;
-    struct dns_pkt_parsed* pdns = parse_dns_packet(dns);
-
-    query_states[dns->s.id].valid = GNUNET_YES;
-    query_states[dns->s.id].client = client;
-    query_states[dns->s.id].local_ip = pkt->orig_from;
-    query_states[dns->s.id].local_port = pkt->src_port;
-    query_states[dns->s.id].remote_ip = pkt->orig_to;
-    query_states[dns->s.id].namelen = strlen((char*)dns->data) + 1;
-    if (query_states[dns->s.id].name != NULL)
-      GNUNET_free(query_states[dns->s.id].name);
-    query_states[dns->s.id].name = GNUNET_malloc(query_states[dns->s.id].namelen);
-    memcpy(query_states[dns->s.id].name, dns->data, query_states[dns->s.id].namelen);
-
-    /* The query is for a .gnunet-address */
-    if (pdns->queries[0]->namelen > 9 &&
-        0 == strncmp(pdns->queries[0]->name+(pdns->queries[0]->namelen - 9), ".gnunet.", 9))
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Query for .gnunet!\n");
-        GNUNET_HashCode key;
-        GNUNET_CRYPTO_hash(pdns->queries[0]->name, pdns->queries[0]->namelen, &key);
-
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                   "Getting with key %08x, len is %d\n",
-                   *((unsigned int*)&key),
-                   pdns->queries[0]->namelen);
-
-        struct receive_dht_cls* cls = GNUNET_malloc(sizeof(struct receive_dht_cls));
-        cls->id = dns->s.id;
-
-        cls->handle = GNUNET_DHT_get_start(dht,
-                                           GNUNET_TIME_UNIT_MINUTES,
-                                           GNUNET_BLOCK_TYPE_DNS,
-                                           &key,
-                                           DEFAULT_GET_REPLICATION,
-                                           GNUNET_DHT_RO_NONE,
-                                           NULL,
-                                           0,
-                                           NULL,
-                                           0,
-                                           receive_dht,
-                                           cls);
-
-        goto outfree;
-      }
+receive_query (void *cls __attribute__ ((unused)),
+               struct GNUNET_SERVER_Client *client,
+               const struct GNUNET_MessageHeader *message)
+{
+  struct query_packet *pkt = (struct query_packet *) message;
+  struct dns_pkt *dns = (struct dns_pkt *) pkt->data;
+  struct dns_pkt_parsed *pdns = parse_dns_packet (dns);
 
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Query for '%s'; namelen=%d\n", pdns->queries[0]->name, pdns->queries[0]->namelen);
+  query_states[dns->s.id].valid = GNUNET_YES;
+  query_states[dns->s.id].client = client;
+  query_states[dns->s.id].local_ip = pkt->orig_from;
+  query_states[dns->s.id].local_port = pkt->src_port;
+  query_states[dns->s.id].remote_ip = pkt->orig_to;
+  query_states[dns->s.id].namelen = strlen ((char *) dns->data) + 1;
+  if (query_states[dns->s.id].name != NULL)
+    GNUNET_free (query_states[dns->s.id].name);
+  query_states[dns->s.id].name =
+      GNUNET_malloc (query_states[dns->s.id].namelen);
+  memcpy (query_states[dns->s.id].name, dns->data,
+          query_states[dns->s.id].namelen);
 
-    /* This is a PTR-Query. Check if it is for "our" network */
-    if (htons(pdns->queries[0]->qtype) == 12 &&
-        74 == pdns->queries[0]->namelen)
-      {
-        char* ipv6addr;
-        char ipv6[16];
-        char ipv6rev[74] = "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.ip6.arpa.";
-        unsigned int i;
-        unsigned long long ipv6prefix;
-        unsigned int comparelen;
-
-        GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "vpn", "IPV6ADDR", &ipv6addr));
-        inet_pton (AF_INET6, ipv6addr, ipv6);
-        GNUNET_free(ipv6addr);
-
-        GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "vpn", "IPV6PREFIX", &ipv6prefix));
-        GNUNET_assert(ipv6prefix < 127);
-        ipv6prefix = (ipv6prefix + 7)/8;
-
-        for (i = ipv6prefix; i < 16; i++)
-          ipv6[i] = 0;
-
-        for (i = 0; i < 16; i++)
-          {
-            unsigned char c1 = ipv6[i] >> 4;
-            unsigned char c2 = ipv6[i] & 0xf;
-
-            if (c1 <= 9)
-              ipv6rev[62-(4*i)] = c1 + '0';
-            else
-              ipv6rev[62-(4*i)] = c1 + 87; /* 87 is the difference between 'a' and 10 */
-
-            if (c2 <= 9)
-              ipv6rev[62-((4*i)+2)] = c2 + '0';
-            else
-              ipv6rev[62-((4*i)+2)] = c2 + 87;
-          }
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "My network is %s'.\n", ipv6rev);
-        comparelen = 10 + 4*ipv6prefix;
-        if(0 == strncmp(pdns->queries[0]->name+(pdns->queries[0]->namelen - comparelen),
-                        ipv6rev + (74 - comparelen),
-                        comparelen))
-          {
-            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Reverse-Query for .gnunet!\n");
-
-            GNUNET_SCHEDULER_add_now(send_rev_query, pdns);
-
-            goto out;
-          }
-      }
+  /* The query is for a .gnunet-address */
+  if (pdns->queries[0]->namelen > 9 &&
+      0 == strncmp (pdns->queries[0]->name + (pdns->queries[0]->namelen - 9),
+                    ".gnunet.", 9))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Query for .gnunet!\n");
+    GNUNET_HashCode key;
 
-    char* virt_dns;
-    unsigned int virt_dns_bytes;
-    if (GNUNET_SYSERR ==
-        GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "VIRTDNS",
-                                               &virt_dns))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "No entry 'VIRTDNS' in configuration!\n");
-        exit (1);
-      }
+    GNUNET_CRYPTO_hash (pdns->queries[0]->name, pdns->queries[0]->namelen,
+                        &key);
 
-    if (1 != inet_pton (AF_INET, virt_dns, &virt_dns_bytes))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Error parsing 'VIRTDNS': %s; %m!\n", virt_dns);
-        exit(1);
-      }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Getting with key %08x, len is %d\n",
+                *((unsigned int *) &key), pdns->queries[0]->namelen);
 
-    GNUNET_free(virt_dns);
+    struct receive_dht_cls *cls =
+        GNUNET_malloc (sizeof (struct receive_dht_cls));
+    cls->id = dns->s.id;
 
-    if (virt_dns_bytes == pkt->orig_to)
-      {
-        /* This is a packet that was sent directly to the virtual dns-server
-         *
-         * This means we have to send this query over gnunet
-         */
+    cls->handle = GNUNET_DHT_get_start (dht,
+                                        GNUNET_TIME_UNIT_MINUTES,
+                                        GNUNET_BLOCK_TYPE_DNS,
+                                        &key,
+                                        DEFAULT_GET_REPLICATION,
+                                        GNUNET_DHT_RO_NONE,
+                                        NULL, 0, NULL, 0, receive_dht, cls);
 
-        size_t size = sizeof(struct GNUNET_MESH_Tunnel*) + sizeof(struct GNUNET_MessageHeader) + (ntohs(message->size) - sizeof(struct query_packet) + 1);
-        struct tunnel_cls *cls_ =  GNUNET_malloc(size);
-        cls_->hdr.size = size - sizeof(struct GNUNET_MESH_Tunnel*);
+    goto outfree;
+  }
 
-        cls_->hdr.type = ntohs(GNUNET_MESSAGE_TYPE_VPN_REMOTE_QUERY_DNS);
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "size: %d\n", size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Query for '%s'; namelen=%d\n",
+              pdns->queries[0]->name, pdns->queries[0]->namelen);
 
-        memcpy(&cls_->dns, dns, cls_->hdr.size - sizeof(struct GNUNET_MessageHeader));
-        GNUNET_SCHEDULER_add_now(send_mesh_query, cls_);
+  /* This is a PTR-Query. Check if it is for "our" network */
+  if (htons (pdns->queries[0]->qtype) == 12 && 74 == pdns->queries[0]->namelen)
+  {
+    char *ipv6addr;
+    char ipv6[16];
+    char ipv6rev[74] =
+        "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.ip6.arpa.";
+    unsigned int i;
+    unsigned long long ipv6prefix;
+    unsigned int comparelen;
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_string (cfg, "vpn",
+                                                          "IPV6ADDR",
+                                                          &ipv6addr));
+    inet_pton (AF_INET6, ipv6addr, ipv6);
+    GNUNET_free (ipv6addr);
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_number (cfg, "vpn",
+                                                          "IPV6PREFIX",
+                                                          &ipv6prefix));
+    GNUNET_assert (ipv6prefix < 127);
+    ipv6prefix = (ipv6prefix + 7) / 8;
+
+    for (i = ipv6prefix; i < 16; i++)
+      ipv6[i] = 0;
+
+    for (i = 0; i < 16; i++)
+    {
+      unsigned char c1 = ipv6[i] >> 4;
+      unsigned char c2 = ipv6[i] & 0xf;
+
+      if (c1 <= 9)
+        ipv6rev[62 - (4 * i)] = c1 + '0';
+      else
+        ipv6rev[62 - (4 * i)] = c1 + 87;        /* 87 is the difference between 'a' and 10 */
+
+      if (c2 <= 9)
+        ipv6rev[62 - ((4 * i) + 2)] = c2 + '0';
+      else
+        ipv6rev[62 - ((4 * i) + 2)] = c2 + 87;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "My network is %s'.\n", ipv6rev);
+    comparelen = 10 + 4 * ipv6prefix;
+    if (0 ==
+        strncmp (pdns->queries[0]->name +
+                 (pdns->queries[0]->namelen - comparelen),
+                 ipv6rev + (74 - comparelen), comparelen))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reverse-Query for .gnunet!\n");
 
-        goto outfree;
-      }
+      GNUNET_SCHEDULER_add_now (send_rev_query, pdns);
 
+      goto out;
+    }
+  }
 
-    /* The query should be sent to the network */
+  char *virt_dns;
+  unsigned int virt_dns_bytes;
 
-    struct sockaddr_in dest;
-    memset(&dest, 0, sizeof dest);
-    dest.sin_port = htons(53);
-    dest.sin_addr.s_addr = pkt->orig_to;
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_string (cfg, "vpn", "VIRTDNS", &virt_dns))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No entry 'VIRTDNS' in configuration!\n");
+    exit (1);
+  }
 
-    GNUNET_NETWORK_socket_sendto(dnsout,
-                                 dns,
-                                 ntohs(pkt->hdr.size) - sizeof(struct query_packet) + 1,
-                                 (struct sockaddr*) &dest,
-                                 sizeof dest);
+  if (1 != inet_pton (AF_INET, virt_dns, &virt_dns_bytes))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Error parsing 'VIRTDNS': %s; %m!\n", virt_dns);
+    exit (1);
+  }
+
+  GNUNET_free (virt_dns);
+
+  if (virt_dns_bytes == pkt->orig_to)
+  {
+    /* This is a packet that was sent directly to the virtual dns-server
+     *
+     * This means we have to send this query over gnunet
+     */
+
+    size_t size =
+        sizeof (struct GNUNET_MESH_Tunnel *) +
+        sizeof (struct GNUNET_MessageHeader) + (ntohs (message->size) -
+                                                sizeof (struct query_packet) +
+                                                1);
+    struct tunnel_cls *cls_ = GNUNET_malloc (size);
+
+    cls_->hdr.size = size - sizeof (struct GNUNET_MESH_Tunnel *);
+
+    cls_->hdr.type = ntohs (GNUNET_MESSAGE_TYPE_VPN_REMOTE_QUERY_DNS);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "size: %d\n", size);
+
+    memcpy (&cls_->dns, dns,
+            cls_->hdr.size - sizeof (struct GNUNET_MessageHeader));
+    GNUNET_SCHEDULER_add_now (send_mesh_query, cls_);
+
+    goto outfree;
+  }
+
+
+  /* The query should be sent to the network */
+
+  struct sockaddr_in dest;
+
+  memset (&dest, 0, sizeof dest);
+  dest.sin_port = htons (53);
+  dest.sin_addr.s_addr = pkt->orig_to;
+
+  GNUNET_NETWORK_socket_sendto (dnsout,
+                                dns,
+                                ntohs (pkt->hdr.size) -
+                                sizeof (struct query_packet) + 1,
+                                (struct sockaddr *) &dest, sizeof dest);
 
 outfree:
-    free_parsed_dns_packet(pdns);
-    pdns = NULL;
+  free_parsed_dns_packet (pdns);
+  pdns = NULL;
 out:
-    GNUNET_SERVER_receive_done(client, GNUNET_OK);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 static void read_response (void *cls,
@@ -900,14 +955,14 @@ open_port ()
                                         sizeof (struct sockaddr_in));
 
   if (err != GNUNET_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Could not bind a port: %m\n");
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not bind a port: %m\n");
+    return GNUNET_SYSERR;
+  }
 
   /* Read the port we bound to */
   socklen_t addrlen = sizeof (struct sockaddr_in);
+
   err = getsockname (GNUNET_NETWORK_get_fd (dnsout),
                      (struct sockaddr *) &addr, &addrlen);
 
@@ -941,12 +996,12 @@ read_response (void *cls
 
 #ifndef MINGW
   if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
-    {
-      unhijack (dnsoutport);
-      if (GNUNET_YES == open_port ())
-        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
-      return;
-    }
+  {
+    unhijack (dnsoutport);
+    if (GNUNET_YES == open_port ())
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
+    return;
+  }
 #else
   /* port the code above? */
   len = 65536;
@@ -961,83 +1016,90 @@ read_response (void *cls
                                         (struct sockaddr *) &addr, &addrlen);
 
     if (r < 0)
-      {
-        unhijack (dnsoutport);
-        if (GNUNET_YES == open_port ())
-          GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
-        return;
-      }
+    {
+      unhijack (dnsoutport);
+      if (GNUNET_YES == open_port ())
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
+      return;
+    }
 
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Answer to query %d\n", ntohs(dns->s.id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Answer to query %d\n",
+                ntohs (dns->s.id));
 
     if (query_states[dns->s.id].valid == GNUNET_YES)
+    {
+      if (query_states[dns->s.id].tunnel != NULL)
       {
-        if (query_states[dns->s.id].tunnel != NULL)
-          {
-            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Answer to query %d for a remote peer!\n", ntohs(dns->s.id));
-            /* This response should go through a tunnel */
-            uint32_t *c = GNUNET_malloc (4 + sizeof(struct GNUNET_MESH_Tunnel*) + r);
-            *c = r;
-            struct GNUNET_MESH_Tunnel** t = (struct GNUNET_MESH_Tunnel**)(c + 1);
-            *t = query_states[dns->s.id].tunnel;
-            memcpy (t + 1, dns, r);
-            if (NULL ==
-                GNUNET_MESH_tunnel_get_data (query_states[dns->s.id].tunnel))
-              {
-                struct GNUNET_MESH_TransmitHandle *th =
-                  GNUNET_MESH_notify_transmit_ready (query_states[dns->s.id].tunnel,
-                                                     GNUNET_YES,
-                                                     32,
-                                                     GNUNET_TIME_UNIT_MINUTES,
-                                                     NULL,
-                                                     r +
-                                                     sizeof (struct
-                                                             GNUNET_MessageHeader),
-                                                     mesh_send_response, c);
-                GNUNET_MESH_tunnel_set_data (query_states[dns->s.id].tunnel,
-                                             th);
-              }
-            else
-              {
-                struct tunnel_notify_queue* head = GNUNET_MESH_tunnel_get_head(query_states[dns->s.id].tunnel);
-                struct tunnel_notify_queue* tail = GNUNET_MESH_tunnel_get_tail(query_states[dns->s.id].tunnel);
-
-                struct tunnel_notify_queue* element = GNUNET_malloc(sizeof(struct tunnel_notify_queue));
-                element->cls = c;
-                element->len = r+sizeof(struct GNUNET_MessageHeader);
-                element->cb = mesh_send_response;
-
-                GNUNET_CONTAINER_DLL_insert_tail(head, tail, element);
-                GNUNET_MESH_tunnel_set_head(query_states[dns->s.id].tunnel, head);
-                GNUNET_MESH_tunnel_set_tail(query_states[dns->s.id].tunnel, tail);
-              }
-          }
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Answer to query %d for a remote peer!\n",
+                    ntohs (dns->s.id));
+        /* This response should go through a tunnel */
+        uint32_t *c =
+            GNUNET_malloc (4 + sizeof (struct GNUNET_MESH_Tunnel *) + r);
+        *c = r;
+        struct GNUNET_MESH_Tunnel **t = (struct GNUNET_MESH_Tunnel **) (c + 1);
+
+        *t = query_states[dns->s.id].tunnel;
+        memcpy (t + 1, dns, r);
+        if (NULL ==
+            GNUNET_MESH_tunnel_get_data (query_states[dns->s.id].tunnel))
+        {
+          struct GNUNET_MESH_TransmitHandle *th =
+              GNUNET_MESH_notify_transmit_ready (query_states[dns->s.id].tunnel,
+                                                 GNUNET_YES,
+                                                 32,
+                                                 GNUNET_TIME_UNIT_MINUTES,
+                                                 NULL,
+                                                 r +
+                                                 sizeof (struct
+                                                         GNUNET_MessageHeader),
+                                                 mesh_send_response, c);
+
+          GNUNET_MESH_tunnel_set_data (query_states[dns->s.id].tunnel, th);
+        }
         else
-          {
-            query_states[dns->s.id].valid = GNUNET_NO;
-
-            size_t len = sizeof (struct answer_packet) + r - 1; /* 1 for the unsigned char data[1]; */
-            struct answer_packet_list *answer =
-              GNUNET_malloc (len + 2 * sizeof (struct answer_packet_list *));
-            answer->pkt.hdr.type =
-              htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
-            answer->pkt.hdr.size = htons (len);
-            answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_IP;
-            answer->pkt.from = addr.sin_addr.s_addr;
-            answer->pkt.to = query_states[dns->s.id].local_ip;
-            answer->pkt.dst_port = query_states[dns->s.id].local_port;
-            memcpy (answer->pkt.data, buf, r);
-
-            GNUNET_CONTAINER_DLL_insert_after (head, tail, tail, answer);
-
-            GNUNET_SERVER_notify_transmit_ready (query_states
-                                                 [dns->s.id].client, len,
-                                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 &send_answer,
-                                                 query_states[dns->s.
-                                                              id].client);
-          }
+        {
+          struct tunnel_notify_queue *head =
+              GNUNET_MESH_tunnel_get_head (query_states[dns->s.id].tunnel);
+          struct tunnel_notify_queue *tail =
+              GNUNET_MESH_tunnel_get_tail (query_states[dns->s.id].tunnel);
+
+          struct tunnel_notify_queue *element =
+              GNUNET_malloc (sizeof (struct tunnel_notify_queue));
+          element->cls = c;
+          element->len = r + sizeof (struct GNUNET_MessageHeader);
+          element->cb = mesh_send_response;
+
+          GNUNET_CONTAINER_DLL_insert_tail (head, tail, element);
+          GNUNET_MESH_tunnel_set_head (query_states[dns->s.id].tunnel, head);
+          GNUNET_MESH_tunnel_set_tail (query_states[dns->s.id].tunnel, tail);
+        }
+      }
+      else
+      {
+        query_states[dns->s.id].valid = GNUNET_NO;
+
+        size_t len = sizeof (struct answer_packet) + r - 1;     /* 1 for the unsigned char data[1]; */
+        struct answer_packet_list *answer =
+            GNUNET_malloc (len + 2 * sizeof (struct answer_packet_list *));
+        answer->pkt.hdr.type =
+            htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS);
+        answer->pkt.hdr.size = htons (len);
+        answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_IP;
+        answer->pkt.from = addr.sin_addr.s_addr;
+        answer->pkt.to = query_states[dns->s.id].local_ip;
+        answer->pkt.dst_port = query_states[dns->s.id].local_port;
+        memcpy (answer->pkt.data, buf, r);
+
+        GNUNET_CONTAINER_DLL_insert_after (head, tail, tail, answer);
+
+        GNUNET_SERVER_notify_transmit_ready (query_states
+                                             [dns->s.id].client, len,
+                                             GNUNET_TIME_UNIT_FOREVER_REL,
+                                             &send_answer,
+                                             query_states[dns->s.id].client);
       }
+    }
   }
   GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                  dnsout, &read_response, NULL);
@@ -1051,14 +1113,14 @@ read_response (void *cls
  * @param tc unused
  */
 static void
-cleanup_task (void *cls __attribute__((unused)),
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_task (void *cls __attribute__ ((unused)),
+              const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_assert(0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
+  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
 
-  unhijack(dnsoutport);
-  GNUNET_DHT_disconnect(dht);
-  GNUNET_MESH_disconnect(mesh_handle);
+  unhijack (dnsoutport);
+  GNUNET_DHT_disconnect (dht);
+  GNUNET_MESH_disconnect (mesh_handle);
 }
 
 /**
@@ -1073,70 +1135,78 @@ uint64_t
 get_port_from_redirects (const char *udp_redirects, const char *tcp_redirects)
 {
   uint64_t ret = 0;
-  char* cpy, *hostname, *redirect;
+  char *cpy, *hostname, *redirect;
   int local_port, count = 0;
 
   if (NULL != udp_redirects)
+  {
+    cpy = GNUNET_strdup (udp_redirects);
+    for (redirect = strtok (cpy, " "); redirect != NULL;
+         redirect = strtok (NULL, " "))
     {
-      cpy = GNUNET_strdup (udp_redirects);
-      for (redirect = strtok (cpy, " "); redirect != NULL; redirect = strtok (NULL, " "))
-        {
-          if (NULL == (hostname = strstr (redirect, ":")))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Warning: option %s is not formatted correctly!\n", redirect);
-              continue;
-            }
-          hostname[0] = '\0';
-          local_port = atoi (redirect);
-          if (!((local_port > 0) && (local_port < 65536)))
-            GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Warning: %s is not a correct port.", redirect);
-
-          ret |= (0xFFFF & htons(local_port));
-          ret <<= 16;
-          count ++;
-
-          if(count > 4)
-            {
-              ret = 0;
-              goto out;
-            }
-        }
-      GNUNET_free(cpy);
-      cpy = NULL;
+      if (NULL == (hostname = strstr (redirect, ":")))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: option %s is not formatted correctly!\n",
+                    redirect);
+        continue;
+      }
+      hostname[0] = '\0';
+      local_port = atoi (redirect);
+      if (!((local_port > 0) && (local_port < 65536)))
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: %s is not a correct port.", redirect);
+
+      ret |= (0xFFFF & htons (local_port));
+      ret <<= 16;
+      count++;
+
+      if (count > 4)
+      {
+        ret = 0;
+        goto out;
+      }
     }
+    GNUNET_free (cpy);
+    cpy = NULL;
+  }
 
   if (NULL != tcp_redirects)
+  {
+    cpy = GNUNET_strdup (tcp_redirects);
+    for (redirect = strtok (cpy, " "); redirect != NULL;
+         redirect = strtok (NULL, " "))
     {
-      cpy = GNUNET_strdup (tcp_redirects);
-      for (redirect = strtok (cpy, " "); redirect != NULL; redirect = strtok (NULL, " "))
-        {
-          if (NULL == (hostname = strstr (redirect, ":")))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Warning: option %s is not formatted correctly!\n", redirect);
-              continue;
-            }
-          hostname[0] = '\0';
-          local_port = atoi (redirect);
-          if (!((local_port > 0) && (local_port < 65536)))
-            GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Warning: %s is not a correct port.", redirect);
-
-          ret |= (0xFFFF & htons(local_port));
-          ret <<= 16;
-          count ++;
-
-          if(count > 4)
-            {
-              ret = 0;
-              goto out;
-            }
-        }
-      GNUNET_free(cpy);
-      cpy = NULL;
+      if (NULL == (hostname = strstr (redirect, ":")))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: option %s is not formatted correctly!\n",
+                    redirect);
+        continue;
+      }
+      hostname[0] = '\0';
+      local_port = atoi (redirect);
+      if (!((local_port > 0) && (local_port < 65536)))
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Warning: %s is not a correct port.", redirect);
+
+      ret |= (0xFFFF & htons (local_port));
+      ret <<= 16;
+      count++;
+
+      if (count > 4)
+      {
+        ret = 0;
+        goto out;
+      }
     }
+    GNUNET_free (cpy);
+    cpy = NULL;
+  }
 
 out:
   if (NULL != cpy)
-    GNUNET_free(cpy);
+    GNUNET_free (cpy);
   return ret;
 }
 
@@ -1146,10 +1216,10 @@ publish_name (const char *name, uint64_t ports, uint32_t service_type,
 {
   size_t size = sizeof (struct GNUNET_DNS_Record);
   struct GNUNET_DNS_Record data;
+
   memset (&data, 0, size);
 
-  data.purpose.size =
-    htonl (size - sizeof (struct GNUNET_CRYPTO_RsaSignature));
+  data.purpose.size = htonl (size - sizeof (struct GNUNET_CRYPTO_RsaSignature));
   data.purpose.purpose = GNUNET_SIGNATURE_PURPOSE_DNS_RECORD;
 
   GNUNET_CRYPTO_hash (name, strlen (name) + 1, &data.service_descriptor);
@@ -1162,15 +1232,16 @@ publish_name (const char *name, uint64_t ports, uint32_t service_type,
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &data.peer);
 
   data.expiration_time =
-    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 2));
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply
+                                        (GNUNET_TIME_UNIT_HOURS, 2));
 
   /* Sign the block */
   if (GNUNET_OK != GNUNET_CRYPTO_rsa_sign (my_private_key,
                                            &data.purpose, &data.signature))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not sign DNS_Record\n");
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not sign DNS_Record\n");
+    return;
+  }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Putting with key %08x, size = %d\n",
@@ -1194,15 +1265,16 @@ publish_name (const char *name, uint64_t ports, uint32_t service_type,
  * @param section the current section
  */
 void
-publish_iterate (void *cls __attribute__((unused)), const char *section)
+publish_iterate (void *cls __attribute__ ((unused)), const char *section)
 {
-  if ((strlen(section) < 8) || (0 != strcmp (".gnunet.", section + (strlen(section) - 8))))
+  if ((strlen (section) < 8) ||
+      (0 != strcmp (".gnunet.", section + (strlen (section) - 8))))
     return;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Parsing dns-name %s\n", section);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Parsing dns-name %s\n", section);
 
   char *udp_redirects, *tcp_redirects, *alternative_names, *alternative_name,
-    *keyfile;
+      *keyfile;
 
   GNUNET_CONFIGURATION_get_value_string (cfg, section,
                                          "UDP_REDIRECTS", &udp_redirects);
@@ -1212,15 +1284,15 @@ publish_iterate (void *cls __attribute__((unused)), const char *section)
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD",
                                                             "HOSTKEY",
                                                             &keyfile))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not read keyfile-value\n");
-      if (keyfile != NULL)
-        GNUNET_free (keyfile);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not read keyfile-value\n");
+    if (keyfile != NULL)
+      GNUNET_free (keyfile);
+    return;
+  }
 
   struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key =
-    GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+      GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   GNUNET_assert (my_private_key != NULL);
 
@@ -1243,17 +1315,17 @@ publish_iterate (void *cls __attribute__((unused)), const char *section)
                                          &alternative_names);
   for (alternative_name = strtok (alternative_names, " ");
        alternative_name != NULL; alternative_name = strtok (NULL, " "))
-    {
-      char *altname =
+  {
+    char *altname =
         alloca (strlen (alternative_name) + strlen (section) + 1 + 1);
-      strcpy (altname, alternative_name);
-      strcpy (altname + strlen (alternative_name) + 1, section);
-      altname[strlen (alternative_name)] = '.';
+    strcpy (altname, alternative_name);
+    strcpy (altname + strlen (alternative_name) + 1, section);
+    altname[strlen (alternative_name)] = '.';
 
-      publish_name (altname, ports, service_type, my_private_key);
-    }
+    publish_name (altname, ports, service_type, my_private_key);
+  }
 
-  GNUNET_free_non_null(alternative_names);
+  GNUNET_free_non_null (alternative_names);
   GNUNET_CRYPTO_rsa_key_free (my_private_key);
   GNUNET_free_non_null (udp_redirects);
   GNUNET_free_non_null (tcp_redirects);
@@ -1263,16 +1335,15 @@ publish_iterate (void *cls __attribute__((unused)), const char *section)
  * Publish a DNS-record in the DHT.
  */
 static void
-publish_names (void *cls __attribute__((unused)),
-               const struct GNUNET_SCHEDULER_TaskContext *tc) {
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      return;
+publish_names (void *cls __attribute__ ((unused)),
+               const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
 
-    GNUNET_CONFIGURATION_iterate_sections(cfg, publish_iterate, NULL);
+  GNUNET_CONFIGURATION_iterate_sections (cfg, publish_iterate, NULL);
 
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_HOURS,
-                                  publish_names,
-                                  NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_HOURS, publish_names, NULL);
 }
 
 /**
@@ -1299,35 +1370,31 @@ run (void *cls,
     {NULL, 0, 0}
   };
 
-  static GNUNET_MESH_ApplicationType *apptypes;
+  static GNUNET_MESH_ApplicationType apptypes[] = {
+    GNUNET_APPLICATION_TYPE_END,
+    GNUNET_APPLICATION_TYPE_END
+  };
+
 
   if (GNUNET_YES != open_port ())
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 
   if (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (cfg_, "dns", "PROVIDE_EXIT"))
-    apptypes = (GNUNET_MESH_ApplicationType[])
-    {
-    GNUNET_APPLICATION_TYPE_INTERNET_RESOLVER,
-    GNUNET_APPLICATION_TYPE_END};
-  else
-  apptypes = (GNUNET_MESH_ApplicationType[])
-  {
-  GNUNET_APPLICATION_TYPE_END};
-
-  mesh_handle =
-    GNUNET_MESH_connect (cfg_, NULL, NULL, mesh_handlers, apptypes);
+    apptypes[0] = GNUNET_APPLICATION_TYPE_INTERNET_RESOLVER;
+  mesh_handle = GNUNET_MESH_connect (cfg_, NULL, NULL, mesh_handlers, apptypes);
 
   cfg = cfg_;
 
   unsigned int i;
+
   for (i = 0; i < 65536; i++)
-    {
-      query_states[i].valid = GNUNET_NO;
-    }
+  {
+    query_states[i].valid = GNUNET_NO;
+  }
 
   dht = GNUNET_DHT_connect (cfg, 1024);
 
@@ -1349,9 +1416,8 @@ int
 main (int argc, char *const *argv)
 {
   return (GNUNET_OK ==
-          GNUNET_SERVICE_run (argc,
-                              argv,
-                              "dns",
-                              GNUNET_SERVICE_OPTION_NONE,
-                              &run, NULL)) ? 0 : 1;
+          GNUNET_SERVICE_run (argc,
+                              argv,
+                              "dns",
+                              GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 }
diff --git a/src/vpn/gnunet-vpn-checksum.c b/src/vpn/gnunet-vpn-checksum.c
index 81ec044dc..0e0e24cdc 100644
--- a/src/vpn/gnunet-vpn-checksum.c
+++ b/src/vpn/gnunet-vpn-checksum.c
@@ -26,26 +26,32 @@
 
 #include "gnunet-vpn-checksum.h"
 
-uint32_t calculate_checksum_update(uint32_t sum, uint16_t *hdr, short len) {
-    for(; len >= 2; len -= 2)
-      sum += *(hdr++);
-    if (len == 1)
-      sum += *((unsigned char*)hdr);
-    return sum;
+uint32_t
+calculate_checksum_update (uint32_t sum, uint16_t * hdr, short len)
+{
+  for (; len >= 2; len -= 2)
+    sum += *(hdr++);
+  if (len == 1)
+    sum += *((unsigned char *) hdr);
+  return sum;
 }
 
-uint16_t calculate_checksum_end(uint32_t sum) {
-    while (sum >> 16)
-      sum = (sum >> 16) + (sum & 0xFFFF);
+uint16_t
+calculate_checksum_end (uint32_t sum)
+{
+  while (sum >> 16)
+    sum = (sum >> 16) + (sum & 0xFFFF);
 
-    return ~sum;
+  return ~sum;
 }
 
 /**
  * Calculate the checksum of an IPv4-Header
  */
 uint16_t
-calculate_ip_checksum(uint16_t* hdr, short len) {
-    uint32_t sum = calculate_checksum_update(0, hdr, len);
-    return calculate_checksum_end(sum);
+calculate_ip_checksum (uint16_t * hdr, short len)
+{
+  uint32_t sum = calculate_checksum_update (0, hdr, len);
+
+  return calculate_checksum_end (sum);
 }
diff --git a/src/vpn/gnunet-vpn-checksum.h b/src/vpn/gnunet-vpn-checksum.h
index 0c0605650..82f4954ca 100644
--- a/src/vpn/gnunet-vpn-checksum.h
+++ b/src/vpn/gnunet-vpn-checksum.h
@@ -4,13 +4,13 @@
 
 #include <platform.h>
 
-uint32_t calculate_checksum_update(uint32_t sum, uint16_t *hdr, short len);
+uint32_t calculate_checksum_update (uint32_t sum, uint16_t * hdr, short len);
 
-uint16_t calculate_checksum_end(uint32_t sum);
+uint16_t calculate_checksum_end (uint32_t sum);
 
 /**
  * Calculate the checksum of an IPv4-Header
  */
-uint16_t calculate_ip_checksum(uint16_t* hdr, short len);
+uint16_t calculate_ip_checksum (uint16_t * hdr, short len);
 
 #endif /* end of include guard: GNUNET-VPN-CHECKSUM_H */
diff --git a/src/vpn/gnunet-vpn-packet.h b/src/vpn/gnunet-vpn-packet.h
index 91c6eb9c1..47fa69847 100644
--- a/src/vpn/gnunet-vpn-packet.h
+++ b/src/vpn/gnunet-vpn-packet.h
@@ -5,221 +5,246 @@
 #include "gnunet_common.h"
 
 // Headers
-struct pkt_tun {
-        unsigned flags:16 GNUNET_PACKED;
-        unsigned type:16 GNUNET_PACKED;
+struct pkt_tun
+{
+  unsigned flags:16 GNUNET_PACKED;
+  unsigned type:16 GNUNET_PACKED;
 };
 
-struct ip6_hdr {
-        unsigned tclass_h:4 GNUNET_PACKED;
-        unsigned version:4 GNUNET_PACKED;
-        unsigned tclass_l:4 GNUNET_PACKED;
-        unsigned flowlbl:20 GNUNET_PACKED;
-        unsigned paylgth:16 GNUNET_PACKED;
-        unsigned nxthdr:8 GNUNET_PACKED;
-        unsigned hoplmt:8 GNUNET_PACKED;
-        unsigned char sadr[16];
-        unsigned char dadr[16];
+struct ip6_hdr
+{
+  unsigned tclass_h:4 GNUNET_PACKED;
+  unsigned version:4 GNUNET_PACKED;
+  unsigned tclass_l:4 GNUNET_PACKED;
+  unsigned flowlbl:20 GNUNET_PACKED;
+  unsigned paylgth:16 GNUNET_PACKED;
+  unsigned nxthdr:8 GNUNET_PACKED;
+  unsigned hoplmt:8 GNUNET_PACKED;
+  unsigned char sadr[16];
+  unsigned char dadr[16];
 };
 
-struct ip_hdr {
-        unsigned hdr_lngth:4 GNUNET_PACKED;
-        unsigned version:4 GNUNET_PACKED;
+struct ip_hdr
+{
+  unsigned hdr_lngth:4 GNUNET_PACKED;
+  unsigned version:4 GNUNET_PACKED;
 
-        unsigned diff_serv:8 GNUNET_PACKED;
-        unsigned tot_lngth:16 GNUNET_PACKED;
+  unsigned diff_serv:8 GNUNET_PACKED;
+  unsigned tot_lngth:16 GNUNET_PACKED;
 
-        unsigned ident:16 GNUNET_PACKED;
-        unsigned flags:3 GNUNET_PACKED;
-        unsigned frag_off:13 GNUNET_PACKED;
+  unsigned ident:16 GNUNET_PACKED;
+  unsigned flags:3 GNUNET_PACKED;
+  unsigned frag_off:13 GNUNET_PACKED;
 
-        unsigned ttl:8 GNUNET_PACKED;
-        unsigned proto:8 GNUNET_PACKED;
-        unsigned chks:16 GNUNET_PACKED;
+  unsigned ttl:8 GNUNET_PACKED;
+  unsigned proto:8 GNUNET_PACKED;
+  unsigned chks:16 GNUNET_PACKED;
 
-        unsigned sadr:32 GNUNET_PACKED;
-        unsigned dadr:32 GNUNET_PACKED;
+  unsigned sadr:32 GNUNET_PACKED;
+  unsigned dadr:32 GNUNET_PACKED;
 };
 
 #define TCP_FLAG_SYN 2
 
-struct tcp_pkt {
-        unsigned spt:16 GNUNET_PACKED;
-        unsigned dpt:16 GNUNET_PACKED;
-        unsigned seq:32 GNUNET_PACKED;
-        unsigned ack:32 GNUNET_PACKED;
-        unsigned off:4 GNUNET_PACKED;
-        unsigned rsv:4 GNUNET_PACKED;
-        unsigned flg:8 GNUNET_PACKED;
-        unsigned wsz:16 GNUNET_PACKED;
-        unsigned crc:16 GNUNET_PACKED;
-        unsigned urg:16 GNUNET_PACKED;
+struct tcp_pkt
+{
+  unsigned spt:16 GNUNET_PACKED;
+  unsigned dpt:16 GNUNET_PACKED;
+  unsigned seq:32 GNUNET_PACKED;
+  unsigned ack:32 GNUNET_PACKED;
+  unsigned off:4 GNUNET_PACKED;
+  unsigned rsv:4 GNUNET_PACKED;
+  unsigned flg:8 GNUNET_PACKED;
+  unsigned wsz:16 GNUNET_PACKED;
+  unsigned crc:16 GNUNET_PACKED;
+  unsigned urg:16 GNUNET_PACKED;
 };
 
-struct udp_pkt {
-        unsigned spt:16 GNUNET_PACKED;
-        unsigned dpt:16 GNUNET_PACKED;
-        unsigned len:16 GNUNET_PACKED;
-        unsigned crc:16 GNUNET_PACKED;
+struct udp_pkt
+{
+  unsigned spt:16 GNUNET_PACKED;
+  unsigned dpt:16 GNUNET_PACKED;
+  unsigned len:16 GNUNET_PACKED;
+  unsigned crc:16 GNUNET_PACKED;
 };
 
-struct icmp_hdr {
-    unsigned type:8 GNUNET_PACKED;
-    unsigned code:8 GNUNET_PACKED;
-    unsigned chks:16 GNUNET_PACKED;
+struct icmp_hdr
+{
+  unsigned type:8 GNUNET_PACKED;
+  unsigned code:8 GNUNET_PACKED;
+  unsigned chks:16 GNUNET_PACKED;
 };
 
 // DNS-Stuff
-struct dns_static {
-        uint16_t id GNUNET_PACKED;
-
-        unsigned rd:1 GNUNET_PACKED; // recursion desired (client -> server)
-        unsigned tc:1 GNUNET_PACKED; // message is truncated
-        unsigned aa:1 GNUNET_PACKED; // authoritative answer
-        unsigned op:4 GNUNET_PACKED; // query:0, inverse q.:1, status: 2
-        unsigned qr:1 GNUNET_PACKED; // query:0, response:1
-
-        unsigned rcode:4 GNUNET_PACKED; // 0 No error
-                          // 1 Format error
-                          // 2 Server failure
-                          // 3 Name Error
-                          // 4 Not Implemented
-                          // 5 Refused
-        unsigned z:3 GNUNET_PACKED;  // reserved
-        unsigned ra:1 GNUNET_PACKED; // recursion available (server -> client)
-
-        uint16_t qdcount GNUNET_PACKED; // number of questions
-        uint16_t ancount GNUNET_PACKED; // number of answers
-        uint16_t nscount GNUNET_PACKED; // number of authority-records
-        uint16_t arcount GNUNET_PACKED; // number of additional records
-};
-
-struct dns_pkt {
-        struct dns_static s;
-        unsigned char data[1];
-};
-
-struct dns_pkt_parsed {
-        struct dns_static s;
-        struct dns_query** queries;
-        struct dns_record** answers;
-        struct dns_record** nameservers;
-        struct dns_record** additional;
-};
-
-struct dns_query_line {
-    unsigned short type;
-    unsigned short class;
-};
-
-struct dns_query {
-        char* name;
-        unsigned char namelen;
-        unsigned short qtype;
-        unsigned short qclass;
-};
-
-struct dns_record_line {
-    unsigned short type;
-    unsigned short class;
-    unsigned int ttl;
-    unsigned short data_len;
-    unsigned char data;
-};
-
-struct dns_record {
-        char* name;
-        unsigned char namelen;
-        unsigned short type;
-        unsigned short class;
-        unsigned int ttl;
-        unsigned short data_len;
-        unsigned char* data;
-};
-
-struct udp_dns {
-        struct udp_pkt udp_hdr;
-        struct dns_pkt data;
+struct dns_static
+{
+  uint16_t id GNUNET_PACKED;
+
+  unsigned rd:1 GNUNET_PACKED;  // recursion desired (client -> server)
+  unsigned tc:1 GNUNET_PACKED;  // message is truncated
+  unsigned aa:1 GNUNET_PACKED;  // authoritative answer
+  unsigned op:4 GNUNET_PACKED;  // query:0, inverse q.:1, status: 2
+  unsigned qr:1 GNUNET_PACKED;  // query:0, response:1
+
+  unsigned rcode:4 GNUNET_PACKED;       // 0 No error
+  // 1 Format error
+  // 2 Server failure
+  // 3 Name Error
+  // 4 Not Implemented
+  // 5 Refused
+  unsigned z:3 GNUNET_PACKED;   // reserved
+  unsigned ra:1 GNUNET_PACKED;  // recursion available (server -> client)
+
+  uint16_t qdcount GNUNET_PACKED;       // number of questions
+  uint16_t ancount GNUNET_PACKED;       // number of answers
+  uint16_t nscount GNUNET_PACKED;       // number of authority-records
+  uint16_t arcount GNUNET_PACKED;       // number of additional records
+};
+
+struct dns_pkt
+{
+  struct dns_static s;
+  unsigned char data[1];
+};
+
+struct dns_pkt_parsed
+{
+  struct dns_static s;
+  struct dns_query **queries;
+  struct dns_record **answers;
+  struct dns_record **nameservers;
+  struct dns_record **additional;
+};
+
+struct dns_query_line
+{
+  unsigned short type;
+  unsigned short class;
+};
+
+struct dns_query
+{
+  char *name;
+  unsigned char namelen;
+  unsigned short qtype;
+  unsigned short qclass;
+};
+
+struct dns_record_line
+{
+  unsigned short type;
+  unsigned short class;
+  unsigned int ttl;
+  unsigned short data_len;
+  unsigned char data;
+};
+
+struct dns_record
+{
+  char *name;
+  unsigned char namelen;
+  unsigned short type;
+  unsigned short class;
+  unsigned int ttl;
+  unsigned short data_len;
+  unsigned char *data;
+};
+
+struct udp_dns
+{
+  struct udp_pkt udp_hdr;
+  struct dns_pkt data;
 };
 
 // Complete Packets
-struct tun_pkt {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-};
-
-struct ip6_pkt {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip6_hdr ip6_hdr;
-        unsigned char data[1];
-};
-
-struct ip6_tcp {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip6_hdr ip6_hdr;
-        struct tcp_pkt tcp_hdr;
-        unsigned char data[1];
-};
-
-struct ip6_icmp {
-    struct GNUNET_MessageHeader shdr;
-    struct pkt_tun tun;
-    struct ip6_hdr ip6_hdr;
-    struct icmp_hdr icmp_hdr;
-};
-
-struct ip6_udp {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip6_hdr ip6_hdr;
-        struct udp_pkt udp_hdr;
-        unsigned char data[1];
-};
-
-struct ip6_udp_dns {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip6_hdr ip6_hdr;
-        struct udp_dns udp_dns;
-};
-
-struct ip_pkt {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip_hdr ip_hdr;
-        unsigned char data[1];
-};
-
-struct ip_udp {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip_hdr ip_hdr;
-        struct udp_pkt udp_hdr;
-        unsigned char data[1];
-};
-
-struct ip_udp_dns {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip_hdr ip_hdr;
-        struct udp_dns udp_dns;
-};
-
-struct ip_tcp {
-        struct GNUNET_MessageHeader shdr;
-        struct pkt_tun tun;
-        struct ip_hdr ip_hdr;
-        struct tcp_pkt tcp_hdr;
-        unsigned char data[1];
-};
-
-struct ip_icmp {
-    struct GNUNET_MessageHeader shdr;
-    struct pkt_tun tun;
-    struct ip_hdr ip_hdr;
-    struct icmp_hdr icmp_hdr;
+struct tun_pkt
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+};
+
+struct ip6_pkt
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip6_hdr ip6_hdr;
+  unsigned char data[1];
+};
+
+struct ip6_tcp
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip6_hdr ip6_hdr;
+  struct tcp_pkt tcp_hdr;
+  unsigned char data[1];
+};
+
+struct ip6_icmp
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip6_hdr ip6_hdr;
+  struct icmp_hdr icmp_hdr;
+};
+
+struct ip6_udp
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip6_hdr ip6_hdr;
+  struct udp_pkt udp_hdr;
+  unsigned char data[1];
+};
+
+struct ip6_udp_dns
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip6_hdr ip6_hdr;
+  struct udp_dns udp_dns;
+};
+
+struct ip_pkt
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip_hdr ip_hdr;
+  unsigned char data[1];
+};
+
+struct ip_udp
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip_hdr ip_hdr;
+  struct udp_pkt udp_hdr;
+  unsigned char data[1];
+};
+
+struct ip_udp_dns
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip_hdr ip_hdr;
+  struct udp_dns udp_dns;
+};
+
+struct ip_tcp
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip_hdr ip_hdr;
+  struct tcp_pkt tcp_hdr;
+  unsigned char data[1];
+};
+
+struct ip_icmp
+{
+  struct GNUNET_MessageHeader shdr;
+  struct pkt_tun tun;
+  struct ip_hdr ip_hdr;
+  struct icmp_hdr icmp_hdr;
 };
 
 #endif