gnunet-daemon-exit.c File Reference

tool to allow IP traffic exit from the GNUnet cadet to the Internet More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_applications.h"
#include "gnunet_dht_service.h"
#include "gnunet_cadet_service.h"
#include "gnunet_dnsparser_lib.h"
#include "gnunet_dnsstub_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"
#include "gnunet_tun_lib.h"
#include "gnunet_regex_service.h"
#include "exit.h"
#include "block_dns.h"

Include dependency graph for gnunet-daemon-exit.c:

Go to the source code of this file.

Data Structures
struct	SocketAddress
	Information about an address. More...
struct	LocalService
	This struct is saved into the services-hashmap to represent a service this peer is specifically offering an exit for (for a specific domain name). More...
struct	RedirectInformation
	Information we use to track a connection (the classical 6-tuple of IP-version, protocol, source-IP, destination-IP, source-port and destinatin-port. More...
struct	ChannelState
	This struct is saved into connections_map to allow finding the right channel given an IP packet from TUN. More...
struct	DnsResponseMessage
	Message with a DNS response. More...

Macros
#define	REGEX_MAX_PATH_LEN_IPV4   4
	Maximum path compression length for cadet regex announcing for IPv4 address based regex. More...
#define	REGEX_MAX_PATH_LEN_IPV6   8
	Maximum path compression length for cadet regex announcing for IPv6 address based regex. More...
#define	REGEX_REFRESH_FREQUENCY   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
	How frequently do we re-announce the regex for the exit? More...
#define	DHT_PUT_FREQUENCY   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
	How frequently do we re-announce the DNS exit in the DHT? More...
#define	DNS_ADVERTISEMENT_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 3)
	How long do we typically sign the DNS exit advertisement for? More...
#define	LOG(kind, ...)   GNUNET_log_from(kind, "exit", __VA_ARGS__);
	Generic logging shorthand. More...

Functions
static GNUNET_NETWORK_STRUCT_END void	process_dns_result (void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t r)
	Callback called from DNSSTUB resolver when a resolution succeeded. More...
static int	check_dns_request (void *cls, const struct DnsResponseMessage *msg)
	Check a request via cadet to perform a DNS query. More...
static void	handle_dns_request (void *cls, const struct DnsResponseMessage *msg)
	Process a request via cadet to perform a DNS query. More...
static void	hash_redirect_info (struct GNUNET_HashCode *hash, const struct RedirectInformation *ri)
	Given IP information about a connection, calculate the respective hash we would use for the connections_map. More...
static struct ChannelState *	get_redirect_state (int af, int protocol, const void *destination_ip, uint16_t destination_port, const void *local_ip, uint16_t local_port, struct GNUNET_HashCode *state_key)
	Get our connection tracking state. More...
static int	check_tcp_service (void *cls, const struct GNUNET_EXIT_TcpServiceStartMessage *start)
	Check a request via cadet to send a request to a TCP service offered by this system. More...
static void	prepare_ipv4_packet (const void *payload, size_t payload_length, int protocol, const struct GNUNET_TUN_TcpHeader *tcp_header, const struct SocketAddress *src_address, const struct SocketAddress *dst_address, struct GNUNET_TUN_IPv4Header *pkt4)
	Prepare an IPv4 packet for transmission via the TUN interface. More...
static void	prepare_ipv6_packet (const void *payload, size_t payload_length, int protocol, const struct GNUNET_TUN_TcpHeader *tcp_header, const struct SocketAddress *src_address, const struct SocketAddress *dst_address, struct GNUNET_TUN_IPv6Header *pkt6)
	Prepare an IPv6 packet for transmission via the TUN interface. More...
static void	send_tcp_packet_via_tun (const struct SocketAddress *destination_address, const struct SocketAddress *source_address, const struct GNUNET_TUN_TcpHeader *tcp_header, const void *payload, size_t payload_length)
	Send a TCP packet via the TUN interface. More...
static void	send_icmp_packet_via_tun (const struct SocketAddress *destination_address, const struct SocketAddress *source_address, const struct GNUNET_TUN_IcmpHeader *icmp_header, const void *payload, size_t payload_length)
	Send an ICMP packet via the TUN interface. More...
static void	setup_fresh_address (int af, uint8_t proto, struct SocketAddress *local_address)
	We need to create a (unique) fresh local address (IP+port). More...
static void	setup_state_record (struct ChannelState *state)
	We are starting a fresh connection (TCP or UDP) and need to pick a source port and IP address (within the correct range and address family) to associate replies with the connection / correct cadet channel. More...
static void	send_udp_packet_via_tun (const struct SocketAddress *destination_address, const struct SocketAddress *source_address, const void *payload, size_t payload_length)
	Send a UDP packet via the TUN interface. More...
static int	check_udp_remote (void *cls, const struct GNUNET_EXIT_UdpInternetMessage *msg)
	Check a request to forward UDP data to the Internet via this peer. More...
static void	handle_udp_remote (void *cls, const struct GNUNET_EXIT_UdpInternetMessage *msg)
	Process a request to forward UDP data to the Internet via this peer. More...
static int	check_udp_service (void *cls, const struct GNUNET_EXIT_UdpServiceMessage *msg)
	Check a request via cadet to send a request to a UDP service offered by this system. More...
static void	handle_udp_service (void *cls, const struct GNUNET_EXIT_UdpServiceMessage *msg)
	Process a request via cadet to send a request to a UDP service offered by this system. More...
static void	handle_tcp_service (void *cls, const struct GNUNET_EXIT_TcpServiceStartMessage *start)
	Process a request via cadet to send a request to a TCP service offered by this system. More...
static int	check_tcp_remote (void *cls, const struct GNUNET_EXIT_TcpInternetStartMessage *start)
	Check a request to forward TCP data to the Internet via this peer. More...
static void	handle_tcp_remote (void *cls, const struct GNUNET_EXIT_TcpInternetStartMessage *start)
	Process a request to forward TCP data to the Internet via this peer. More...
static int	check_tcp_data (void *cls, const struct GNUNET_EXIT_TcpDataMessage *data)
	Check a request to forward TCP data on an established connection via this peer. More...
static void	handle_tcp_data (void *cls, const struct GNUNET_EXIT_TcpDataMessage *data)
	Process a request to forward TCP data on an established connection via this peer. More...
static void	make_up_icmpv4_payload (struct ChannelState *state, struct GNUNET_TUN_IPv4Header *ipp, struct GNUNET_TUN_UdpHeader *udp)
	Synthesize a plausible ICMP payload for an ICMPv4 error response on the given channel. More...
static void	make_up_icmpv6_payload (struct ChannelState *state, struct GNUNET_TUN_IPv6Header *ipp, struct GNUNET_TUN_UdpHeader *udp)
	Synthesize a plausible ICMP payload for an ICMPv6 error response on the given channel. More...
static int	check_icmp_remote (void *cls, const struct GNUNET_EXIT_IcmpInternetMessage *msg)
	Check a request to forward ICMP data to the Internet via this peer. More...
static void	handle_icmp_remote (void *cls, const struct GNUNET_EXIT_IcmpInternetMessage *msg)
	Process a request to forward ICMP data to the Internet via this peer. More...
static uint16_t	make_up_icmp_service_payload (struct ChannelState *state, char *buf)
	Setup ICMP payload for ICMP error messages. More...
static int	check_icmp_service (void *cls, const struct GNUNET_EXIT_IcmpServiceMessage *msg)
	Check a request via cadet to send ICMP data to a service offered by this system. More...
static void	handle_icmp_service (void *cls, const struct GNUNET_EXIT_IcmpServiceMessage *msg)
	Process a request via cadet to send ICMP data to a service offered by this system. More...
static int	free_service_record (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free memory associated with a service record. More...
static void *	new_service_channel (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
	Callback from CADET for new channels. More...
static void	clean_channel (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called by cadet whenever an inbound channel is destroyed. More...
static void	store_service (int proto, const char *name, uint16_t destination_port, struct LocalService *service)
	Given a service descriptor and a destination port, find the respective service entry. More...
static void	send_packet_to_cadet_channel (struct ChannelState *s, struct GNUNET_MQ_Envelope *env)
	Send the given packet via the cadet channel. More...
static void	icmp_from_helper (const struct GNUNET_TUN_IcmpHeader *icmp, size_t pktlen, int af, const void *destination_ip, const void *source_ip)
	Handles an ICMP packet received from the helper. More...
static void	udp_from_helper (const struct GNUNET_TUN_UdpHeader *udp, size_t pktlen, int af, const void *destination_ip, const void *source_ip)
	Handles an UDP packet received from the helper. More...
static void	tcp_from_helper (const struct GNUNET_TUN_TcpHeader *tcp, size_t pktlen, int af, const void *destination_ip, const void *source_ip)
	Handles a TCP packet received from the helper. More...
static int	message_token (void *cls, const struct GNUNET_MessageHeader *message)
	Receive packets from the helper-process. More...
static void *	new_channel (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
	Callback from CADET for new channels. More...
static int	free_iterate (void *cls, const struct GNUNET_HashCode *hash, void *value)
	Function that frees everything from a hashmap. More...
static void	dummy_task (void *cls)
	Function scheduled as very last function if the service disabled itself because the helper is not installed properly. More...
static void	cleanup (void *cls)
	Function scheduled as very last function, cleans up after us. More...
static void	add_services (int proto, char *cpy, const char *name)
	Add services to the service map. More...
static void	read_service_conf (void *cls, const char *section)
	Reads the configuration and populates #udp_services and #tcp_services. More...
static void	do_dht_put (void *cls)
	We are running a DNS exit service, advertise it in the DHT. More...
static void	dht_put_cont (void *cls)
	Function called when the DHT PUT operation is complete. More...
static void	parse_ip_options ()
	Figure out which IP versions we should support (and which are supported by the OS) according to our configuration. More...
static void	advertise_dns_exit ()
	Helper function to open the CADET port for DNS exits and to advertise the DNS exit (if applicable). More...
static int	setup_exit_helper_args ()
	Initialize exit_argv. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg_)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function. More...

Variables
static int	global_ret
	Return value from 'main'. More...
static struct GNUNET_REGEX_Announcement *	regex4
	Handle to our regex announcement for IPv4. More...
static struct GNUNET_REGEX_Announcement *	regex6
	Handle to our regex announcement for IPv4. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	The handle to the configuration used throughout the process. More...
static struct GNUNET_HELPER_Handle *	helper_handle
	The handle to the helper. More...
static char *	exit_argv [8]
	Arguments to the exit helper. More...
static struct in6_addr	exit_ipv6addr
	IPv6 address of our TUN interface. More...
static unsigned long long	ipv6prefix
	IPv6 prefix (0..127) from configuration file. More...
static struct in_addr	exit_ipv4addr
	IPv4 address of our TUN interface. More...
static struct in_addr	exit_ipv4mask
	IPv4 netmask of our TUN interface. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Statistics. More...
static struct GNUNET_CADET_Handle *	cadet_handle
	The handle to cadet. More...
static struct GNUNET_CONTAINER_MultiHashMap *	connections_map
	This hashmaps contains the mapping from peer, service-descriptor, source-port and destination-port to a struct ChannelState. More...
static struct GNUNET_CONTAINER_Heap *	connections_heap
	Heap so we can quickly find "old" connections. More...
static unsigned long long	max_connections
	If there are at least this many connections, old ones will be removed. More...
static struct GNUNET_CONTAINER_MultiHashMap *	services
	This hashmaps saves interesting things about the configured services. More...
static struct ChannelState *	channels [UINT16_MAX+1]
	Array of all open DNS requests from channels. More...
static struct GNUNET_DNSSTUB_Context *	dnsstub
	Handle to the DNS Stub resolver. More...
static struct GNUNET_DHT_PutHandle *	dht_put
	Handle for ongoing DHT PUT operations to advertise exit service. More...
static struct GNUNET_DHT_Handle *	dht
	Handle to the DHT. More...
static struct GNUNET_SCHEDULER_Task *	dht_task
	Task for doing DHT PUTs to advertise exit service. More...
static struct GNUNET_DNS_Advertisement	dns_advertisement
	Advertisement message we put into the DHT to advertise us as a DNS exit. More...
static struct GNUNET_HashCode	dht_put_key
	Key we store the DNS advertismenet under. More...
static struct GNUNET_CRYPTO_EddsaPrivateKey *	peer_key
	Private key for this peer. More...
static struct GNUNET_CADET_Port *	dns_port
	Port for DNS exit. More...
static struct GNUNET_CADET_Port *	cadet_port4
	Port for IPv4 exit. More...
static struct GNUNET_CADET_Port *	cadet_port6
	Port for IPv6 exit. More...
static int	ipv4_exit
	Are we an IPv4-exit? More...
static int	ipv6_exit
	Are we an IPv6-exit? More...
static int	ipv4_enabled
	Do we support IPv4 at all on the TUN interface? More...
static int	ipv6_enabled
	Do we support IPv6 at all on the TUN interface? More...

Detailed Description

tool to allow IP traffic exit from the GNUnet cadet to the Internet

Author

Philipp Toelke

Christian Grothoff

TODO:

• test

Design:

• which code should advertise services? the service model is right now a bit odd, especially as this code DOES the exit and knows the DNS "name", but OTOH this is clearly NOT the place to advertise the service's existence; maybe the daemon should turn into a service with an API to add local-exit services dynamically?

Definition in file gnunet-daemon-exit.c.

Macro Definition Documentation

REGEX_MAX_PATH_LEN_IPV4

#define REGEX_MAX_PATH_LEN_IPV4   4

Maximum path compression length for cadet regex announcing for IPv4 address based regex.

Definition at line 58 of file gnunet-daemon-exit.c.

Referenced by run().

REGEX_MAX_PATH_LEN_IPV6

#define REGEX_MAX_PATH_LEN_IPV6   8

Maximum path compression length for cadet regex announcing for IPv6 address based regex.

Definition at line 64 of file gnunet-daemon-exit.c.

Referenced by run().

REGEX_REFRESH_FREQUENCY

#define REGEX_REFRESH_FREQUENCY   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)

How frequently do we re-announce the regex for the exit?

Definition at line 69 of file gnunet-daemon-exit.c.

Referenced by run().

DHT_PUT_FREQUENCY

#define DHT_PUT_FREQUENCY   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)

How frequently do we re-announce the DNS exit in the DHT?

Definition at line 74 of file gnunet-daemon-exit.c.

Referenced by do_dht_put().

DNS_ADVERTISEMENT_TIMEOUT

#define DNS_ADVERTISEMENT_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 3)

How long do we typically sign the DNS exit advertisement for?

Definition at line 79 of file gnunet-daemon-exit.c.

Referenced by do_dht_put().

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from(kind, "exit", __VA_ARGS__);

Generic logging shorthand.

Definition at line 85 of file gnunet-daemon-exit.c.

Referenced by clean_channel(), handle_udp_service(), and process_dns_result().

Function Documentation

process_dns_result()

static GNUNET_NETWORK_STRUCT_END void process_dns_result ( void *  cls, const struct GNUNET_TUN_DnsHeader *  dns, size_t  r  )

static

Callback called from DNSSTUB resolver when a resolution succeeded.

Parameters

cls	NULL
dns	the response itself
r	number of bytes in dns

Definition at line 447 of file gnunet-daemon-exit.c.

References ChannelState::channel, DnsResponseMessage::dns, ChannelState::dns, env, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TUN_DnsHeader::id, LOG, and ChannelState::specifics.

Referenced by handle_dns_request().

{
  struct ChannelState *ts;
  struct GNUNET_MQ_Envelope *env;
  struct DnsResponseMessage *resp;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Processing DNS result from stub resolver\n");
  GNUNET_assert(NULL == cls);
  if (NULL == dns)
    return;
  /* Handle case that this is a reply to a request from a CADET DNS channel */
  ts = channels[dns->id];
  if (NULL == ts)
    return;
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Got a response from the stub resolver for DNS request received via CADET!\n");
  channels[dns->id] = NULL;
  env = GNUNET_MQ_msg_extra(resp,
                            r - sizeof(struct GNUNET_TUN_DnsHeader),
                            GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET);
  GNUNET_memcpy(&resp->dns,
                dns,
                r);
  resp->dns.id = ts->specifics.dns.original_id;
  GNUNET_MQ_send(GNUNET_CADET_get_mq(ts->channel),
                 env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_dns_request()

static int check_dns_request ( void *  cls, const struct DnsResponseMessage *  msg  )

static

Check a request via cadet to perform a DNS query.

Parameters

cls	our struct ChannelState *
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 488 of file gnunet-daemon-exit.c.

References GNUNET_break, GNUNET_break_op, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and ChannelState::is_dns.

{
  struct ChannelState *ts = cls;

  if (NULL == dnsstub)
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  if (GNUNET_NO == ts->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_dns_request()

static void handle_dns_request ( void *  cls, const struct DnsResponseMessage *  msg  )

static

Process a request via cadet to perform a DNS query.

Parameters

cls	our struct ChannelState *
msg	the actual message

Definition at line 514 of file gnunet-daemon-exit.c.

References buf, ChannelState::channel, DnsResponseMessage::dns, ChannelState::dns, GNUNET_ALIGN, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_DNSSTUB_resolve(), GNUNET_memcpy, GNUNET_SYSERR, GNUNET_YES, DnsResponseMessage::header, GNUNET_TUN_DnsHeader::id, ChannelState::is_dns, process_dns_result(), GNUNET_MessageHeader::size, and ChannelState::specifics.

{
  struct ChannelState *ts = cls;
  size_t mlen = ntohs(msg->header.size);
  size_t dlen = mlen - sizeof(struct GNUNET_MessageHeader);
  char buf[dlen] GNUNET_ALIGN;
  struct GNUNET_TUN_DnsHeader *dout;

  if (GNUNET_SYSERR == ts->is_dns)
    {
      /* channel is DNS from now on */
      ts->is_dns = GNUNET_YES;
    }
  ts->specifics.dns.original_id = msg->dns.id;
  if (channels[ts->specifics.dns.my_id] == ts)
    channels[ts->specifics.dns.my_id] = NULL;
  ts->specifics.dns.my_id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                               UINT16_MAX + 1);
  channels[ts->specifics.dns.my_id] = ts;
  GNUNET_memcpy(buf,
                &msg->dns,
                dlen);
  dout = (struct GNUNET_TUN_DnsHeader *)buf;
  dout->id = ts->specifics.dns.my_id;
  ts->specifics.dns.rs = GNUNET_DNSSTUB_resolve(dnsstub,
                                                buf,
                                                dlen,
                                                &process_dns_result,
                                                NULL);
  if (NULL == ts->specifics.dns.rs)
    {
      GNUNET_break_op(0);
      return;
    }
  GNUNET_CADET_receive_done(ts->channel);
}

Here is the call graph for this function:

hash_redirect_info()

static void hash_redirect_info ( struct GNUNET_HashCode *  hash, const struct RedirectInformation *  ri  )

static

Given IP information about a connection, calculate the respective hash we would use for the connections_map.

Parameters

hash	resulting hash
ri	information about the connection

Definition at line 561 of file gnunet-daemon-exit.c.

References SocketAddress::address, SocketAddress::af, GNUNET_assert, GNUNET_memcpy, SocketAddress::ipv4, SocketAddress::ipv6, RedirectInformation::local_address, SocketAddress::port, SocketAddress::proto, and RedirectInformation::remote_address.

Referenced by get_redirect_state().

{
  char *off;

  memset(hash,
         0,
         sizeof(struct GNUNET_HashCode));
  /* the GNUnet hashmap only uses the first sizeof(unsigned int) of the hash,
     so we put the IP address in there (and hope for few collisions) */
  off = (char*)hash;
  switch (ri->remote_address.af)
    {
    case AF_INET:
      GNUNET_memcpy(off,
                    &ri->remote_address.address.ipv4,
                    sizeof(struct in_addr));
      off += sizeof(struct in_addr);
      break;

    case AF_INET6:
      GNUNET_memcpy(off,
                    &ri->remote_address.address.ipv6,
                    sizeof(struct in6_addr));
      off += sizeof(struct in_addr);
      break;

    default:
      GNUNET_assert(0);
    }
  GNUNET_memcpy(off,
                &ri->remote_address.port,
                sizeof(uint16_t));
  off += sizeof(uint16_t);
  switch (ri->local_address.af)
    {
    case AF_INET:
      GNUNET_memcpy(off,
                    &ri->local_address.address.ipv4,
                    sizeof(struct in_addr));
      off += sizeof(struct in_addr);
      break;

    case AF_INET6:
      GNUNET_memcpy(off,
                    &ri->local_address.address.ipv6,
                    sizeof(struct in6_addr));
      off += sizeof(struct in_addr);
      break;

    default:
      GNUNET_assert(0);
    }
  GNUNET_memcpy(off,
                &ri->local_address.port,
                sizeof(uint16_t));
  off += sizeof(uint16_t);
  GNUNET_memcpy(off,
                &ri->remote_address.proto,
                sizeof(uint8_t));
  /* off += sizeof (uint8_t); */
}

Here is the caller graph for this function:

get_redirect_state()

static struct ChannelState* get_redirect_state ( int  af, int  protocol, const void *  destination_ip, uint16_t  destination_port, const void *  local_ip, uint16_t  local_port, struct GNUNET_HashCode *  state_key  )

static

Get our connection tracking state.

Warns if it does not exists, refreshes the timestamp if it does exist.

Parameters

af	address family
protocol	IPPROTO_UDP or IPPROTO_TCP
destination_ip	target IP
destination_port	target port
local_ip	local IP
local_port	local port
state_key	set to hash's state if non-NULL

Returns

NULL if we have no tracking information for this tuple

Definition at line 639 of file gnunet-daemon-exit.c.

References SocketAddress::address, SocketAddress::af, GNUNET_CONTAINER_heap_update_cost(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_TIME_absolute_get(), hash_redirect_info(), SocketAddress::ipv4, SocketAddress::ipv6, key, RedirectInformation::local_address, SocketAddress::port, SocketAddress::proto, RedirectInformation::remote_address, ChannelState::specifics, state, and ChannelState::tcp_udp.

Referenced by icmp_from_helper(), setup_state_record(), tcp_from_helper(), and udp_from_helper().

{
  struct RedirectInformation ri;
  struct GNUNET_HashCode key;
  struct ChannelState *state;

  if (((af == AF_INET) && (protocol == IPPROTO_ICMP)) ||
      ((af == AF_INET6) && (protocol == IPPROTO_ICMPV6)))
    {
      /* ignore ports */
      destination_port = 0;
      local_port = 0;
    }
  ri.remote_address.af = af;
  if (af == AF_INET)
    ri.remote_address.address.ipv4 = *((struct in_addr*)destination_ip);
  else
    ri.remote_address.address.ipv6 = *((struct in6_addr*)destination_ip);
  ri.remote_address.port = destination_port;
  ri.remote_address.proto = protocol;
  ri.local_address.af = af;
  if (af == AF_INET)
    ri.local_address.address.ipv4 = *((struct in_addr*)local_ip);
  else
    ri.local_address.address.ipv6 = *((struct in6_addr*)local_ip);
  ri.local_address.port = local_port;
  ri.local_address.proto = protocol;
  hash_redirect_info(&key,
                     &ri);
  if (NULL != state_key)
    *state_key = key;
  state = GNUNET_CONTAINER_multihashmap_get(connections_map,
                                            &key);
  if (NULL == state)
    return NULL;
  /* Mark this connection as freshly used */
  if (NULL == state_key)
    GNUNET_CONTAINER_heap_update_cost(state->specifics.tcp_udp.heap_node,
                                      GNUNET_TIME_absolute_get().abs_value_us);
  return state;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_tcp_service()

static int check_tcp_service ( void *  cls, const struct GNUNET_EXIT_TcpServiceStartMessage *  start  )

static

Check a request via cadet to send a request to a TCP service offered by this system.

Parameters

cls	our struct ChannelState *
start	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 699 of file gnunet-daemon-exit.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, GNUNET_TUN_TcpHeader::off, ChannelState::specifics, state, GNUNET_EXIT_TcpServiceStartMessage::tcp_header, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;

  if (NULL == state)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (GNUNET_YES == state->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (NULL == state->specifics.tcp_udp.serv)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (NULL != state->specifics.tcp_udp.heap_node)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (start->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

prepare_ipv4_packet()

static void prepare_ipv4_packet ( const void *  payload, size_t  payload_length, int  protocol, const struct GNUNET_TUN_TcpHeader *  tcp_header, const struct SocketAddress *  src_address, const struct SocketAddress *  dst_address, struct GNUNET_TUN_IPv4Header *  pkt4  )

static

Prepare an IPv4 packet for transmission via the TUN interface.

Initializes the IP header and calculates checksums (IP+UDP/TCP). For UDP, the UDP header will be fully created, whereas for TCP only the ports and checksum will be filled in. So for TCP, a skeleton TCP header must be part of the provided payload.

Parameters

payload	payload of the packet (starting with UDP payload or TCP header, depending on protocol)
payload_length	number of bytes in payload
protocol	IPPROTO_UDP or IPPROTO_TCP
tcp_header	skeleton of the TCP header, NULL for UDP
src_address	source address to use (IP and port)
dst_address	destination address to use (IP and port)
pkt4	where to write the assembled packet; must contain enough space for the IP header, UDP/TCP header AND the payload

Definition at line 752 of file gnunet-daemon-exit.c.

References SocketAddress::address, GNUNET_TUN_TcpHeader::destination_port, GNUNET_TUN_UdpHeader::destination_port, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_TUN_calculate_tcp4_checksum(), GNUNET_TUN_calculate_udp4_checksum(), GNUNET_TUN_initialize_ipv4_header(), SocketAddress::ipv4, len, GNUNET_TUN_UdpHeader::len, SocketAddress::port, GNUNET_TUN_TcpHeader::source_port, and GNUNET_TUN_UdpHeader::source_port.

Referenced by send_tcp_packet_via_tun(), and send_udp_packet_via_tun().

{
  size_t len;

  len = payload_length;
  switch (protocol)
    {
    case IPPROTO_UDP:
      len += sizeof(struct GNUNET_TUN_UdpHeader);
      break;

    case IPPROTO_TCP:
      len += sizeof(struct GNUNET_TUN_TcpHeader);
      GNUNET_assert(NULL != tcp_header);
      break;

    default:
      GNUNET_break(0);
      return;
    }
  if (len + sizeof(struct GNUNET_TUN_IPv4Header) > UINT16_MAX)
    {
      GNUNET_break(0);
      return;
    }

  GNUNET_TUN_initialize_ipv4_header(pkt4,
                                    protocol,
                                    len,
                                    &src_address->address.ipv4,
                                    &dst_address->address.ipv4);
  switch (protocol)
    {
    case IPPROTO_UDP:
    {
      struct GNUNET_TUN_UdpHeader *pkt4_udp = (struct GNUNET_TUN_UdpHeader *)&pkt4[1];

      pkt4_udp->source_port = htons(src_address->port);
      pkt4_udp->destination_port = htons(dst_address->port);
      pkt4_udp->len = htons((uint16_t)payload_length);
      GNUNET_TUN_calculate_udp4_checksum(pkt4,
                                         pkt4_udp,
                                         payload,
                                         payload_length);
      GNUNET_memcpy(&pkt4_udp[1],
                    payload,
                    payload_length);
    }
    break;

    case IPPROTO_TCP:
    {
      struct GNUNET_TUN_TcpHeader *pkt4_tcp = (struct GNUNET_TUN_TcpHeader *)&pkt4[1];

      *pkt4_tcp = *tcp_header;
      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                 "Sending TCP packet from port %u to port %u\n",
                 src_address->port,
                 dst_address->port);
      pkt4_tcp->source_port = htons(src_address->port);
      pkt4_tcp->destination_port = htons(dst_address->port);
      GNUNET_TUN_calculate_tcp4_checksum(pkt4,
                                         pkt4_tcp,
                                         payload,
                                         payload_length);
      GNUNET_memcpy(&pkt4_tcp[1],
                    payload,
                    payload_length);
    }
    break;

    default:
      GNUNET_assert(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_ipv6_packet()

static void prepare_ipv6_packet ( const void *  payload, size_t  payload_length, int  protocol, const struct GNUNET_TUN_TcpHeader *  tcp_header, const struct SocketAddress *  src_address, const struct SocketAddress *  dst_address, struct GNUNET_TUN_IPv6Header *  pkt6  )

static

Prepare an IPv6 packet for transmission via the TUN interface.

Initializes the IP header and calculates checksums (IP+UDP/TCP). For UDP, the UDP header will be fully created, whereas for TCP only the ports and checksum will be filled in. So for TCP, a skeleton TCP header must be part of the provided payload.

Parameters

payload	payload of the packet (starting with UDP payload or TCP header, depending on protocol)
payload_length	number of bytes in payload
protocol	IPPROTO_UDP or IPPROTO_TCP
tcp_header	skeleton TCP header data to send, NULL for UDP
src_address	source address to use (IP and port)
dst_address	destination address to use (IP and port)
pkt6	where to write the assembled packet; must contain enough space for the IP header, UDP/TCP header AND the payload

Definition at line 854 of file gnunet-daemon-exit.c.

References SocketAddress::address, GNUNET_TUN_TcpHeader::destination_port, GNUNET_TUN_UdpHeader::destination_port, GNUNET_assert, GNUNET_break, GNUNET_memcpy, GNUNET_TUN_calculate_tcp6_checksum(), GNUNET_TUN_calculate_udp6_checksum(), GNUNET_TUN_initialize_ipv6_header(), SocketAddress::ipv6, len, GNUNET_TUN_UdpHeader::len, SocketAddress::port, GNUNET_TUN_TcpHeader::source_port, and GNUNET_TUN_UdpHeader::source_port.

Referenced by send_tcp_packet_via_tun(), and send_udp_packet_via_tun().

{
  size_t len;

  len = payload_length;
  switch (protocol)
    {
    case IPPROTO_UDP:
      len += sizeof(struct GNUNET_TUN_UdpHeader);
      break;

    case IPPROTO_TCP:
      len += sizeof(struct GNUNET_TUN_TcpHeader);
      break;

    default:
      GNUNET_break(0);
      return;
    }
  if (len > UINT16_MAX)
    {
      GNUNET_break(0);
      return;
    }

  GNUNET_TUN_initialize_ipv6_header(pkt6,
                                    protocol,
                                    len,
                                    &src_address->address.ipv6,
                                    &dst_address->address.ipv6);

  switch (protocol)
    {
    case IPPROTO_UDP:
    {
      struct GNUNET_TUN_UdpHeader *pkt6_udp = (struct GNUNET_TUN_UdpHeader *)&pkt6[1];

      pkt6_udp->source_port = htons(src_address->port);
      pkt6_udp->destination_port = htons(dst_address->port);
      pkt6_udp->len = htons((uint16_t)payload_length);
      GNUNET_TUN_calculate_udp6_checksum(pkt6,
                                         pkt6_udp,
                                         payload,
                                         payload_length);
      GNUNET_memcpy(&pkt6_udp[1],
                    payload,
                    payload_length);
    }
    break;

    case IPPROTO_TCP:
    {
      struct GNUNET_TUN_TcpHeader *pkt6_tcp = (struct GNUNET_TUN_TcpHeader *)&pkt6[1];

      /* GNUNET_memcpy first here as some TCP header fields are initialized this way! */
      *pkt6_tcp = *tcp_header;
      pkt6_tcp->source_port = htons(src_address->port);
      pkt6_tcp->destination_port = htons(dst_address->port);
      GNUNET_TUN_calculate_tcp6_checksum(pkt6,
                                         pkt6_tcp,
                                         payload,
                                         payload_length);
      GNUNET_memcpy(&pkt6_tcp[1],
                    payload,
                    payload_length);
    }
    break;

    default:
      GNUNET_assert(0);
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_tcp_packet_via_tun()

static void send_tcp_packet_via_tun ( const struct SocketAddress *  destination_address, const struct SocketAddress *  source_address, const struct GNUNET_TUN_TcpHeader *  tcp_header, const void *  payload, size_t  payload_length  )

static

Send a TCP packet via the TUN interface.

Parameters

destination_address	IP and port to use for the TCP packet's destination
source_address	IP and port to use for the TCP packet's source
tcp_header	header template to use
payload	payload of the TCP packet
payload_length	number of bytes in payload

Definition at line 945 of file gnunet-daemon-exit.c.

References SocketAddress::af, buf, ETH_P_IPV4, ETH_P_IPV6, GNUNET_TUN_Layer2PacketHeader::flags, gettext_noop, GNUNET_ALIGN, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, SocketAddress::ipv4, SocketAddress::ipv6, len, prepare_ipv4_packet(), prepare_ipv6_packet(), GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_tcp_data(), handle_tcp_remote(), and handle_tcp_service().

{
  size_t len;

  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# TCP packets sent via TUN"),
                           1,
                           GNUNET_NO);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Sending packet with %u bytes TCP payload via TUN\n",
             (unsigned int)payload_length);
  len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader);
  switch (source_address->af)
    {
    case AF_INET:
      len += sizeof(struct GNUNET_TUN_IPv4Header);
      break;

    case AF_INET6:
      len += sizeof(struct GNUNET_TUN_IPv6Header);
      break;

    default:
      GNUNET_break(0);
      return;
    }
  len += sizeof(struct GNUNET_TUN_TcpHeader);
  len += payload_length;
  if (len >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  {
    char buf[len] GNUNET_ALIGN;
    struct GNUNET_MessageHeader *hdr;
    struct GNUNET_TUN_Layer2PacketHeader *tun;

    hdr = (struct GNUNET_MessageHeader *)buf;
    hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER);
    hdr->size = htons(len);
    tun = (struct GNUNET_TUN_Layer2PacketHeader*)&hdr[1];
    tun->flags = htons(0);
    switch (source_address->af)
      {
      case AF_INET:
      {
        struct GNUNET_TUN_IPv4Header *ipv4
          = (struct GNUNET_TUN_IPv4Header*)&tun[1];

        tun->proto = htons(ETH_P_IPV4);
        prepare_ipv4_packet(payload,
                            payload_length,
                            IPPROTO_TCP,
                            tcp_header,
                            source_address,
                            destination_address,
                            ipv4);
      }
      break;

      case AF_INET6:
      {
        struct GNUNET_TUN_IPv6Header *ipv6
          = (struct GNUNET_TUN_IPv6Header*)&tun[1];

        tun->proto = htons(ETH_P_IPV6);
        prepare_ipv6_packet(payload,
                            payload_length,
                            IPPROTO_TCP,
                            tcp_header,
                            source_address,
                            destination_address,
                            ipv6);
      }
      break;

      default:
        GNUNET_assert(0);
        break;
      }
    if (NULL != helper_handle)
      (void)GNUNET_HELPER_send(helper_handle,
                               (const struct GNUNET_MessageHeader*)buf,
                               GNUNET_YES,
                               NULL,
                               NULL);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_icmp_packet_via_tun()

static void send_icmp_packet_via_tun ( const struct SocketAddress *  destination_address, const struct SocketAddress *  source_address, const struct GNUNET_TUN_IcmpHeader *  icmp_header, const void *  payload, size_t  payload_length  )

static

Send an ICMP packet via the TUN interface.

Parameters

destination_address	IP to use for the ICMP packet's destination
source_address	IP to use for the ICMP packet's source
icmp_header	ICMP header to send
payload	payload of the ICMP packet (does NOT include ICMP header)
payload_length	number of bytes of data in payload

Definition at line 1050 of file gnunet-daemon-exit.c.

References SocketAddress::address, SocketAddress::af, buf, ETH_P_IPV4, ETH_P_IPV6, GNUNET_TUN_Layer2PacketHeader::flags, gettext_noop, GNUNET_ALIGN, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TUN_calculate_icmp_checksum(), GNUNET_TUN_initialize_ipv4_header(), GNUNET_TUN_initialize_ipv6_header(), GNUNET_YES, SocketAddress::ipv4, SocketAddress::ipv6, len, GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_icmp_remote(), and handle_icmp_service().

{
  size_t len;
  struct GNUNET_TUN_IcmpHeader *icmp;

  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# ICMP packets sent via TUN"),
                           1, GNUNET_NO);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Sending packet with %u bytes ICMP payload via TUN\n",
             (unsigned int)payload_length);
  len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader);
  switch (destination_address->af)
    {
    case AF_INET:
      len += sizeof(struct GNUNET_TUN_IPv4Header);
      break;

    case AF_INET6:
      len += sizeof(struct GNUNET_TUN_IPv6Header);
      break;

    default:
      GNUNET_break(0);
      return;
    }
  len += sizeof(struct GNUNET_TUN_IcmpHeader);
  len += payload_length;
  if (len >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  {
    char buf[len] GNUNET_ALIGN;
    struct GNUNET_MessageHeader *hdr;
    struct GNUNET_TUN_Layer2PacketHeader *tun;

    hdr = (struct GNUNET_MessageHeader *)buf;
    hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER);
    hdr->size = htons(len);
    tun = (struct GNUNET_TUN_Layer2PacketHeader*)&hdr[1];
    tun->flags = htons(0);
    switch (source_address->af)
      {
      case AF_INET:
      {
        struct GNUNET_TUN_IPv4Header * ipv4 = (struct GNUNET_TUN_IPv4Header*)&tun[1];

        tun->proto = htons(ETH_P_IPV4);
        GNUNET_TUN_initialize_ipv4_header(ipv4,
                                          IPPROTO_ICMP,
                                          sizeof(struct GNUNET_TUN_IcmpHeader) + payload_length,
                                          &source_address->address.ipv4,
                                          &destination_address->address.ipv4);
        icmp = (struct GNUNET_TUN_IcmpHeader*)&ipv4[1];
      }
      break;

      case AF_INET6:
      {
        struct GNUNET_TUN_IPv6Header * ipv6 = (struct GNUNET_TUN_IPv6Header*)&tun[1];

        tun->proto = htons(ETH_P_IPV6);
        GNUNET_TUN_initialize_ipv6_header(ipv6,
                                          IPPROTO_ICMPV6,
                                          sizeof(struct GNUNET_TUN_IcmpHeader) + payload_length,
                                          &source_address->address.ipv6,
                                          &destination_address->address.ipv6);
        icmp = (struct GNUNET_TUN_IcmpHeader*)&ipv6[1];
      }
      break;

      default:
        GNUNET_assert(0);
        break;
      }
    *icmp = *icmp_header;
    GNUNET_memcpy(&icmp[1],
                  payload,
                  payload_length);
    GNUNET_TUN_calculate_icmp_checksum(icmp,
                                       payload,
                                       payload_length);
    if (NULL != helper_handle)
      (void)GNUNET_HELPER_send(helper_handle,
                               (const struct GNUNET_MessageHeader*)buf,
                               GNUNET_YES,
                               NULL, NULL);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_fresh_address()

static void setup_fresh_address ( int  af, uint8_t  proto, struct SocketAddress *  local_address  )

static

We need to create a (unique) fresh local address (IP+port).

Fill one in.

Parameters

af	desired address family
proto	desired protocol (IPPROTO_UDP or IPPROTO_TCP)
local_address	address to initialize

Definition at line 1155 of file gnunet-daemon-exit.c.

References SocketAddress::address, SocketAddress::af, exit_ipv4addr, exit_ipv4mask, exit_ipv6addr, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_memcmp, SocketAddress::ipv4, SocketAddress::ipv6, ipv6prefix, SocketAddress::port, and SocketAddress::proto.

Referenced by setup_state_record().

{
  local_address->af = af;
  local_address->proto = (uint8_t)proto;
  /* default "local" port range is often 32768--61000,
     so we pick a random value in that range */
  if (((af == AF_INET) && (proto == IPPROTO_ICMP)) ||
      ((af == AF_INET6) && (proto == IPPROTO_ICMPV6)))
    local_address->port = 0;
  else
    local_address->port
      = (uint16_t)32768 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                   28232);
  switch (af)
    {
    case AF_INET:
    {
      struct in_addr addr;
      struct in_addr mask;
      struct in_addr rnd;

      addr = exit_ipv4addr;
      mask = exit_ipv4mask;
      if (0 == ~mask.s_addr)
        {
          /* only one valid IP anyway */
          local_address->address.ipv4 = addr;
          return;
        }
      /* Given 192.168.0.1/255.255.0.0, we want a mask
         of '192.168.255.255', thus:  */
      mask.s_addr = addr.s_addr | ~mask.s_addr;
      /* Pick random IPv4 address within the subnet, except 'addr' or 'mask' itself */
      do
        {
          rnd.s_addr = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                UINT32_MAX);
          local_address->address.ipv4.s_addr = (addr.s_addr | rnd.s_addr) & mask.s_addr;
        }
      while ((local_address->address.ipv4.s_addr == addr.s_addr) ||
             (local_address->address.ipv4.s_addr == mask.s_addr));
    }
    break;

    case AF_INET6:
    {
      struct in6_addr addr;
      struct in6_addr mask;
      struct in6_addr rnd;
      int i;

      addr = exit_ipv6addr;
      GNUNET_assert(ipv6prefix < 128);
      if (ipv6prefix == 127)
        {
          /* only one valid IP anyway */
          local_address->address.ipv6 = addr;
          return;
        }
      /* Given ABCD::/96, we want a mask of 'ABCD::FFFF:FFFF,
         thus: */
      mask = addr;
      for (i = 127; i >= ipv6prefix; i--)
        mask.s6_addr[i / 8] |= (1 << (i % 8));

      /* Pick random IPv6 address within the subnet, except 'addr' or 'mask' itself */
      do
        {
          for (i = 0; i < 16; i++)
            {
              rnd.s6_addr[i] = (unsigned char)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                                       256);
              local_address->address.ipv6.s6_addr[i]
                = (addr.s6_addr[i] | rnd.s6_addr[i]) & mask.s6_addr[i];
            }
        }
      while ((0 == GNUNET_memcmp(&local_address->address.ipv6,
                                 &addr)) ||
             (0 == GNUNET_memcmp(&local_address->address.ipv6,
                                 &mask)));
    }
    break;

    default:
      GNUNET_assert(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_state_record()

static void setup_state_record ( struct ChannelState *  state )

static

We are starting a fresh connection (TCP or UDP) and need to pick a source port and IP address (within the correct range and address family) to associate replies with the connection / correct cadet channel.

This function generates a "fresh" source IP and source port number for a connection After picking a good source address, this function sets up the state in the 'connections_map' and 'connections_heap' to allow finding the state when needed later. The function also makes sure that we remain within memory limits by cleaning up 'old' states.

Parameters

state

skeleton state to setup a record for; should 'state->specifics.tcp_udp.ri.remote_address' filled in so that this code can determine which AF/protocol is going to be used (the 'channel' should also already be set); after calling this function, heap_node and the local_address will be also initialized (heap_node != NULL can be used to test if a state has been fully setup).

Definition at line 1268 of file gnunet-daemon-exit.c.

References buf, ChannelState::channel, get_redirect_state(), GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_TIME_absolute_get(), key, max_connections, setup_fresh_address(), ChannelState::specifics, and ChannelState::tcp_udp.

Referenced by handle_icmp_remote(), handle_icmp_service(), handle_tcp_remote(), handle_tcp_service(), handle_udp_remote(), and handle_udp_service().

{
  struct GNUNET_HashCode key;
  struct ChannelState *s;

  /* generate fresh, unique address */
  do
    {
      if (NULL == state->specifics.tcp_udp.serv)
        setup_fresh_address(state->specifics.tcp_udp.ri.remote_address.af,
                            state->specifics.tcp_udp.ri.remote_address.proto,
                            &state->specifics.tcp_udp.ri.local_address);
      else
        setup_fresh_address(state->specifics.tcp_udp.serv->address.af,
                            state->specifics.tcp_udp.serv->address.proto,
                            &state->specifics.tcp_udp.ri.local_address);
    }
  while (NULL !=
         get_redirect_state(state->specifics.tcp_udp.ri.remote_address.af,
                            state->specifics.tcp_udp.ri.remote_address.proto,
                            &state->specifics.tcp_udp.ri.remote_address.address,
                            state->specifics.tcp_udp.ri.remote_address.port,
                            &state->specifics.tcp_udp.ri.local_address.address,
                            state->specifics.tcp_udp.ri.local_address.port,
                            &key));
  {
    char buf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Picked local address %s:%u for new connection\n",
               inet_ntop(state->specifics.tcp_udp.ri.local_address.af,
                         &state->specifics.tcp_udp.ri.local_address.address,
                         buf,
                         sizeof(buf)),
               (unsigned int)state->specifics.tcp_udp.ri.local_address.port);
  }
  state->specifics.tcp_udp.state_key = key;
  GNUNET_assert(GNUNET_OK ==
                GNUNET_CONTAINER_multihashmap_put(connections_map,
                                                  &key, state,
                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  state->specifics.tcp_udp.heap_node
    = GNUNET_CONTAINER_heap_insert(connections_heap,
                                   state,
                                   GNUNET_TIME_absolute_get().abs_value_us);
  while (GNUNET_CONTAINER_heap_get_size(connections_heap) > max_connections)
    {
      s = GNUNET_CONTAINER_heap_remove_root(connections_heap);
      GNUNET_assert(state != s);
      s->specifics.tcp_udp.heap_node = NULL;
      GNUNET_CADET_channel_destroy(s->channel);
      GNUNET_assert(GNUNET_OK ==
                    GNUNET_CONTAINER_multihashmap_remove(connections_map,
                                                         &s->specifics.tcp_udp.state_key,
                                                         s));
      GNUNET_free(s);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_udp_packet_via_tun()

static void send_udp_packet_via_tun ( const struct SocketAddress *  destination_address, const struct SocketAddress *  source_address, const void *  payload, size_t  payload_length  )

static

Send a UDP packet via the TUN interface.

Parameters

destination_address	IP and port to use for the UDP packet's destination
source_address	IP and port to use for the UDP packet's source
payload	payload of the UDP packet (does NOT include UDP header)
payload_length	number of bytes of data in payload

Definition at line 1336 of file gnunet-daemon-exit.c.

References SocketAddress::af, buf, ETH_P_IPV4, ETH_P_IPV6, GNUNET_TUN_Layer2PacketHeader::flags, gettext_noop, GNUNET_ALIGN, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, SocketAddress::ipv4, SocketAddress::ipv6, len, prepare_ipv4_packet(), prepare_ipv6_packet(), GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_udp_remote(), and handle_udp_service().

{
  size_t len;

  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# UDP packets sent via TUN"),
                           1, GNUNET_NO);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Sending packet with %u bytes UDP payload via TUN\n",
             (unsigned int)payload_length);
  len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader);
  switch (source_address->af)
    {
    case AF_INET:
      len += sizeof(struct GNUNET_TUN_IPv4Header);
      break;

    case AF_INET6:
      len += sizeof(struct GNUNET_TUN_IPv6Header);
      break;

    default:
      GNUNET_break(0);
      return;
    }
  len += sizeof(struct GNUNET_TUN_UdpHeader);
  len += payload_length;
  if (len >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  {
    char buf[len] GNUNET_ALIGN;
    struct GNUNET_MessageHeader *hdr;
    struct GNUNET_TUN_Layer2PacketHeader *tun;

    hdr = (struct GNUNET_MessageHeader *)buf;
    hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER);
    hdr->size = htons(len);
    tun = (struct GNUNET_TUN_Layer2PacketHeader*)&hdr[1];
    tun->flags = htons(0);
    switch (source_address->af)
      {
      case AF_INET:
      {
        struct GNUNET_TUN_IPv4Header * ipv4 = (struct GNUNET_TUN_IPv4Header*)&tun[1];

        tun->proto = htons(ETH_P_IPV4);
        prepare_ipv4_packet(payload,
                            payload_length,
                            IPPROTO_UDP,
                            NULL,
                            source_address,
                            destination_address,
                            ipv4);
      }
      break;

      case AF_INET6:
      {
        struct GNUNET_TUN_IPv6Header * ipv6 = (struct GNUNET_TUN_IPv6Header*)&tun[1];

        tun->proto = htons(ETH_P_IPV6);
        prepare_ipv6_packet(payload,
                            payload_length,
                            IPPROTO_UDP,
                            NULL,
                            source_address,
                            destination_address,
                            ipv6);
      }
      break;

      default:
        GNUNET_assert(0);
        break;
      }
    if (NULL != helper_handle)
      (void)GNUNET_HELPER_send(helper_handle,
                               (const struct GNUNET_MessageHeader*)buf,
                               GNUNET_YES,
                               NULL, NULL);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_udp_remote()

static int check_udp_remote ( void *  cls, const struct GNUNET_EXIT_UdpInternetMessage *  msg  )

static

Check a request to forward UDP data to the Internet via this peer.

Parameters

cls	our struct ChannelState *
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 1434 of file gnunet-daemon-exit.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, and state.

{
  struct ChannelState *state = cls;

  if (GNUNET_YES == state->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_udp_remote()

static void handle_udp_remote ( void *  cls, const struct GNUNET_EXIT_UdpInternetMessage *  msg  )

static

Process a request to forward UDP data to the Internet via this peer.

Parameters

cls	our struct ChannelState *
msg	the actual message

Definition at line 1455 of file gnunet-daemon-exit.c.

References SocketAddress::af, GNUNET_EXIT_UdpInternetMessage::af, buf, ChannelState::channel, GNUNET_EXIT_UdpInternetMessage::destination_port, gettext_noop, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_EXIT_UdpInternetMessage::header, ipv4_exit, ipv6_exit, ChannelState::is_dns, payload, ChannelState::peer, send_udp_packet_via_tun(), setup_state_record(), GNUNET_MessageHeader::size, GNUNET_EXIT_UdpInternetMessage::source_port, ChannelState::specifics, state, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_UdpInternetMessage);
  const struct in_addr *v4;
  const struct in6_addr *v6;
  const void *payload;
  int af;

  if (GNUNET_SYSERR == state->is_dns)
    {
      /* channel is UDP/TCP from now on */
      state->is_dns = GNUNET_NO;
    }
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len, GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# UDP IP-exit requests received via cadet"),
                           1, GNUNET_NO);
  af = (int)ntohl(msg->af);
  state->specifics.tcp_udp.ri.remote_address.af = af;
  switch (af)
    {
    case AF_INET:
      if (pkt_len < sizeof(struct in_addr))
        {
          GNUNET_break_op(0);
          return;
        }
      if (!ipv4_exit)
        {
          GNUNET_break_op(0);
          return;
        }
      v4 = (const struct in_addr*)&msg[1];
      payload = &v4[1];
      pkt_len -= sizeof(struct in_addr);
      state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
      break;

    case AF_INET6:
      if (pkt_len < sizeof(struct in6_addr))
        {
          GNUNET_break_op(0);
          return;
        }
      if (!ipv6_exit)
        {
          GNUNET_break_op(0);
          return;
        }
      v6 = (const struct in6_addr*)&msg[1];
      payload = &v6[1];
      pkt_len -= sizeof(struct in6_addr);
      state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
      break;

    default:
      GNUNET_break_op(0);
      return;
    }
  {
    char buf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received data from %s for forwarding to UDP %s:%u\n",
               GNUNET_i2s(&state->peer),
               inet_ntop(af,
                         &state->specifics.tcp_udp.ri.remote_address.address,
                         buf, sizeof(buf)),
               (unsigned int)ntohs(msg->destination_port));
  }
  state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_UDP;
  state->specifics.tcp_udp.ri.remote_address.port = msg->destination_port;
  if (NULL == state->specifics.tcp_udp.heap_node)
    setup_state_record(state);
  if (0 != ntohs(msg->source_port))
    state->specifics.tcp_udp.ri.local_address.port = msg->source_port;
  send_udp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                          &state->specifics.tcp_udp.ri.local_address,
                          payload,
                          pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

check_udp_service()

static int check_udp_service ( void *  cls, const struct GNUNET_EXIT_UdpServiceMessage *  msg  )

static

Check a request via cadet to send a request to a UDP service offered by this system.

Parameters

cls	our struct ChannelState *
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 1552 of file gnunet-daemon-exit.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, ChannelState::specifics, state, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;

  if (NULL == state->specifics.tcp_udp.serv)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_udp_service()

static void handle_udp_service ( void *  cls, const struct GNUNET_EXIT_UdpServiceMessage *  msg  )

static

Process a request via cadet to send a request to a UDP service offered by this system.

Parameters

cls	our struct ChannelState *
msg	the actual message

Definition at line 1574 of file gnunet-daemon-exit.c.

References ChannelState::channel, GNUNET_EXIT_UdpServiceMessage::destination_port, gettext_noop, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_EXIT_UdpServiceMessage::header, LOG, ChannelState::peer, send_udp_packet_via_tun(), setup_state_record(), GNUNET_MessageHeader::size, GNUNET_EXIT_UdpServiceMessage::source_port, ChannelState::specifics, state, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_UdpServiceMessage);

  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len, GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# UDP service requests received via cadet"),
                           1, GNUNET_NO);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Received data from %s for forwarding to UDP service %s on port %u\n",
      GNUNET_i2s(&state->peer),
      GNUNET_h2s(&state->specifics.tcp_udp.serv->descriptor),
      (unsigned int)ntohs(msg->destination_port));
  setup_state_record(state);
  if (0 != ntohs(msg->source_port))
    state->specifics.tcp_udp.ri.local_address.port = msg->source_port;
  send_udp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                          &state->specifics.tcp_udp.ri.local_address,
                          &msg[1],
                          pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

handle_tcp_service()

static void handle_tcp_service ( void *  cls, const struct GNUNET_EXIT_TcpServiceStartMessage *  start  )

static

Process a request via cadet to send a request to a TCP service offered by this system.

Parameters

cls	our struct ChannelState *
start	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 1612 of file gnunet-daemon-exit.c.

References ChannelState::channel, GNUNET_TUN_TcpHeader::destination_port, gettext_noop, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_EXIT_TcpServiceStartMessage::header, ChannelState::is_dns, ChannelState::peer, GNUNET_EXIT_TcpServiceStartMessage::reserved, send_tcp_packet_via_tun(), setup_state_record(), GNUNET_MessageHeader::size, ChannelState::specifics, state, GNUNET_EXIT_TcpServiceStartMessage::tcp_header, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(start->header.size) - sizeof(struct GNUNET_EXIT_TcpServiceStartMessage);

  if (GNUNET_SYSERR == state->is_dns)
    {
      /* channel is UDP/TCP from now on */
      state->is_dns = GNUNET_NO;
    }
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# TCP service creation requests received via cadet"),
                           1,
                           GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len,
                           GNUNET_NO);
  GNUNET_break_op(ntohl(start->reserved) == 0);
  /* setup fresh connection */
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Received data from %s for forwarding to TCP service %s on port %u\n",
             GNUNET_i2s(&state->peer),
             GNUNET_h2s(&state->specifics.tcp_udp.serv->descriptor),
             (unsigned int)ntohs(start->tcp_header.destination_port));
  setup_state_record(state);
  send_tcp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                          &state->specifics.tcp_udp.ri.local_address,
                          &start->tcp_header,
                          &start[1],
                          pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

check_tcp_remote()

static int check_tcp_remote ( void *  cls, const struct GNUNET_EXIT_TcpInternetStartMessage *  start  )

static

Check a request to forward TCP data to the Internet via this peer.

Parameters

cls	our struct ChannelState *
start	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 1657 of file gnunet-daemon-exit.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, GNUNET_TUN_TcpHeader::off, ChannelState::specifics, state, GNUNET_EXIT_TcpInternetStartMessage::tcp_header, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;

  if (NULL == state)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (GNUNET_YES == state->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if ((NULL != state->specifics.tcp_udp.serv) ||
      (NULL != state->specifics.tcp_udp.heap_node))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (start->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_tcp_remote()

static void handle_tcp_remote ( void *  cls, const struct GNUNET_EXIT_TcpInternetStartMessage *  start  )

static

Process a request to forward TCP data to the Internet via this peer.

Parameters

cls	our struct ChannelState *
start	the actual message

Definition at line 1694 of file gnunet-daemon-exit.c.

References GNUNET_EXIT_TcpInternetStartMessage::af, SocketAddress::af, buf, ChannelState::channel, GNUNET_TUN_TcpHeader::destination_port, gettext_noop, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_EXIT_TcpInternetStartMessage::header, ipv4_exit, ipv6_exit, ChannelState::is_dns, payload, ChannelState::peer, send_tcp_packet_via_tun(), setup_state_record(), GNUNET_MessageHeader::size, ChannelState::specifics, state, GNUNET_EXIT_TcpInternetStartMessage::tcp_header, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(start->header.size) - sizeof(struct GNUNET_EXIT_TcpInternetStartMessage);
  const struct in_addr *v4;
  const struct in6_addr *v6;
  const void *payload;
  int af;

  if (GNUNET_SYSERR == state->is_dns)
    {
      /* channel is UDP/TCP from now on */
      state->is_dns = GNUNET_NO;
    }
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len, GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# TCP IP-exit creation requests received via cadet"),
                           1, GNUNET_NO);
  af = (int)ntohl(start->af);
  state->specifics.tcp_udp.ri.remote_address.af = af;
  switch (af)
    {
    case AF_INET:
      if (pkt_len < sizeof(struct in_addr))
        {
          GNUNET_break_op(0);
          return;
        }
      if (!ipv4_exit)
        {
          GNUNET_break_op(0);
          return;
        }
      v4 = (const struct in_addr*)&start[1];
      payload = &v4[1];
      pkt_len -= sizeof(struct in_addr);
      state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
      break;

    case AF_INET6:
      if (pkt_len < sizeof(struct in6_addr))
        {
          GNUNET_break_op(0);
          return;
        }
      if (!ipv6_exit)
        {
          GNUNET_break_op(0);
          return;
        }
      v6 = (const struct in6_addr*)&start[1];
      payload = &v6[1];
      pkt_len -= sizeof(struct in6_addr);
      state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
      break;

    default:
      GNUNET_break_op(0);
      return;
    }
  {
    char buf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received payload from %s for existing TCP stream to %s:%u\n",
               GNUNET_i2s(&state->peer),
               inet_ntop(af,
                         &state->specifics.tcp_udp.ri.remote_address.address,
                         buf, sizeof(buf)),
               (unsigned int)ntohs(start->tcp_header.destination_port));
  }
  state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_TCP;
  state->specifics.tcp_udp.ri.remote_address.port = ntohs(start->tcp_header.destination_port);
  setup_state_record(state);
  send_tcp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                          &state->specifics.tcp_udp.ri.local_address,
                          &start->tcp_header,
                          payload,
                          pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

check_tcp_data()

static int check_tcp_data ( void *  cls, const struct GNUNET_EXIT_TcpDataMessage *  data  )

static

Check a request to forward TCP data on an established connection via this peer.

Parameters

cls	our struct ChannelState *
message	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 1789 of file gnunet-daemon-exit.c.

References gettext_noop, GNUNET_break_op, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, GNUNET_TUN_TcpHeader::off, ChannelState::specifics, state, GNUNET_EXIT_TcpDataMessage::tcp_header, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;

  if ((NULL == state) ||
      (NULL == state->specifics.tcp_udp.heap_node))
    {
      /* connection should have been up! */
      GNUNET_STATISTICS_update(stats,
                               gettext_noop("# TCP DATA requests dropped (no session)"),
                               1, GNUNET_NO);
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (data->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (GNUNET_YES == state->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

Here is the call graph for this function:

handle_tcp_data()

static void handle_tcp_data ( void *  cls, const struct GNUNET_EXIT_TcpDataMessage *  data  )

static

Process a request to forward TCP data on an established connection via this peer.

Parameters

cls	our struct ChannelState *
message	the actual message

Definition at line 1826 of file gnunet-daemon-exit.c.

References buf, ChannelState::channel, gettext_noop, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_EXIT_TcpDataMessage::header, ChannelState::is_dns, ChannelState::peer, GNUNET_EXIT_TcpDataMessage::reserved, send_tcp_packet_via_tun(), GNUNET_MessageHeader::size, ChannelState::specifics, state, GNUNET_EXIT_TcpDataMessage::tcp_header, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(data->header.size) - sizeof(struct GNUNET_EXIT_TcpDataMessage);

  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len, GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# TCP data requests received via cadet"),
                           1, GNUNET_NO);
  if (GNUNET_SYSERR == state->is_dns)
    {
      /* channel is UDP/TCP from now on */
      state->is_dns = GNUNET_NO;
    }

  GNUNET_break_op(ntohl(data->reserved) == 0);
  {
    char buf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received additional %u bytes of data from %s for TCP stream to %s:%u\n",
               pkt_len,
               GNUNET_i2s(&state->peer),
               inet_ntop(state->specifics.tcp_udp.ri.remote_address.af,
                         &state->specifics.tcp_udp.ri.remote_address.address,
                         buf, sizeof(buf)),
               (unsigned int)state->specifics.tcp_udp.ri.remote_address.port);
  }

  send_tcp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                          &state->specifics.tcp_udp.ri.local_address,
                          &data->tcp_header,
                          &data[1], pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

make_up_icmpv4_payload()

static void make_up_icmpv4_payload ( struct ChannelState *  state, struct GNUNET_TUN_IPv4Header *  ipp, struct GNUNET_TUN_UdpHeader *  udp  )

static

Synthesize a plausible ICMP payload for an ICMPv4 error response on the given channel.

Parameters

state	channel information
ipp	IPv6 header to fill in (ICMP payload)
udp	"UDP" header to fill in (ICMP payload); might actually also be the first 8 bytes of the TCP header

Definition at line 1875 of file gnunet-daemon-exit.c.

References GNUNET_TUN_UdpHeader::crc, GNUNET_TUN_UdpHeader::destination_port, GNUNET_TUN_initialize_ipv4_header(), GNUNET_TUN_UdpHeader::len, GNUNET_TUN_UdpHeader::source_port, ChannelState::specifics, and ChannelState::tcp_udp.

Referenced by handle_icmp_remote(), and make_up_icmp_service_payload().

{
  GNUNET_TUN_initialize_ipv4_header(ipp,
                                    state->specifics.tcp_udp.ri.remote_address.proto,
                                    sizeof(struct GNUNET_TUN_TcpHeader),
                                    &state->specifics.tcp_udp.ri.remote_address.address.ipv4,
                                    &state->specifics.tcp_udp.ri.local_address.address.ipv4);
  udp->source_port = htons(state->specifics.tcp_udp.ri.remote_address.port);
  udp->destination_port = htons(state->specifics.tcp_udp.ri.local_address.port);
  udp->len = htons(0);
  udp->crc = htons(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_up_icmpv6_payload()

static void make_up_icmpv6_payload ( struct ChannelState *  state, struct GNUNET_TUN_IPv6Header *  ipp, struct GNUNET_TUN_UdpHeader *  udp  )

static

Synthesize a plausible ICMP payload for an ICMPv6 error response on the given channel.

Parameters

state	channel information
ipp	IPv6 header to fill in (ICMP payload)
udp	"UDP" header to fill in (ICMP payload); might actually also be the first 8 bytes of the TCP header

Definition at line 1901 of file gnunet-daemon-exit.c.

References GNUNET_TUN_UdpHeader::crc, GNUNET_TUN_UdpHeader::destination_port, GNUNET_TUN_initialize_ipv6_header(), GNUNET_TUN_UdpHeader::len, GNUNET_TUN_UdpHeader::source_port, ChannelState::specifics, and ChannelState::tcp_udp.

Referenced by handle_icmp_remote(), and make_up_icmp_service_payload().

{
  GNUNET_TUN_initialize_ipv6_header(ipp,
                                    state->specifics.tcp_udp.ri.remote_address.proto,
                                    sizeof(struct GNUNET_TUN_TcpHeader),
                                    &state->specifics.tcp_udp.ri.remote_address.address.ipv6,
                                    &state->specifics.tcp_udp.ri.local_address.address.ipv6);
  udp->source_port = htons(state->specifics.tcp_udp.ri.remote_address.port);
  udp->destination_port = htons(state->specifics.tcp_udp.ri.local_address.port);
  udp->len = htons(0);
  udp->crc = htons(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_icmp_remote()

static int check_icmp_remote ( void *  cls, const struct GNUNET_EXIT_IcmpInternetMessage *  msg  )

static

Check a request to forward ICMP data to the Internet via this peer.

Parameters

cls	our struct ChannelState *
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 1926 of file gnunet-daemon-exit.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, and state.

{
  struct ChannelState *state = cls;

  if (GNUNET_YES == state->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_icmp_remote()

static void handle_icmp_remote ( void *  cls, const struct GNUNET_EXIT_IcmpInternetMessage *  msg  )

static

Process a request to forward ICMP data to the Internet via this peer.

Parameters

cls	our struct ChannelState *
msg	the actual message

Definition at line 1947 of file gnunet-daemon-exit.c.

References SocketAddress::af, GNUNET_EXIT_IcmpInternetMessage::af, buf, ChannelState::channel, gettext_noop, GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE, GNUNET_TUN_ICMPTYPE6_ECHO_REPLY, GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST, GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG, GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM, GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED, GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE, GNUNET_TUN_ICMPTYPE_ECHO_REPLY, GNUNET_TUN_ICMPTYPE_ECHO_REQUEST, GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH, GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED, GNUNET_EXIT_IcmpInternetMessage::header, GNUNET_EXIT_IcmpInternetMessage::icmp_header, ipv4_exit, ipv6_exit, ChannelState::is_dns, make_up_icmpv4_payload(), make_up_icmpv6_payload(), payload, ChannelState::peer, send_icmp_packet_via_tun(), setup_state_record(), GNUNET_MessageHeader::size, ChannelState::specifics, state, ChannelState::tcp_udp, GNUNET_TUN_IcmpHeader::type, and udp.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_IcmpInternetMessage);
  const struct in_addr *v4;
  const struct in6_addr *v6;
  const void *payload;
  char buf[sizeof(struct GNUNET_TUN_IPv6Header) + 8] GNUNET_ALIGN;
  int af;

  if (GNUNET_SYSERR == state->is_dns)
    {
      /* channel is UDP/TCP from now on */
      state->is_dns = GNUNET_NO;
    }
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len, GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# ICMP IP-exit requests received via cadet"),
                           1, GNUNET_NO);

  af = (int)ntohl(msg->af);
  if ((NULL != state->specifics.tcp_udp.heap_node) &&
      (af != state->specifics.tcp_udp.ri.remote_address.af))
    {
      /* other peer switched AF on this channel; not allowed */
      GNUNET_break_op(0);
      return;
    }

  switch (af)
    {
    case AF_INET:
      if (pkt_len < sizeof(struct in_addr))
        {
          GNUNET_break_op(0);
          return;
        }
      if (!ipv4_exit)
        {
          GNUNET_break_op(0);
          return;
        }
      v4 = (const struct in_addr*)&msg[1];
      payload = &v4[1];
      pkt_len -= sizeof(struct in_addr);
      state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
      if (NULL == state->specifics.tcp_udp.heap_node)
        {
          state->specifics.tcp_udp.ri.remote_address.af = af;
          state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_ICMP;
          setup_state_record(state);
        }
      /* check that ICMP type is something we want to support
         and possibly make up payload! */
      switch (msg->icmp_header.type)
        {
        case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
        case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
          break;

        case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
        case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
        case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          /* make up payload */
          {
            struct GNUNET_TUN_IPv4Header *ipp = (struct GNUNET_TUN_IPv4Header *)buf;
            struct GNUNET_TUN_UdpHeader *udp = (struct GNUNET_TUN_UdpHeader *)&ipp[1];

            GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
            pkt_len = sizeof(struct GNUNET_TUN_IPv4Header) + 8;
            make_up_icmpv4_payload(state,
                                   ipp,
                                   udp);
            payload = ipp;
          }
          break;

        default:
          GNUNET_break_op(0);
          GNUNET_STATISTICS_update(stats,
                                   gettext_noop("# ICMPv4 packets dropped (type not allowed)"),
                                   1, GNUNET_NO);
          return;
        }
      /* end AF_INET */
      break;

    case AF_INET6:
      if (pkt_len < sizeof(struct in6_addr))
        {
          GNUNET_break_op(0);
          return;
        }
      if (!ipv6_exit)
        {
          GNUNET_break_op(0);
          return;
        }
      v6 = (const struct in6_addr*)&msg[1];
      payload = &v6[1];
      pkt_len -= sizeof(struct in6_addr);
      state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
      if (NULL == state->specifics.tcp_udp.heap_node)
        {
          state->specifics.tcp_udp.ri.remote_address.af = af;
          state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_ICMPV6;
          setup_state_record(state);
        }
      /* check that ICMP type is something we want to support
         and possibly make up payload! */
      switch (msg->icmp_header.type)
        {
        case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
        case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
          break;

        case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
        case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
        case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
        case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          /* make up payload */
          {
            struct GNUNET_TUN_IPv6Header *ipp = (struct GNUNET_TUN_IPv6Header *)buf;
            struct GNUNET_TUN_UdpHeader *udp = (struct GNUNET_TUN_UdpHeader *)&ipp[1];

            GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
            pkt_len = sizeof(struct GNUNET_TUN_IPv6Header) + 8;
            make_up_icmpv6_payload(state,
                                   ipp,
                                   udp);
            payload = ipp;
          }
          break;

        default:
          GNUNET_break_op(0);
          GNUNET_STATISTICS_update(stats,
                                   gettext_noop("# ICMPv6 packets dropped (type not allowed)"),
                                   1, GNUNET_NO);
          return;
        }
      /* end AF_INET6 */
      break;

    default:
      /* bad AF */
      GNUNET_break_op(0);
      return;
    }

  {
    char buf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received ICMP data from %s for forwarding to %s\n",
               GNUNET_i2s(&state->peer),
               inet_ntop(af,
                         &state->specifics.tcp_udp.ri.remote_address.address,
                         buf, sizeof(buf)));
  }
  send_icmp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                           &state->specifics.tcp_udp.ri.local_address,
                           &msg->icmp_header,
                           payload, pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

make_up_icmp_service_payload()

static uint16_t make_up_icmp_service_payload ( struct ChannelState *  state, char *  buf  )

static

Setup ICMP payload for ICMP error messages.

Called for both IPv4 and IPv6 addresses.

Parameters

state	context for creating the IP Packet
buf	where to create the payload, has at least sizeof (struct GNUNET_TUN_IPv6Header) + 8 bytes

Returns

number of bytes of payload we created in buf

Definition at line 2137 of file gnunet-daemon-exit.c.

References GNUNET_assert, GNUNET_break, SocketAddress::ipv4, SocketAddress::ipv6, make_up_icmpv4_payload(), make_up_icmpv6_payload(), ChannelState::specifics, ChannelState::tcp_udp, and udp.

Referenced by handle_icmp_service().

{
  switch (state->specifics.tcp_udp.serv->address.af)
    {
    case AF_INET:
    {
      struct GNUNET_TUN_IPv4Header *ipv4;
      struct GNUNET_TUN_UdpHeader *udp;

      ipv4 = (struct GNUNET_TUN_IPv4Header *)buf;
      udp = (struct GNUNET_TUN_UdpHeader *)&ipv4[1];
      make_up_icmpv4_payload(state,
                             ipv4,
                             udp);
      GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
      return sizeof(struct GNUNET_TUN_IPv4Header) + 8;
    }
    break;

    case AF_INET6:
    {
      struct GNUNET_TUN_IPv6Header *ipv6;
      struct GNUNET_TUN_UdpHeader *udp;

      ipv6 = (struct GNUNET_TUN_IPv6Header *)buf;
      udp = (struct GNUNET_TUN_UdpHeader *)&ipv6[1];
      make_up_icmpv6_payload(state,
                             ipv6,
                             udp);
      GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
      return sizeof(struct GNUNET_TUN_IPv6Header) + 8;
    }
    break;

    default:
      GNUNET_break(0);
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_icmp_service()

static int check_icmp_service ( void *  cls, const struct GNUNET_EXIT_IcmpServiceMessage *  msg  )

static

Check a request via cadet to send ICMP data to a service offered by this system.

Parameters

cls	our struct ChannelState *
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 2189 of file gnunet-daemon-exit.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, ChannelState::specifics, state, and ChannelState::tcp_udp.

{
  struct ChannelState *state = cls;

  if (GNUNET_YES == state->is_dns)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (NULL == state->specifics.tcp_udp.serv)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_icmp_service()

static void handle_icmp_service ( void *  cls, const struct GNUNET_EXIT_IcmpServiceMessage *  msg  )

static

Process a request via cadet to send ICMP data to a service offered by this system.

Parameters

cls	our struct ChannelState *
msg	the actual message

Definition at line 2216 of file gnunet-daemon-exit.c.

References GNUNET_EXIT_IcmpServiceMessage::af, buf, ChannelState::channel, gettext_noop, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE, GNUNET_TUN_ICMPTYPE6_ECHO_REPLY, GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST, GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG, GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM, GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED, GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE, GNUNET_TUN_ICMPTYPE_ECHO_REPLY, GNUNET_TUN_ICMPTYPE_ECHO_REQUEST, GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH, GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED, GNUNET_EXIT_IcmpServiceMessage::header, GNUNET_EXIT_IcmpServiceMessage::icmp_header, make_up_icmp_service_payload(), payload, ChannelState::peer, send_icmp_packet_via_tun(), setup_state_record(), GNUNET_MessageHeader::size, ChannelState::specifics, state, ChannelState::tcp_udp, and GNUNET_TUN_IcmpHeader::type.

{
  struct ChannelState *state = cls;
  uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_IcmpServiceMessage);
  struct GNUNET_TUN_IcmpHeader icmp;
  char buf[sizeof(struct GNUNET_TUN_IPv6Header) + 8] GNUNET_ALIGN;
  const void *payload;

  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from CADET"),
                           pkt_len, GNUNET_NO);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# ICMP service requests received via cadet"),
                           1, GNUNET_NO);
  /* check that we got at least a valid header */
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Received data from %s for forwarding to ICMP service %s\n",
             GNUNET_i2s(&state->peer),
             GNUNET_h2s(&state->specifics.tcp_udp.serv->descriptor));
  icmp = msg->icmp_header;
  payload = &msg[1];
  state->specifics.tcp_udp.ri.remote_address
    = state->specifics.tcp_udp.serv->address;
  setup_state_record(state);

  /* check that ICMP type is something we want to support,
     perform ICMP PT if needed ans possibly make up payload */
  switch (msg->af)
    {
    case AF_INET:
      switch (msg->icmp_header.type)
        {
        case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
            icmp.type = GNUNET_TUN_ICMPTYPE6_ECHO_REPLY;
          break;

        case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
            icmp.type = GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST;
          break;

        case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
            icmp.type = GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE;
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          payload = buf;
          pkt_len = make_up_icmp_service_payload(state, buf);
          break;

        case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
            icmp.type = GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED;
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          payload = buf;
          pkt_len = make_up_icmp_service_payload(state, buf);
          break;

        case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
            {
              GNUNET_STATISTICS_update(stats,
                                       gettext_noop("# ICMPv4 packets dropped (impossible PT to v6)"),
                                       1, GNUNET_NO);
              return;
            }
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          payload = buf;
          pkt_len = make_up_icmp_service_payload(state, buf);
          break;

        default:
          GNUNET_break_op(0);
          GNUNET_STATISTICS_update(stats,
                                   gettext_noop("# ICMPv4 packets dropped (type not allowed)"),
                                   1, GNUNET_NO);
          return;
        }
      /* end of AF_INET */
      break;

    case AF_INET6:
      switch (msg->icmp_header.type)
        {
        case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET)
            icmp.type = GNUNET_TUN_ICMPTYPE_ECHO_REPLY;
          break;

        case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET)
            icmp.type = GNUNET_TUN_ICMPTYPE_ECHO_REQUEST;
          break;

        case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET)
            icmp.type = GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE;
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          payload = buf;
          pkt_len = make_up_icmp_service_payload(state, buf);
          break;

        case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET)
            icmp.type = GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED;
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          payload = buf;
          pkt_len = make_up_icmp_service_payload(state, buf);
          break;

        case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
        case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
          if (state->specifics.tcp_udp.serv->address.af == AF_INET)
            {
              GNUNET_STATISTICS_update(stats,
                                       gettext_noop("# ICMPv6 packets dropped (impossible PT to v4)"),
                                       1, GNUNET_NO);
              return;
            }
          if (0 != pkt_len)
            {
              GNUNET_break_op(0);
              return;
            }
          payload = buf;
          pkt_len = make_up_icmp_service_payload(state, buf);
          break;

        default:
          GNUNET_break_op(0);
          GNUNET_STATISTICS_update(stats,
                                   gettext_noop("# ICMPv6 packets dropped (type not allowed)"),
                                   1, GNUNET_NO);
          return;
        }
      /* end of AF_INET6 */
      break;

    default:
      GNUNET_break_op(0);
      return;
    }

  send_icmp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address,
                           &state->specifics.tcp_udp.ri.local_address,
                           &icmp,
                           payload,
                           pkt_len);
  GNUNET_CADET_receive_done(state->channel);
}

Here is the call graph for this function:

free_service_record()

static int free_service_record ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Free memory associated with a service record.

Parameters

cls	unused
key	service descriptor
value	service record to free

Returns

GNUNET_OK

Definition at line 2398 of file gnunet-daemon-exit.c.

References GNUNET_assert, GNUNET_CADET_close_port(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_free_non_null, GNUNET_OK, GNUNET_YES, LocalService::name, LocalService::port, service, and value.

Referenced by cleanup().

{
  struct LocalService *service = value;

  GNUNET_assert(GNUNET_YES ==
                GNUNET_CONTAINER_multihashmap_remove(services,
                                                     key,
                                                     service));
  GNUNET_CADET_close_port(service->port);
  GNUNET_free_non_null(service->name);
  GNUNET_free(service);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

new_service_channel()

static void* new_service_channel ( void *  cls, struct GNUNET_CADET_Channel *  channel, const struct GNUNET_PeerIdentity *  initiator  )

static

Callback from CADET for new channels.

Parameters

cls	closure
channel	new handle to the channel
initiator	peer that started the channel

Returns

initial channel context for the channel

Definition at line 2424 of file gnunet-daemon-exit.c.

References LocalService::address, ChannelState::channel, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), ls, ChannelState::peer, ChannelState::specifics, and ChannelState::tcp_udp.

Referenced by store_service().

{
  struct LocalService *ls = cls;
  struct ChannelState *s = GNUNET_new(struct ChannelState);

  s->peer = *initiator;
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Inbound CADET channels created"),
                           1,
                           GNUNET_NO);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Received inbound channel from `%s'\n",
             GNUNET_i2s(initiator));
  s->channel = channel;
  s->specifics.tcp_udp.serv = ls;
  s->specifics.tcp_udp.ri.remote_address = ls->address;
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

clean_channel()

static void clean_channel ( void *  cls, const struct GNUNET_CADET_Channel *  channel  )

static

Function called by cadet whenever an inbound channel is destroyed.

Should clean up any associated state.

Parameters

cls	our struct ChannelState *
channel	connection to the other end (henceforth invalid)

Definition at line 2454 of file gnunet-daemon-exit.c.

References ChannelState::dns, GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SYSERR, GNUNET_YES, ChannelState::is_dns, LOG, ChannelState::specifics, and ChannelState::tcp_udp.

Referenced by advertise_dns_exit(), run(), and store_service().

{
  struct ChannelState *s = cls;

  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Channel destroyed\n");
  if (GNUNET_SYSERR == s->is_dns)
    {
      GNUNET_free(s);
      return;
    }
  if (GNUNET_YES == s->is_dns)
    {
      if (channels[s->specifics.dns.my_id] == s)
        channels[s->specifics.dns.my_id] = NULL;
    }
  else
    {
      if (NULL != s->specifics.tcp_udp.heap_node)
        {
          GNUNET_assert(GNUNET_YES ==
                        GNUNET_CONTAINER_multihashmap_remove(connections_map,
                                                             &s->specifics.tcp_udp.state_key,
                                                             s));
          GNUNET_CONTAINER_heap_remove_node(s->specifics.tcp_udp.heap_node);
          s->specifics.tcp_udp.heap_node = NULL;
        }
    }
  GNUNET_free(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

store_service()

static void store_service ( int  proto, const char *  name, uint16_t  destination_port, struct LocalService *  service  )

static

Given a service descriptor and a destination port, find the respective service entry.

Parameters

proto	IPPROTO_TCP or IPPROTO_UDP
name	name of the service
destination_port	destination port
service	service information record to store (service->name will be set).

Definition at line 2497 of file gnunet-daemon-exit.c.

References _, clean_channel(), LocalService::descriptor, GNUNET_CADET_close_port(), GNUNET_CADET_open_port(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE, GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT, GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START, GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_strdup, GNUNET_TUN_compute_service_cadet_port(), GNUNET_TUN_service_name_to_hash(), LocalService::is_udp, LocalService::name, new_service_channel(), LocalService::port, and SocketAddress::proto.

Referenced by add_services().

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size(icmp_service,
                          GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE,
                          struct GNUNET_EXIT_IcmpServiceMessage,
                          service),
    GNUNET_MQ_hd_var_size(udp_service,
                          GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE,
                          struct GNUNET_EXIT_UdpServiceMessage,
                          service),
    GNUNET_MQ_hd_var_size(tcp_service,
                          GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START,
                          struct GNUNET_EXIT_TcpServiceStartMessage,
                          service),
    GNUNET_MQ_hd_var_size(tcp_data,
                          GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT,
                          struct GNUNET_EXIT_TcpDataMessage,
                          service),
    GNUNET_MQ_handler_end()
  };

  struct GNUNET_HashCode cadet_port;

  service->name = GNUNET_strdup(name);
  GNUNET_TUN_service_name_to_hash(name,
                                  &service->descriptor);
  GNUNET_TUN_compute_service_cadet_port(&service->descriptor,
                                        destination_port,
                                        &cadet_port);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Opening CADET port %s for SERVICE exit %s on port %u\n",
             GNUNET_h2s(&cadet_port),
             name,
             (unsigned int)destination_port);
  service->port = GNUNET_CADET_open_port(cadet_handle,
                                         &cadet_port,
                                         &new_service_channel,
                                         service,
                                         NULL,
                                         &clean_channel,
                                         handlers);
  service->is_udp = (IPPROTO_UDP == proto);
  if (GNUNET_OK !=
      GNUNET_CONTAINER_multihashmap_put(services,
                                        &cadet_port,
                                        service,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_CADET_close_port(service->port);
      GNUNET_free_non_null(service->name);
      GNUNET_free(service);
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 _("Got duplicate service records for `%s:%u'\n"),
                 name,
                 (unsigned int)destination_port);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_packet_to_cadet_channel()

static void send_packet_to_cadet_channel ( struct ChannelState *  s, struct GNUNET_MQ_Envelope *  env  )

static

Send the given packet via the cadet channel.

Parameters

s	channel destination
env	message to queue

Definition at line 2567 of file gnunet-daemon-exit.c.

References ChannelState::channel, gettext_noop, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_MQ_send(), GNUNET_NO, and GNUNET_STATISTICS_update().

Referenced by icmp_from_helper(), tcp_from_helper(), and udp_from_helper().

{
  GNUNET_assert(NULL != s);
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Messages transmitted via cadet channels"),
                           1,
                           GNUNET_NO);
  GNUNET_MQ_send(GNUNET_CADET_get_mq(s->channel),
                 env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

icmp_from_helper()

static void icmp_from_helper ( const struct GNUNET_TUN_IcmpHeader *  icmp, size_t  pktlen, int  af, const void *  destination_ip, const void *  source_ip  )

static

Handles an ICMP packet received from the helper.

Parameters

icmp	A pointer to the Packet
pktlen	number of bytes in icmp
af	address family (AFINET or AF_INET6)
destination_ip	destination IP-address of the IP packet (should be our local address)
source_ip	original source IP-address of the IP packet (should be the original destination address)

Definition at line 2592 of file gnunet-daemon-exit.c.

References _, GNUNET_EXIT_IcmpToVPNMessage::af, GNUNET_TUN_UdpHeader::destination_port, env, get_redirect_state(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN, GNUNET_MQ_msg_extra, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE, GNUNET_TUN_ICMPTYPE6_ECHO_REPLY, GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST, GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG, GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM, GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED, GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE, GNUNET_TUN_ICMPTYPE_ECHO_REPLY, GNUNET_TUN_ICMPTYPE_ECHO_REQUEST, GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH, GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED, GNUNET_EXIT_IcmpToVPNMessage::icmp_header, SocketAddress::ipv4, SocketAddress::ipv6, GNUNET_TUN_IPv6Header::next_header, GNUNET_TUN_IPv4Header::protocol, send_packet_to_cadet_channel(), GNUNET_TUN_UdpHeader::source_port, state, GNUNET_TUN_IcmpHeader::type, and udp.

Referenced by message_token().

{
  struct ChannelState *state;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_EXIT_IcmpToVPNMessage *i2v;
  const struct GNUNET_TUN_IPv4Header *ipv4;
  const struct GNUNET_TUN_IPv6Header *ipv6;
  const struct GNUNET_TUN_UdpHeader *udp;
  uint16_t source_port;
  uint16_t destination_port;
  uint8_t protocol;

  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received ICMP packet going from %s to %s\n",
               inet_ntop(af,
                         source_ip,
                         sbuf, sizeof(sbuf)),
               inet_ntop(af,
                         destination_ip,
                         dbuf, sizeof(dbuf)));
  }

  if (pktlen < sizeof(struct GNUNET_TUN_IcmpHeader))
    {
      /* blame kernel */
      GNUNET_break(0);
      return;
    }

  /* Find out if this is an ICMP packet in response to an existing
     TCP/UDP packet and if so, figure out ports / protocol of the
     existing session from the IP data in the ICMP payload */
  source_port = 0;
  destination_port = 0;
  switch (af)
    {
    case AF_INET:
      protocol = IPPROTO_ICMP;
      switch (icmp->type)
        {
        case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
        case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
          break;

        case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
        case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
        case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
          if (pktlen <
              sizeof(struct GNUNET_TUN_IcmpHeader) +
              sizeof(struct GNUNET_TUN_IPv4Header) + 8)
            {
              /* blame kernel */
              GNUNET_break(0);
              return;
            }
          ipv4 = (const struct GNUNET_TUN_IPv4Header *)&icmp[1];
          protocol = ipv4->protocol;
          /* could be TCP or UDP, but both have the ports in the right
             place, so that doesn't matter here */
          udp = (const struct GNUNET_TUN_UdpHeader *)&ipv4[1];
          /* swap ports, as they are from the original message */
          destination_port = ntohs(udp->source_port);
          source_port = ntohs(udp->destination_port);
          /* throw away ICMP payload, won't be useful for the other side anyway */
          pktlen = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;

        default:
          GNUNET_STATISTICS_update(stats,
                                   gettext_noop("# ICMPv4 packets dropped (type not allowed)"),
                                   1, GNUNET_NO);
          return;
        }
      break;

    case AF_INET6:
      protocol = IPPROTO_ICMPV6;
      switch (icmp->type)
        {
        case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
        case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
        case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
        case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
          if (pktlen <
              sizeof(struct GNUNET_TUN_IcmpHeader) +
              sizeof(struct GNUNET_TUN_IPv6Header) + 8)
            {
              /* blame kernel */
              GNUNET_break(0);
              return;
            }
          ipv6 = (const struct GNUNET_TUN_IPv6Header *)&icmp[1];
          protocol = ipv6->next_header;
          /* could be TCP or UDP, but both have the ports in the right
             place, so that doesn't matter here */
          udp = (const struct GNUNET_TUN_UdpHeader *)&ipv6[1];
          /* swap ports, as they are from the original message */
          destination_port = ntohs(udp->source_port);
          source_port = ntohs(udp->destination_port);
          /* throw away ICMP payload, won't be useful for the other side anyway */
          pktlen = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;

        case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
        case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
          break;

        default:
          GNUNET_STATISTICS_update(stats,
                                   gettext_noop("# ICMPv6 packets dropped (type not allowed)"),
                                   1, GNUNET_NO);
          return;
        }
      break;

    default:
      GNUNET_assert(0);
    }
  switch (protocol)
    {
    case IPPROTO_ICMP:
      state = get_redirect_state(af,
                                 IPPROTO_ICMP,
                                 source_ip,
                                 0,
                                 destination_ip,
                                 0,
                                 NULL);
      break;

    case IPPROTO_ICMPV6:
      state = get_redirect_state(af,
                                 IPPROTO_ICMPV6,
                                 source_ip,
                                 0,
                                 destination_ip,
                                 0,
                                 NULL);
      break;

    case IPPROTO_UDP:
      state = get_redirect_state(af,
                                 IPPROTO_UDP,
                                 source_ip,
                                 source_port,
                                 destination_ip,
                                 destination_port,
                                 NULL);
      break;

    case IPPROTO_TCP:
      state = get_redirect_state(af,
                                 IPPROTO_TCP,
                                 source_ip,
                                 source_port,
                                 destination_ip,
                                 destination_port,
                                 NULL);
      break;

    default:
      GNUNET_STATISTICS_update(stats,
                               gettext_noop("# ICMP packets dropped (not allowed)"),
                               1,
                               GNUNET_NO);
      return;
    }
  if (NULL == state)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 _("ICMP Packet dropped, have no matching connection information\n"));
      return;
    }
  env = GNUNET_MQ_msg_extra(i2v,
                            pktlen - sizeof(struct GNUNET_TUN_IcmpHeader),
                            GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN);
  i2v->af = htonl(af);
  GNUNET_memcpy(&i2v->icmp_header,
                icmp,
                pktlen);
  send_packet_to_cadet_channel(state,
                               env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_from_helper()

static void udp_from_helper ( const struct GNUNET_TUN_UdpHeader *  udp, size_t  pktlen, int  af, const void *  destination_ip, const void *  source_ip  )

static

Handles an UDP packet received from the helper.

Parameters

udp	A pointer to the Packet
pktlen	number of bytes in 'udp'
af	address family (AFINET or AF_INET6)
destination_ip	destination IP-address of the IP packet (should be our local address)
source_ip	original source IP-address of the IP packet (should be the original destination address)

Definition at line 2796 of file gnunet-daemon-exit.c.

References _, GNUNET_EXIT_UdpReplyMessage::destination_port, GNUNET_TUN_UdpHeader::destination_port, env, get_redirect_state(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY, GNUNET_MQ_msg_extra, GNUNET_TUN_UdpHeader::len, send_packet_to_cadet_channel(), GNUNET_EXIT_UdpReplyMessage::source_port, GNUNET_TUN_UdpHeader::source_port, and state.

Referenced by message_token().

{
  struct ChannelState *state;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_EXIT_UdpReplyMessage *urm;

  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];

    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received UDP packet going from %s:%u to %s:%u\n",
               inet_ntop(af,
                         source_ip,
                         sbuf, sizeof(sbuf)),
               (unsigned int)ntohs(udp->source_port),
               inet_ntop(af,
                         destination_ip,
                         dbuf, sizeof(dbuf)),
               (unsigned int)ntohs(udp->destination_port));
  }

  if (pktlen < sizeof(struct GNUNET_TUN_UdpHeader))
    {
      /* blame kernel */
      GNUNET_break(0);
      return;
    }
  if (pktlen != ntohs(udp->len))
    {
      /* blame kernel */
      GNUNET_break(0);
      return;
    }
  state = get_redirect_state(af,
                             IPPROTO_UDP,
                             source_ip,
                             ntohs(udp->source_port),
                             destination_ip,
                             ntohs(udp->destination_port),
                             NULL);
  if (NULL == state)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 _("UDP Packet dropped, have no matching connection information\n"));
      return;
    }
  env = GNUNET_MQ_msg_extra(urm,
                            pktlen - sizeof(struct GNUNET_TUN_UdpHeader),
                            GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY);
  urm->source_port = htons(0);
  urm->destination_port = htons(0);
  GNUNET_memcpy(&urm[1],
                &udp[1],
                pktlen - sizeof(struct GNUNET_TUN_UdpHeader));
  send_packet_to_cadet_channel(state,
                               env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_from_helper()

static void tcp_from_helper ( const struct GNUNET_TUN_TcpHeader *  tcp, size_t  pktlen, int  af, const void *  destination_ip, const void *  source_ip  )

static

Handles a TCP packet received from the helper.

Parameters

tcp	A pointer to the Packet
pktlen	the length of the packet, including its TCP header
af	address family (AFINET or AF_INET6)
destination_ip	destination IP-address of the IP packet (should be our local address)
source_ip	original source IP-address of the IP packet (should be the original destination address)

Definition at line 2872 of file gnunet-daemon-exit.c.

References _, buf, GNUNET_TUN_TcpHeader::crc, GNUNET_TUN_TcpHeader::destination_port, env, get_redirect_state(), GNUNET_ALIGN, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN, GNUNET_MQ_msg_extra, GNUNET_EXIT_TcpDataMessage::reserved, send_packet_to_cadet_channel(), GNUNET_TUN_TcpHeader::source_port, state, and GNUNET_EXIT_TcpDataMessage::tcp_header.

Referenced by message_token().

{
  struct ChannelState *state;
  char buf[pktlen] GNUNET_ALIGN;
  struct GNUNET_TUN_TcpHeader *mtcp;
  struct GNUNET_EXIT_TcpDataMessage *tdm;
  struct GNUNET_MQ_Envelope *env;
  size_t mlen;

  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "Received TCP packet with %u bytes going from %s:%u to %s:%u\n",
               (unsigned int)(pktlen - sizeof(struct GNUNET_TUN_TcpHeader)),
               inet_ntop(af,
                         source_ip,
                         sbuf, sizeof(sbuf)),
               (unsigned int)ntohs(tcp->source_port),
               inet_ntop(af,
                         destination_ip,
                         dbuf, sizeof(dbuf)),
               (unsigned int)ntohs(tcp->destination_port));
  }

  if (pktlen < sizeof(struct GNUNET_TUN_TcpHeader))
    {
      /* blame kernel */
      GNUNET_break(0);
      return;
    }
  state = get_redirect_state(af,
                             IPPROTO_TCP,
                             source_ip,
                             ntohs(tcp->source_port),
                             destination_ip,
                             ntohs(tcp->destination_port),
                             NULL);
  if (NULL == state)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 _("TCP Packet dropped, have no matching connection information\n"));

      return;
    }
  /* mug port numbers and crc to avoid information leakage;
     sender will need to lookup the correct values anyway */
  GNUNET_memcpy(buf, tcp, pktlen);
  mtcp = (struct GNUNET_TUN_TcpHeader *)buf;
  mtcp->source_port = 0;
  mtcp->destination_port = 0;
  mtcp->crc = 0;

  mlen = sizeof(struct GNUNET_EXIT_TcpDataMessage) + (pktlen - sizeof(struct GNUNET_TUN_TcpHeader));
  if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  env = GNUNET_MQ_msg_extra(tdm,
                            pktlen - sizeof(struct GNUNET_TUN_TcpHeader),
                            GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN);
  tdm->reserved = htonl(0);
  GNUNET_memcpy(&tdm->tcp_header,
                buf,
                pktlen);
  send_packet_to_cadet_channel(state,
                               env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

message_token()

static int message_token ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Receive packets from the helper-process.

Parameters

cls	unused
message	message received from helper

Definition at line 2954 of file gnunet-daemon-exit.c.

References _, ETH_P_IPV4, ETH_P_IPV6, gettext_noop, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TUN_IPv4Header::header_length, icmp_from_helper(), GNUNET_TUN_IPv6Header::next_header, GNUNET_TUN_IPv6Header::payload_length, GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_TUN_IPv4Header::protocol, size, GNUNET_MessageHeader::size, tcp_from_helper(), GNUNET_TUN_IPv4Header::total_length, GNUNET_MessageHeader::type, and udp_from_helper().

Referenced by run().

{
  const struct GNUNET_TUN_Layer2PacketHeader *pkt_tun;
  size_t size;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Got %u-byte message of type %u from gnunet-helper-exit\n",
             ntohs(message->size),
             ntohs(message->type));
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Packets received from TUN"),
                           1, GNUNET_NO);
  if (ntohs(message->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
    {
      GNUNET_break(0);
      return GNUNET_OK;
    }
  size = ntohs(message->size);
  if (size < sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct GNUNET_MessageHeader))
    {
      GNUNET_break(0);
      return GNUNET_OK;
    }
  GNUNET_STATISTICS_update(stats,
                           gettext_noop("# Bytes received from TUN"),
                           size, GNUNET_NO);
  pkt_tun = (const struct GNUNET_TUN_Layer2PacketHeader *)&message[1];
  size -= sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct GNUNET_MessageHeader);
  switch (ntohs(pkt_tun->proto))
    {
    case ETH_P_IPV4:
    {
      const struct GNUNET_TUN_IPv4Header *pkt4;

      if (size < sizeof(struct GNUNET_TUN_IPv4Header))
        {
          /* Kernel to blame? */
          GNUNET_break(0);
          return GNUNET_OK;
        }
      pkt4 = (const struct GNUNET_TUN_IPv4Header *)&pkt_tun[1];
      if (size != ntohs(pkt4->total_length))
        {
          /* Kernel to blame? */
          GNUNET_break(0);
          return GNUNET_OK;
        }
      if (pkt4->header_length * 4 != sizeof(struct GNUNET_TUN_IPv4Header))
        {
          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                     _("IPv4 packet options received.  Ignored.\n"));
          return GNUNET_OK;
        }

      size -= sizeof(struct GNUNET_TUN_IPv4Header);
      switch (pkt4->protocol)
        {
        case IPPROTO_UDP:
          udp_from_helper((const struct GNUNET_TUN_UdpHeader *)&pkt4[1], size,
                          AF_INET,
                          &pkt4->destination_address,
                          &pkt4->source_address);
          break;

        case IPPROTO_TCP:
          tcp_from_helper((const struct GNUNET_TUN_TcpHeader *)&pkt4[1], size,
                          AF_INET,
                          &pkt4->destination_address,
                          &pkt4->source_address);
          break;

        case IPPROTO_ICMP:
          icmp_from_helper((const struct GNUNET_TUN_IcmpHeader *)&pkt4[1], size,
                           AF_INET,
                           &pkt4->destination_address,
                           &pkt4->source_address);
          break;

        default:
          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                     _("IPv4 packet with unsupported next header %u received.  Ignored.\n"),
                     (int)pkt4->protocol);
          return GNUNET_OK;
        }
    }
    break;

    case ETH_P_IPV6:
    {
      const struct GNUNET_TUN_IPv6Header *pkt6;

      if (size < sizeof(struct GNUNET_TUN_IPv6Header))
        {
          /* Kernel to blame? */
          GNUNET_break(0);
          return GNUNET_OK;
        }
      pkt6 = (struct GNUNET_TUN_IPv6Header *)&pkt_tun[1];
      if (size != ntohs(pkt6->payload_length) + sizeof(struct GNUNET_TUN_IPv6Header))
        {
          /* Kernel to blame? */
          GNUNET_break(0);
          return GNUNET_OK;
        }
      size -= sizeof(struct GNUNET_TUN_IPv6Header);
      switch (pkt6->next_header)
        {
        case IPPROTO_UDP:
          udp_from_helper((const struct GNUNET_TUN_UdpHeader *)&pkt6[1], size,
                          AF_INET6,
                          &pkt6->destination_address,
                          &pkt6->source_address);
          break;

        case IPPROTO_TCP:
          tcp_from_helper((const struct GNUNET_TUN_TcpHeader *)&pkt6[1], size,
                          AF_INET6,
                          &pkt6->destination_address,
                          &pkt6->source_address);
          break;

        case IPPROTO_ICMPV6:
          icmp_from_helper((const struct GNUNET_TUN_IcmpHeader *)&pkt6[1], size,
                           AF_INET6,
                           &pkt6->destination_address,
                           &pkt6->source_address);
          break;

        default:
          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                     _("IPv6 packet with unsupported next header %d received.  Ignored.\n"),
                     pkt6->next_header);
          return GNUNET_OK;
        }
    }
    break;

    default:
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 _("Packet from unknown protocol %u received.  Ignored.\n"),
                 ntohs(pkt_tun->proto));
      break;
    }
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

new_channel()

static void* new_channel ( void *  cls, struct GNUNET_CADET_Channel *  channel, const struct GNUNET_PeerIdentity *  initiator  )