From e7708b300114cd6612d2d643d3291324515a1e46 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Fri, 6 Jan 2012 01:02:51 +0000 Subject: [PATCH] -late night code cleanup --- src/exit/gnunet-daemon-exit.c | 577 +++++++++++++++++++--------------- 1 file changed, 332 insertions(+), 245 deletions(-) diff --git a/src/exit/gnunet-daemon-exit.c b/src/exit/gnunet-daemon-exit.c index 4986b9344..77830020e 100644 --- a/src/exit/gnunet-daemon-exit.c +++ b/src/exit/gnunet-daemon-exit.c @@ -463,9 +463,10 @@ get_redirect_state (int af, if (NULL == state) return NULL; /* Mark this connection as freshly used */ - GNUNET_CONTAINER_heap_update_cost (connections_heap, - state->heap_node, - GNUNET_TIME_absolute_get ().abs_value); + if (NULL == state_key) + GNUNET_CONTAINER_heap_update_cost (connections_heap, + state->heap_node, + GNUNET_TIME_absolute_get ().abs_value); return state; } @@ -479,7 +480,7 @@ get_redirect_state (int af, * @param dpt destination port * @return NULL if we are not aware of such a service */ -struct LocalService * +static struct LocalService * find_service (struct GNUNET_CONTAINER_MultiHashMap *service_map, const GNUNET_HashCode *desc, uint16_t dpt) @@ -875,73 +876,182 @@ message_token (void *cls GNUNET_UNUSED, void *client GNUNET_UNUSED, } +/** + * We need to create a (unique) fresh local address (IP+port). + * Fill one in. + * + * @param af desired address family + * @param proto desired protocol (IPPROTO_UDP or IPPROTO_TCP) + * @param local_address address to initialize + */ +static void +setup_fresh_address (int af, + int proto, + struct SocketAddress *local_address) +{ + switch (af) + { + case AF_INET: + { + const char *ipv4addr = exit_argv[4]; + const char *ipv4mask = exit_argv[5]; + uint32_t tmp; + uint32_t tmp2; + + GNUNET_assert (1 == inet_pton (AF_INET, ipv4addr, &tmp)); + GNUNET_assert (1 == inet_pton (AF_INET, ipv4mask, &tmp2)); + // FIXME + /* This should be a noop */ + tmp = tmp & tmp2; + tmp |= ntohl (*((uint32_t *) /*tunnel*/ 42)) & (~tmp2); + + // pkt4->source_address.s_addr = tmp; + } + break; + case AF_INET6: + { + const char *ipv6addr = exit_argv[2]; + /* Generate a new src-address + * This takes as much from the address of the tunnel as fits into + * the host-mask*/ + unsigned long long ipv6prefix_r = (ipv6prefix + 7) / 8; + inet_pton (AF_INET6, ipv6addr, &local_address->address.ipv6); + if (ipv6prefix_r < (16 - sizeof (void *))) + ipv6prefix_r = 16 - sizeof (void *); + + unsigned int offset = ipv6prefix_r - (16 - sizeof (void *)); + // memcpy ((((char *) &pkt6->source_address)) + ipv6prefix_r, ((char *) &tunnel) + offset, 16 - ipv6prefix_r); + offset++; + } + break; + default: + GNUNET_assert (0); + } +} + +/** + * FIXME: document! + */ +static void +setup_state_record (struct TunnelState *state) +{ + GNUNET_HashCode key; + struct TunnelState *s; + /* generate fresh, unique address */ + do + { + setup_fresh_address (state->serv->address.af, + state->serv->address.proto, + &state->ri.local_address); + } while (NULL != get_redirect_state (state->serv->address.af, + IPPROTO_UDP, + &state->ri.remote_address.address, + state->ri.remote_address.port, + &state->ri.local_address.address, + state->ri.local_address.port, + &key)); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (connections_map, + &key, state, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + state->heap_node = GNUNET_CONTAINER_heap_insert (connections_heap, + state, + GNUNET_TIME_absolute_get ().abs_value); + while (GNUNET_CONTAINER_heap_get_size (connections_heap) > max_connections) + { + s = GNUNET_CONTAINER_heap_remove_root (connections_heap); + GNUNET_assert (state != s); + s->heap_node = NULL; + GNUNET_MESH_tunnel_destroy (s->tunnel); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_remove (connections_map, + &s->state_key, + s)); + GNUNET_free (s); + } +} -void -prepare_ipv4_packet (size_t len, - uint16_t pktlen, void *payload, - uint8_t protocol, - void *ipaddress, void *tunnel, - struct RedirectInformation * - state, struct ip4_header *pkt4) +/** + * FIXME: document + */ +static void +prepare_ipv4_packet (const void *payload, size_t payload_length, + int protocol, + const struct SocketAddress *src_address, + const struct SocketAddress *dst_address, + struct ip4_header *pkt4) { - const char *ipv4addr = exit_argv[4]; - const char *ipv4mask = exit_argv[5]; - uint32_t tmp; - uint32_t tmp2; - - GNUNET_assert (1 == inet_pton (AF_INET, ipv4addr, &tmp)); - GNUNET_assert (1 == inet_pton (AF_INET, ipv4mask, &tmp2)); - memcpy (&pkt4[1], payload, pktlen); + size_t len; + + len = payload_length; + switch (protocol) + { + case IPPROTO_UDP: + len += sizeof (struct udp_packet); + break; + case IPPROTO_TCP: + /* tcp_header (with port/crc not set) must be part of payload! */ + if (len < sizeof (struct tcp_packet)) + { + GNUNET_break (0); + return; + } + break; + default: + GNUNET_break (0); + return; + } + if (len + sizeof (struct ip4_header) > UINT16_MAX) + { + GNUNET_break (0); + return; + } + pkt4->version = 4; pkt4->header_length = sizeof (struct ip4_header) / 4; pkt4->diff_serv = 0; - pkt4->total_length = htons (sizeof (struct ip4_header) + pktlen); - pkt4->identification = 0; // FIXME! + pkt4->total_length = htons ((uint16_t) (sizeof (struct ip4_header) + len)); + pkt4->identification = 0; // FIXME: pick at random! pkt4->flags = 0; pkt4->fragmentation_offset = 0; pkt4->ttl = 255; pkt4->protocol = protocol; - pkt4->checksum = 0; /* Will be calculated later */ - - memcpy (&pkt4->destination_address, ipaddress, sizeof (struct in_addr)); - - /* Generate a new src-address -- FIXME: not always, right!? */ - - /* This should be a noop */ - tmp = tmp & tmp2; - tmp |= ntohl (*((uint32_t *) tunnel)) & (~tmp2); - - pkt4->source_address.s_addr = tmp; + pkt4->checksum = 0; + pkt4->destination_address = dst_address->address.ipv4; + pkt4->source_address = src_address->address.ipv4; pkt4->checksum = GNUNET_CRYPTO_crc16_n (pkt4, sizeof (struct ip4_header)); - // FIXME: memcpy (&state->addr, &tmp, 4); - switch (protocol) { case IPPROTO_UDP: { struct udp_packet *pkt4_udp = (struct udp_packet *) &pkt4[1]; - // FIXME: state->pt = pkt4_udp->spt; + + pkt4_udp->spt = htons (src_address->port); + pkt4_udp->dpt = htons (dst_address->port); pkt4_udp->crc = 0; /* Optional for IPv4 */ + pkt4_udp->len = htons ((uint16_t) payload_length); + memcpy (&pkt4_udp[1], payload, payload_length); } break; case IPPROTO_TCP: { struct tcp_packet *pkt4_tcp = (struct tcp_packet *) &pkt4[1]; - // FIXME: state->pt = pkt4_tcp->spt; + memcpy (pkt4_tcp, payload, payload_length); + pkt4_tcp->spt = htons (src_address->port); + pkt4_tcp->dpt = htons (dst_address->port); pkt4_tcp->crc = 0; uint32_t sum = 0; sum = GNUNET_CRYPTO_crc16_step (sum, &pkt4->source_address, sizeof (struct in_addr) * 2); - tmp = (protocol << 16) | (0xffff & pktlen); - tmp = htonl (tmp); - sum = GNUNET_CRYPTO_crc16_step (sum, & tmp, 4); - sum = GNUNET_CRYPTO_crc16_step (sum, & pkt4_tcp, pktlen); + uint32_t tmp = htonl ((protocol << 16) | (0xffff & len)); + sum = GNUNET_CRYPTO_crc16_step (sum, & tmp, sizeof (uint32_t)); + sum = GNUNET_CRYPTO_crc16_step (sum, & pkt4_tcp, len); pkt4_tcp->crc = GNUNET_CRYPTO_crc16_finish (sum); } break; @@ -951,62 +1061,70 @@ prepare_ipv4_packet (size_t len, } -void -prepare_ipv6_packet (size_t len, uint16_t pktlen, void *payload, - uint16_t protocol, void *ipaddress, void *tunnel, - struct RedirectInformation *state, struct ip6_header *pkt6) +/** + * FIXME: document + */ +static void +prepare_ipv6_packet (const void *payload, size_t payload_length, + int protocol, + const struct SocketAddress *src_address, + const struct SocketAddress *dst_address, + struct ip6_header *pkt6) { - const char *ipv6addr = exit_argv[2]; - uint32_t tmp; - + size_t len; - memcpy (&pkt6[1], payload, pktlen); + len = payload_length; + switch (protocol) + { + case IPPROTO_UDP: + len += sizeof (struct udp_packet); + break; + case IPPROTO_TCP: + /* tcp_header (with port/crc not set) must be part of payload! */ + if (len < sizeof (struct tcp_packet)) + { + GNUNET_break (0); + return; + } + break; + default: + GNUNET_break (0); + return; + } + if (len > UINT16_MAX) + { + GNUNET_break (0); + return; + } pkt6->version = 6; pkt6->next_header = protocol; - pkt6->payload_length = htons (pktlen); - pkt6->hop_limit = 64; - - memcpy (&pkt6->destination_address, ipaddress, sizeof (struct in6_addr)); - - /* Generate a new src-address - * This takes as much from the address of the tunnel as fits into - * the host-mask*/ - - unsigned long long ipv6prefix_r = (ipv6prefix + 7) / 8; - - inet_pton (AF_INET6, ipv6addr, &pkt6->source_address); - - if (ipv6prefix_r < (16 - sizeof (void *))) - ipv6prefix_r = 16 - sizeof (void *); - - unsigned int offset = ipv6prefix_r - (16 - sizeof (void *)); - - memcpy ((((char *) &pkt6->source_address)) + ipv6prefix_r, - ((char *) &tunnel) + offset, 16 - ipv6prefix_r); - - /* copy the needed information into the state */ - // FIXME: memcpy (&state->addr, &pkt6->source_address, 16); + pkt6->payload_length = htons ((uint16_t) (len + sizeof (struct ip6_header))); + pkt6->hop_limit = 255; + pkt6->destination_address = dst_address->address.ipv6; + pkt6->source_address = src_address->address.ipv6; switch (protocol) { case IPPROTO_UDP: { struct udp_packet *pkt6_udp = (struct udp_packet *) &pkt6[1]; - - // FIXME: state->pt = pkt6_udp->spt; + + memcpy (&pkt6[1], payload, payload_length); pkt6_udp->crc = 0; + pkt6_udp->spt = htons (src_address->port); + pkt6_udp->dpt = htons (dst_address->port); + pkt6_udp->len = htons ((uint16_t) payload_length); + uint32_t sum = 0; - sum = - GNUNET_CRYPTO_crc16_step (sum, & pkt6->source_address, - 16 * 2); - tmp = (htons (pktlen) & 0xffff); - sum = GNUNET_CRYPTO_crc16_step (sum, & tmp, 4); - tmp = htons (pkt6->next_header & 0x00ff); - sum = GNUNET_CRYPTO_crc16_step (sum, & tmp, 4); - sum = - GNUNET_CRYPTO_crc16_step (sum, pkt6_udp, - ntohs (pkt6_udp->len)); + sum = GNUNET_CRYPTO_crc16_step (sum, + &pkt6->source_address, + sizeof (struct in6_addr) * 2); + uint32_t tmp = htons (len); + sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t)); + tmp = htonl (pkt6->next_header); + sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t)); + sum = GNUNET_CRYPTO_crc16_step (sum, pkt6_udp, len); pkt6_udp->crc = GNUNET_CRYPTO_crc16_finish (sum); } break; @@ -1014,20 +1132,19 @@ prepare_ipv6_packet (size_t len, uint16_t pktlen, void *payload, { struct tcp_packet *pkt6_tcp = (struct tcp_packet *) pkt6; - // FIXME: state->pt = pkt6_tcp->spt; + memcpy (pkt6_tcp, payload, payload_length); pkt6_tcp->crc = 0; + pkt6_tcp->spt = htons (src_address->port); + pkt6_tcp->dpt = htons (dst_address->port); + uint32_t sum = 0; - - sum = - GNUNET_CRYPTO_crc16_step (sum, & pkt6->source_address, 16 * 2); - tmp = htonl (pktlen); - sum = GNUNET_CRYPTO_crc16_step (sum, & tmp, 4); - tmp = htonl (((pkt6->next_header & 0x000000ff))); - sum = GNUNET_CRYPTO_crc16_step (sum, & tmp, 4); - - sum = - GNUNET_CRYPTO_crc16_step (sum, pkt6_tcp, - ntohs (pkt6->payload_length)); + sum = GNUNET_CRYPTO_crc16_step (sum, &pkt6->source_address, + sizeof (struct in6_addr) * 2); + uint32_t tmp = htonl (len); + sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t)); + tmp = htonl (pkt6->next_header); + sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t)); + sum = GNUNET_CRYPTO_crc16_step (sum, pkt6_tcp, len); pkt6_tcp->crc = GNUNET_CRYPTO_crc16_finish (sum); } break; @@ -1285,89 +1402,127 @@ receive_tcp_remote (void *cls GNUNET_UNUSED, struct GNUNET_MESH_Tunnel *tunnel, return GNUNET_YES; } -static int -receive_udp_remote (void *cls GNUNET_UNUSED, struct GNUNET_MESH_Tunnel *tunnel, - void **tunnel_ctx GNUNET_UNUSED, - const struct GNUNET_PeerIdentity *sender GNUNET_UNUSED, - const struct GNUNET_MessageHeader *message, - const struct GNUNET_ATS_Information *atsi GNUNET_UNUSED) -{ - // FIXME -#if 0 - GNUNET_HashCode *desc = (GNUNET_HashCode *) (message + 1); - struct udp_packet *pkt = (struct udp_packet *) (desc + 1); - struct remote_addr *s = (struct remote_addr *) desc; - char *buf; - size_t len; - - GNUNET_assert (ntohs (pkt->len) == - ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - - sizeof (GNUNET_HashCode)); - - /* Prepare the state. - * This will be saved in the hashmap, so that the receiving procedure knows - * through which tunnel this connection has to be routed. - */ - struct TunnelState *state = GNUNET_malloc (sizeof (struct TunnelState)); - state->tunnel = tunnel; - state->hashmap = udp_connections; - state->type = REMOTE; - memcpy (&state->remote, s, sizeof (struct remote_addr)); - len = - sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) + - sizeof (struct ip6_hdr) + ntohs (pkt->len); - buf = alloca (len); - memset (buf, 0, len); +/** + * FIXME: document! + */ +static void +send_udp_packet_via_tun (const struct SocketAddress *destination_address, + const struct SocketAddress *source_address, + const void *payload, size_t payload_length) +{ + size_t len; - switch (s->addrlen) + len = sizeof (struct GNUNET_MessageHeader) + sizeof (struct tun_header); + switch (source_address->af) { - case 4: - prepare_ipv4_packet (len, ntohs (pkt->len), pkt, IPPROTO_UDP, &s->addr, - tunnel, state, (struct ip4_header *) buf); + case AF_INET: + len += sizeof (struct ip4_header); break; - case 16: - prepare_ipv6_packet (len, ntohs (pkt->len), pkt, IPPROTO_UDP, &s->addr, - tunnel, state, (struct ip6_header *) buf); + case AF_INET6: + len += sizeof (struct ip6_header); break; default: - GNUNET_assert (0); - break; + GNUNET_break (0); + return; + } + len += sizeof (struct udp_packet); + len += payload_length; + if (len >= GNUNET_SERVER_MAX_MESSAGE_SIZE) + { + GNUNET_break (0); + return; + } + { + char buf[len]; + struct GNUNET_MessageHeader *hdr; + struct tun_header *tun; + + hdr= (struct GNUNET_MessageHeader *) buf; + hdr->type = htons (42); + hdr->size = htons (len); + tun = (struct tun_header*) &hdr[1]; + tun->flags = htons (0); + switch (source_address->af) + { + case AF_INET: + { + struct ip4_header * ipv4 = (struct ip4_header*) &tun[1]; + + tun->proto = htons (ETH_P_IPV4); + prepare_ipv4_packet (payload, payload_length, IPPROTO_UDP, + source_address, + destination_address, + ipv4); + } + break; + case AF_INET6: + { + struct ip6_header * ipv6 = (struct ip6_header*) &tun[1]; + + tun->proto = htons (ETH_P_IPV6); + prepare_ipv6_packet (payload, payload_length, IPPROTO_UDP, + source_address, + destination_address, + ipv6); + } + break; + default: + GNUNET_assert (0); + break; + } + (void) GNUNET_HELPER_send (helper_handle, + (const struct GNUNET_MessageHeader*) buf, + GNUNET_YES, + NULL, NULL); } +} - hash_redirect_info (&state->hash, &state->redirect_info, s->addrlen); - (void) GNUNET_HELPER_send (helper_handle, - (const struct GNUNET_MessageHeader*) buf, - GNUNET_YES, - NULL, NULL); - 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); +/** + * FIXME: document! + */ +static int +receive_udp_remote (void *cls GNUNET_UNUSED, struct GNUNET_MESH_Tunnel *tunnel, + void **tunnel_ctx GNUNET_UNUSED, + const struct GNUNET_PeerIdentity *sender GNUNET_UNUSED, + const struct GNUNET_MessageHeader *message, + const struct GNUNET_ATS_Information *atsi GNUNET_UNUSED) +{ + struct TunnelState *state = *tunnel_ctx; + // FIXME: write proper request struct (!) + const GNUNET_HashCode *desc = (const GNUNET_HashCode *) &message[1]; + const struct udp_packet *pkt = (const struct udp_packet *) &desc[1]; + const struct SocketAddress *s = (const struct SocketAddress *) desc; + uint16_t pkt_len = ntohs (message->size); - state->heap_node = - GNUNET_CONTAINER_heap_insert (udp_connections_heap, state, - GNUNET_TIME_absolute_get ().abs_value); + if (pkt_len != ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - sizeof (GNUNET_HashCode)) + { + GNUNET_break_op (0); + return GNUNET_YES; + } + pkt_len -= (sizeof (struct GNUNET_MessageHeader) + sizeof (GNUNET_HashCode)); - if (GNUNET_CONTAINER_heap_get_size (udp_connections_heap) > - max_udp_connections) - GNUNET_SCHEDULER_add_now (collect_connections, udp_connections_heap); + if (NULL == state->heap_node) + { + /* first packet, setup record */ + state->ri.remote_address = *s; + setup_state_record (state); } - else - GNUNET_free (state); -#endif + + send_udp_packet_via_tun (&state->ri.remote_address, + &state->ri.local_address, + &pkt[1], pkt_len - sizeof (struct udp_packet)); return GNUNET_YES; } /** - * The messages are one GNUNET_HashCode for the service, followed by a struct udp_packet + * FIXME: document! */ static int receive_udp_service (void *cls GNUNET_UNUSED, struct GNUNET_MESH_Tunnel *tunnel, @@ -1376,16 +1531,12 @@ receive_udp_service (void *cls GNUNET_UNUSED, struct GNUNET_MESH_Tunnel *tunnel, const struct GNUNET_MessageHeader *message, const struct GNUNET_ATS_Information *atsi GNUNET_UNUSED) { - // FIXME -#if 0 + struct TunnelState *state = *tunnel_ctx; + // FIXME: write proper request struct (we don't need UDP except dpt either!) const GNUNET_HashCode *desc = (const GNUNET_HashCode *) &message[1]; const struct udp_packet *pkt = (const struct udp_packet *) &desc[1]; uint16_t pkt_len = ntohs (message->size); - struct LocalService *serv; - struct TunnelState *state; - struct tunnel_state *s; - char *buf; - size_t len; + /* check that we got at least a valid header */ if (pkt_len < sizeof (struct GNUNET_MessageHeader) + sizeof (GNUNET_HashCode) + sizeof (struct udp_packet)) @@ -1399,93 +1550,29 @@ receive_udp_service (void *cls GNUNET_UNUSED, struct GNUNET_MESH_Tunnel *tunnel, ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - sizeof (GNUNET_HashCode)); - if (NULL == (serv = find_service (udp_services, desc, ntohs (pkt->dpt)))) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - _("No service found for %s on port %d!\n"), - "UDP", - ntohs (pkt->dpt)); - return GNUNET_YES; - } - pkt->dpt = htons (serv->remote_port); - - /* At this point it would be possible to check against some kind of ACL. */ - - s = GNUNET_MESH_tunnel_get_data (tunnel); - - - /* Prepare the state. - * This will be saved in the hashmap, so that the receiving procedure knows - * through which tunnel this connection has to be routed. - */ - - state = GNUNET_malloc (sizeof (struct TunnelState)); - - state->tunnel = tunnel; - state->serv = serv; - state->type = SERVICE; - state->hashmap = udp_connections; - memcpy (&state->desc, desc, sizeof (GNUNET_HashCode)); - - len = - sizeof (struct GNUNET_MessageHeader) + sizeof (struct pkt_tun) + - sizeof (struct ip6_hdr) + ntohs (pkt->len); - buf = alloca (len); - - memset (buf, 0, len); - - switch (serv->version) + if (NULL == state->serv) { - case 4: - prepare_ipv4_packet (len, ntohs (pkt->len), pkt, IPPROTO_UDP, - &serv->v4.ip4address, tunnel, state, - (struct ip4_header *) buf); - break; - case 6: - prepare_ipv6_packet (len, ntohs (pkt->len), pkt, IPPROTO_UDP, - &serv->v6.ip6address, tunnel, state, - (struct ip6_header *) 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); - - 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); + /* setup fresh connection */ + GNUNET_assert (NULL == state->heap_node); + if (NULL == (state->serv = find_service (udp_services, desc, ntohs (pkt->dpt)))) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("No service found for %s on port %d!\n"), + "UDP", + ntohs (pkt->dpt)); + GNUNET_MESH_tunnel_destroy (state->tunnel); + return GNUNET_YES; + } + state->ri.remote_address = state->serv->address; + setup_state_record (state); } - else - GNUNET_free (state); - - (void) GNUNET_HELPER_send (helper_handle, - (const struct GNUNET_MessageHeader*) buf, - GNUNET_YES, - NULL, NULL); -#endif + send_udp_packet_via_tun (&state->ri.remote_address, + &state->ri.local_address, + &pkt[1], pkt_len - sizeof (struct udp_packet)); return GNUNET_YES; } - - - - - /** * Callback from GNUNET_MESH for new tunnels. * -- 2.25.1