From 502af2167f7c218366666ca4944bd7cc54b5b19a Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Mon, 15 Aug 2011 21:46:35 +0000 Subject: indentation --- src/vpn/gnunet-daemon-vpn.c | 1572 +++++++++++++++++++++++-------------------- 1 file changed, 827 insertions(+), 745 deletions(-) (limited to 'src/vpn/gnunet-daemon-vpn.c') 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 */ - -- cgit v1.2.3