gnunet-service-vpn.c File Reference

service that opens a virtual interface and allows its clients to allocate IPs on the virtual interface and to then redirect IP traffic received on those IPs via the GNUnet cadet More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_common.h"
#include "gnunet_protocols.h"
#include "gnunet_applications.h"
#include "gnunet_cadet_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_regex_service.h"
#include "vpn.h"
#include "exit.h"

Include dependency graph for gnunet-service-vpn.c:

Go to the source code of this file.

Data Structures
struct	DestinationChannel
	List of channels we keep for each destination port for a given destination entry. More...
struct	DestinationEntry
	Information we track for each IP address to determine which channel to send the traffic over to the destination. More...
struct	ChannelMessageQueueEntry
	A messages we have in queue for a particular channel. More...
struct	ChannelState
	This struct is saved into connections_map to allow finding the right channel given an IP packet from TUN. More...

Macros
#define	MAX_MESSAGE_QUEUE_SIZE   4
	Maximum number of messages we allow in the queue for cadet.

Functions
static void	get_destination_key_from_ip (int af, const void *address, struct GNUNET_HashCode *key)
	Compute the key under which we would store an entry in the destination_map for the given IP address.
static void	get_channel_key_from_ips (int af, uint8_t protocol, const void *source_ip, uint16_t source_port, const void *destination_ip, uint16_t destination_port, struct GNUNET_HashCode *key)
	Compute the key under which we would store an entry in the channel_map for the given socket address pair.
static void	send_client_reply (struct GNUNET_SERVICE_Client *client, uint64_t request_id, int result_af, const void *addr)
	Notify the client about the result of its request.
static void	free_channel_state (struct ChannelState *ts)
	Free resources associated with a channel state.
static void	send_to_channel (struct ChannelState *ts, struct GNUNET_MQ_Envelope *env)
	Add the given message to the given channel and trigger the transmission process.
static const char *	print_channel_destination (const struct DestinationEntry *de)
	Output destination of a channel for diagnostics.
static void	channel_cleaner (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called whenever a channel is destroyed.
static void	make_up_icmpv4_payload (struct ChannelState *ts, struct GNUNET_TUN_IPv4Header *ipp, struct GNUNET_TUN_UdpHeader *udp)
	Synthesize a plausible ICMP payload for an ICMP error response on the given channel.
static void	make_up_icmpv6_payload (struct ChannelState *ts, struct GNUNET_TUN_IPv6Header *ipp, struct GNUNET_TUN_UdpHeader *udp)
	Synthesize a plausible ICMP payload for an ICMP error response on the given channel.
static int	check_icmp_back (void *cls, const struct GNUNET_EXIT_IcmpToVPNMessage *i2v)
	We got an ICMP packet back from the CADET channel.
static void	handle_icmp_back (void *cls, const struct GNUNET_EXIT_IcmpToVPNMessage *i2v)
	We got an ICMP packet back from the CADET channel.
static int	check_udp_back (void *cls, const struct GNUNET_EXIT_UdpReplyMessage *reply)
	We got a UDP packet back from the CADET channel.
static void	handle_udp_back (void *cls, const struct GNUNET_EXIT_UdpReplyMessage *reply)
	We got a UDP packet back from the CADET channel.
static int	check_tcp_back (void *cls, const struct GNUNET_EXIT_TcpDataMessage *data)
	We got a TCP packet back from the CADET channel.
static void	handle_tcp_back (void *cls, const struct GNUNET_EXIT_TcpDataMessage *data)
	We got a TCP packet back from the CADET channel.
static struct GNUNET_CADET_Channel *	create_channel (struct ChannelState *ts, const struct GNUNET_PeerIdentity *target, const struct GNUNET_HashCode *port)
	Create a channel for ts to target at port.
static void	handle_regex_result (void *cls, const struct GNUNET_PeerIdentity *id, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int put_path_length)
	Regex has found a potential exit peer for us; consider using it.
static struct ChannelState *	create_channel_to_destination (struct DestinationChannel *dt, int client_af)
	Initialize the given destination entry's cadet channel.
static void	expire_channel (struct ChannelState *except)
	We have too many active channels.
static void	route_packet (struct DestinationEntry *destination, int af, uint8_t protocol, const void *source_ip, const void *destination_ip, const void *payload, size_t payload_length)
	Route a packet via cadet to the given destination.
static int	message_token (void *cls, const struct GNUNET_MessageHeader *message)
	Receive packets from the helper-process (someone send to the local virtual channel interface).
static int	allocate_v4_address (struct in_addr *v4)
	Allocate an IPv4 address from the range of the channel for a new redirection.
static int	allocate_v6_address (struct in6_addr *v6)
	Allocate an IPv6 address from the range of the channel for a new redirection.
static void	free_destination_entry (struct DestinationEntry *de)
	Free resources occupied by a destination entry.
static void	expire_destination (struct DestinationEntry *except)
	We have too many active destinations.
static int	allocate_response_ip (int *result_af, void **addr, struct in_addr *v4, struct in6_addr *v6)
	Allocate an IP address for the response.
static int	check_client_redirect_to_ip (void *cls, const struct RedirectToIpRequestMessage *msg)
	A client asks us to setup a redirection via some exit node to a particular IP.
static void	handle_client_redirect_to_ip (void *cls, const struct RedirectToIpRequestMessage *msg)
	A client asks us to setup a redirection via some exit node to a particular IP.
static void	handle_client_redirect_to_service (void *cls, const struct RedirectToServiceRequestMessage *msg)
	A client asks us to setup a redirection to a particular peer offering a service.
static int	cleanup_destination (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free memory occupied by an entry in the destination map.
static int	cleanup_channel (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free memory occupied by an entry in the channel map.
static void	cleanup (void *cls)
	Function scheduled as very last function, cleans up after us.
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
	Callback called when a client connects to the service.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
	Callback called when a client disconnected from the service.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg_, struct GNUNET_SERVICE_Handle *service)
	Main function that will be run by the scheduler.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "vpn", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(client_redirect_to_ip, GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_IP, struct RedirectToIpRequestMessage, NULL), GNUNET_MQ_hd_fixed_size(client_redirect_to_service, GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_SERVICE, struct RedirectToServiceRequestMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
static int	global_ret
	Return value from main().
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration we use.
static struct GNUNET_CADET_Handle *	cadet_handle
	Handle to the cadet service.
static struct GNUNET_CONTAINER_MultiHashMap *	destination_map
	Map from IP address to destination information (possibly with a CADET channel handle for fast setup).
static struct GNUNET_CONTAINER_Heap *	destination_heap
	Min-Heap sorted by activity time to expire old mappings.
static struct GNUNET_CONTAINER_MultiHashMap *	channel_map
	Map from source and destination address (IP+port) to connection information (mostly with the respective CADET channel handle).
static struct GNUNET_CONTAINER_Heap *	channel_heap
	Min-Heap sorted by activity time to expire old mappings; values are of type 'struct ChannelState'.
static struct GNUNET_STATISTICS_Handle *	stats
	Statistics.
static struct GNUNET_HELPER_Handle *	helper_handle
	The handle to the VPN helper process "gnunet-helper-vpn".
static char *	vpn_argv [7]
	Arguments to the vpn helper.
static unsigned long long	ipv6prefix
	Length of the prefix of the VPN's IPv6 network.
static unsigned long long	max_destination_mappings
	If there are more than this number of address-mappings, old ones will be removed.
static unsigned long long	max_channel_mappings
	If there are more than this number of open channels, old ones will be removed.

Detailed Description

service that opens a virtual interface and allows its clients to allocate IPs on the virtual interface and to then redirect IP traffic received on those IPs via the GNUnet cadet

Author

Philipp Toelke

Christian Grothoff

TODO:

• keep multiple peers/cadet channels ready as alternative exits / detect & recover from channel-to-exit failure gracefully

Definition in file gnunet-service-vpn.c.

Macro Definition Documentation

MAX_MESSAGE_QUEUE_SIZE

#define MAX_MESSAGE_QUEUE_SIZE   4

Maximum number of messages we allow in the queue for cadet.

Definition at line 48 of file gnunet-service-vpn.c.

Function Documentation

get_destination_key_from_ip()

static void get_destination_key_from_ip ( int  af, const void *  address, struct GNUNET_HashCode *  key  )

static

Compute the key under which we would store an entry in the destination_map for the given IP address.

Parameters

af	address family (AF_INET or AF_INET6)
address	IP address, struct in_addr or struct in6_addr
key	where to store the key

Definition at line 381 of file gnunet-service-vpn.c.

{
  switch (af)
  {
  case AF_INET:
    GNUNET_CRYPTO_hash (address, sizeof(struct in_addr), key);
    break;
 
  case AF_INET6:
    GNUNET_CRYPTO_hash (address, sizeof(struct in6_addr), key);
    break;
 
  default:
    GNUNET_assert (0);
    break;
  }
}

References address, GNUNET_assert, GNUNET_CRYPTO_hash(), and key.

Referenced by allocate_v4_address(), allocate_v6_address(), handle_client_redirect_to_ip(), handle_client_redirect_to_service(), and message_token().

Here is the call graph for this function:

Here is the caller graph for this function:

get_channel_key_from_ips()

static void get_channel_key_from_ips ( int  af, uint8_t  protocol, const void *  source_ip, uint16_t  source_port, const void *  destination_ip, uint16_t  destination_port, struct GNUNET_HashCode *  key  )

static

Compute the key under which we would store an entry in the channel_map for the given socket address pair.

Parameters

af	address family (AF_INET or AF_INET6)
protocol	IPPROTO_TCP or IPPROTO_UDP
source_ip	sender's source IP, struct in_addr or struct in6_addr
source_port	sender's source port
destination_ip	sender's destination IP, struct in_addr or struct in6_addr
destination_port	sender's destination port
key	where to store the key

Definition at line 415 of file gnunet-service-vpn.c.

{
  char *off;
 
  memset (key, 0, sizeof(struct GNUNET_HashCode));
  /* the GNUnet hashmap only uses the first sizeof(unsigned int) of the hash,
     so we put the ports in there (and hope for few collisions) */
  off = (char *) key;
  GNUNET_memcpy (off, &source_port, sizeof(uint16_t));
  off += sizeof(uint16_t);
  GNUNET_memcpy (off, &destination_port, sizeof(uint16_t));
  off += sizeof(uint16_t);
  switch (af)
  {
  case AF_INET:
    GNUNET_memcpy (off, source_ip, sizeof(struct in_addr));
    off += sizeof(struct in_addr);
    GNUNET_memcpy (off, destination_ip, sizeof(struct in_addr));
    off += sizeof(struct in_addr);
    break;
 
  case AF_INET6:
    GNUNET_memcpy (off, source_ip, sizeof(struct in6_addr));
    off += sizeof(struct in6_addr);
    GNUNET_memcpy (off, destination_ip, sizeof(struct in6_addr));
    off += sizeof(struct in6_addr);
    break;
 
  default:
    GNUNET_assert (0);
    break;
  }
  GNUNET_memcpy (off, &protocol, sizeof(uint8_t));
  /* off += sizeof (uint8_t);  */
}

References GNUNET_assert, GNUNET_memcpy, and key.

Referenced by free_channel_state(), and route_packet().

Here is the caller graph for this function:

send_client_reply()

static void send_client_reply ( struct GNUNET_SERVICE_Client *  client, uint64_t  request_id, int  result_af, const void *  addr  )

static

Notify the client about the result of its request.

Parameters

client	client to notify
request_id	original request ID to include in response
result_af	resulting address family
addr	resulting IP address

Definition at line 467 of file gnunet-service-vpn.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct RedirectToIpResponseMessage *res;
  size_t rlen;
 
  switch (result_af)
  {
  case AF_INET:
    rlen = sizeof(struct in_addr);
    break;
 
  case AF_INET6:
    rlen = sizeof(struct in6_addr);
    break;
 
  case AF_UNSPEC:
    rlen = 0;
    break;
 
  default:
    GNUNET_assert (0);
    return;
  }
  env = GNUNET_MQ_msg_extra (res, rlen, GNUNET_MESSAGE_TYPE_VPN_CLIENT_USE_IP);
  res->result_af = htonl (result_af);
  res->request_id = request_id;
  GNUNET_memcpy (&res[1], addr, rlen);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
}

References env, GNUNET_assert, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_CLIENT_USE_IP, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), res, and RedirectToIpResponseMessage::result_af.

Referenced by handle_client_redirect_to_ip(), and handle_client_redirect_to_service().

Here is the call graph for this function:

Here is the caller graph for this function:

free_channel_state()

static void free_channel_state ( struct ChannelState *  ts )

static

Free resources associated with a channel state.

Parameters

ts	state to free

Definition at line 508 of file gnunet-service-vpn.c.

{
  struct GNUNET_HashCode key;
  struct ChannelMessageQueueEntry *tnq;
  struct GNUNET_CADET_Channel *channel;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up channel state\n");
  if (NULL != (channel = ts->channel))
  {
    ts->channel = NULL;
    GNUNET_CADET_channel_destroy (channel);
    return;
  }
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# Active channels"),
                            -1,
                            GNUNET_NO);
  while (NULL != (tnq = ts->tmq_head))
  {
    GNUNET_CONTAINER_DLL_remove (ts->tmq_head, ts->tmq_tail, tnq);
    ts->tmq_length--;
    GNUNET_free (tnq);
  }
  GNUNET_assert (0 == ts->tmq_length);
  GNUNET_assert (NULL == ts->destination.heap_node);
  if (NULL != ts->search)
  {
    GNUNET_REGEX_search_cancel (ts->search);
    ts->search = NULL;
  }
  if (NULL != ts->heap_node)
  {
    GNUNET_CONTAINER_heap_remove_node (ts->heap_node);
    ts->heap_node = NULL;
    get_channel_key_from_ips (ts->af,
                              ts->protocol,
                              &ts->source_ip,
                              ts->source_port,
                              &ts->destination_ip,
                              ts->destination_port,
                              &key);
    GNUNET_assert (
      GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_remove (channel_map, &key, ts));
  }
  GNUNET_free (ts);
}

References ChannelState::af, ChannelState::channel, channel_map, ChannelState::destination, ChannelState::destination_ip, ChannelState::destination_port, get_channel_key_from_ips(), gettext_noop, GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_REGEX_search_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, ChannelState::heap_node, DestinationEntry::heap_node, key, ChannelState::protocol, ChannelState::search, ChannelState::source_ip, ChannelState::source_port, stats, ChannelState::tmq_head, ChannelState::tmq_length, and ChannelState::tmq_tail.

Referenced by channel_cleaner(), cleanup_channel(), and expire_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

send_to_channel()

static void send_to_channel ( struct ChannelState *  ts, struct GNUNET_MQ_Envelope *  env  )

static

Add the given message to the given channel and trigger the transmission process.

Parameters

ts	channel to queue the message for
env	message to queue

Definition at line 565 of file gnunet-service-vpn.c.

{
  struct GNUNET_MQ_Handle *mq;
 
  GNUNET_assert (NULL != ts->channel);
  mq = GNUNET_CADET_get_mq (ts->channel);
  GNUNET_MQ_env_set_options (env,
                             GNUNET_MQ_PRIO_BEST_EFFORT
                             | GNUNET_MQ_PREF_OUT_OF_ORDER);
  GNUNET_MQ_send (mq, env);
  if (GNUNET_MQ_get_length (mq) > MAX_MESSAGE_QUEUE_SIZE)
  {
    env = GNUNET_MQ_unsent_head (mq);
    GNUNET_assert (NULL != env);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "# Messages dropped in cadet queue (overflow)"),
                              1,
                              GNUNET_NO);
    GNUNET_MQ_discard (env);
  }
}

References ChannelState::channel, env, gettext_noop, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_MQ_discard(), GNUNET_MQ_env_set_options(), GNUNET_MQ_get_length(), GNUNET_MQ_PREF_OUT_OF_ORDER, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_MQ_send(), GNUNET_MQ_unsent_head(), GNUNET_NO, GNUNET_STATISTICS_update(), MAX_MESSAGE_QUEUE_SIZE, mq, and stats.

Referenced by route_packet().

Here is the call graph for this function:

Here is the caller graph for this function:

print_channel_destination()

static const char * print_channel_destination ( const struct DestinationEntry *  de )

static

Output destination of a channel for diagnostics.

Parameters

de	destination to process

Returns

diagnostic string describing destination

Definition at line 596 of file gnunet-service-vpn.c.

{
  static char dest[256];
 
  if (de->is_service)
  {
    GNUNET_snprintf (dest,
                     sizeof(dest),
                     "HS: %s-%s",
                     GNUNET_i2s (&de->details.service_destination.target),
                     GNUNET_h2s (
                       &de->details.service_destination.service_descriptor));
  }
  else
  {
    inet_ntop (de->details.exit_destination.af,
               &de->details.exit_destination.ip,
               dest,
               sizeof(dest));
  }
  return dest;
}

References DestinationEntry::af, DestinationEntry::details, DestinationEntry::exit_destination, GNUNET_h2s(), GNUNET_i2s(), GNUNET_snprintf(), DestinationEntry::ip, DestinationEntry::is_service, DestinationEntry::service_descriptor, DestinationEntry::service_destination, and DestinationEntry::target.

Referenced by channel_cleaner(), cleanup_channel(), expire_channel(), free_destination_entry(), handle_regex_result(), and route_packet().

Here is the call graph for this function:

Here is the caller graph for this function:

channel_cleaner()

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

static

Function called whenever a 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 628 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
 
  ts->channel =
    NULL; /* we must not call GNUNET_CADET_channel_destroy() anymore */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "CADET notified us about death of channel to `%s'\n",
              print_channel_destination (&ts->destination));
  free_channel_state (ts);
}

References ChannelState::channel, ChannelState::destination, free_channel_state(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and print_channel_destination().

Referenced by create_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

make_up_icmpv4_payload()

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

static

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

Parameters

ts	channel information
ipp	IPv4 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 651 of file gnunet-service-vpn.c.

{
  GNUNET_TUN_initialize_ipv4_header (ipp,
                                     ts->protocol,
                                     sizeof(struct GNUNET_TUN_TcpHeader),
                                     &ts->source_ip.v4,
                                     &ts->destination_ip.v4);
  udp->source_port = htons (ts->source_port);
  udp->destination_port = htons (ts->destination_port);
  udp->len = htons (0);
  udp->crc = htons (0);
}

References ChannelState::destination_ip, ChannelState::destination_port, GNUNET_TUN_initialize_ipv4_header(), ChannelState::protocol, ChannelState::source_ip, ChannelState::source_port, udp, and ChannelState::v4.

Referenced by handle_icmp_back().

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 *  ts, struct GNUNET_TUN_IPv6Header *  ipp, struct GNUNET_TUN_UdpHeader *  udp  )

static

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

Parameters

ts	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 677 of file gnunet-service-vpn.c.

{
  GNUNET_TUN_initialize_ipv6_header (ipp,
                                     ts->protocol,
                                     sizeof(struct GNUNET_TUN_TcpHeader),
                                     &ts->source_ip.v6,
                                     &ts->destination_ip.v6);
  udp->source_port = htons (ts->source_port);
  udp->destination_port = htons (ts->destination_port);
  udp->len = htons (0);
  udp->crc = htons (0);
}

References ChannelState::destination_ip, ChannelState::destination_port, GNUNET_TUN_initialize_ipv6_header(), ChannelState::protocol, ChannelState::source_ip, ChannelState::source_port, udp, and ChannelState::v6.

Referenced by handle_icmp_back().

Here is the call graph for this function:

Here is the caller graph for this function:

check_icmp_back()

static int check_icmp_back ( void *  cls, const struct GNUNET_EXIT_IcmpToVPNMessage *  i2v  )

static

We got an ICMP packet back from the CADET channel.

Check it is OK.

Parameters

cls	our struct ChannelState *
i2v	the actual message

Returns

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

Definition at line 702 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
 
  if (NULL == ts->heap_node)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (AF_UNSPEC == ts->af)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References ChannelState::af, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and ChannelState::heap_node.

handle_icmp_back()

static void handle_icmp_back ( void *  cls, const struct GNUNET_EXIT_IcmpToVPNMessage *  i2v  )

static

We got an ICMP packet back from the CADET channel.

Pass it on to the local virtual interface via the helper.

Parameters

cls	our struct ChannelState *
i2v	the actual message

Definition at line 728 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
  size_t mlen;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# ICMP packets received from cadet"),
                            1,
                            GNUNET_NO);
  mlen =
    ntohs (i2v->header.size) - sizeof(struct GNUNET_EXIT_IcmpToVPNMessage);
  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];
 
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Received ICMP packet from cadet, sending %u bytes from %s -> %s via TUN\n",
      (unsigned int) mlen,
      inet_ntop (ts->af, &ts->destination_ip, sbuf, sizeof(sbuf)),
      inet_ntop (ts->af, &ts->source_ip, dbuf, sizeof(dbuf)));
  }
  switch (ts->af)
  {
  case AF_INET: {
      size_t size = sizeof(struct GNUNET_TUN_IPv4Header)
                    + sizeof(struct GNUNET_TUN_IcmpHeader)
                    + sizeof(struct GNUNET_MessageHeader)
                    + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + mlen;
      {
        /* reserve some extra space in case we have an ICMP type here where
             we will need to make up the payload ourselves */
        char buf[size + sizeof(struct GNUNET_TUN_IPv4Header) + 8] GNUNET_ALIGN;
        struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) buf;
        struct GNUNET_TUN_Layer2PacketHeader *tun =
          (struct GNUNET_TUN_Layer2PacketHeader *) &msg[1];
        struct GNUNET_TUN_IPv4Header *ipv4 =
          (struct GNUNET_TUN_IPv4Header *) &tun[1];
        struct GNUNET_TUN_IcmpHeader *icmp =
          (struct GNUNET_TUN_IcmpHeader *) &ipv4[1];
        msg->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
        tun->flags = htons (0);
        tun->proto = htons (ETH_P_IPV4);
        GNUNET_TUN_initialize_ipv4_header (ipv4,
                                           IPPROTO_ICMP,
                                           sizeof(struct GNUNET_TUN_IcmpHeader)
                                           + mlen,
                                           &ts->destination_ip.v4,
                                           &ts->source_ip.v4);
        *icmp = i2v->icmp_header;
        GNUNET_memcpy (&icmp[1], &i2v[1], mlen);
        /* For some ICMP types, we need to adjust (make up) the payload here.
             Also, depending on the AF used on the other side, we have to
             do ICMP PT (translate ICMP types) */
        switch (ntohl (i2v->af))
        {
        case AF_INET:
          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: {
              struct GNUNET_TUN_IPv4Header *ipp =
                (struct GNUNET_TUN_IPv4Header *) &icmp[1];
              struct GNUNET_TUN_UdpHeader *udp =
                (struct GNUNET_TUN_UdpHeader *) &ipp[1];
 
              if (mlen != 0)
              {
                /* sender did not strip ICMP payload? */
                GNUNET_break_op (0);
                return;
              }
              size += sizeof(struct GNUNET_TUN_IPv4Header) + 8;
              GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
              make_up_icmpv4_payload (ts, ipp, udp);
            }
            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:
          /* ICMP PT 6-to-4 and possibly making up payloads */
          switch (icmp->type)
          {
          case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
            icmp->type = GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE;
            {
              struct GNUNET_TUN_IPv4Header *ipp =
                (struct GNUNET_TUN_IPv4Header *) &icmp[1];
              struct GNUNET_TUN_UdpHeader *udp =
                (struct GNUNET_TUN_UdpHeader *) &ipp[1];
 
              if (mlen != 0)
              {
                /* sender did not strip ICMP payload? */
                GNUNET_break_op (0);
                return;
              }
              size += sizeof(struct GNUNET_TUN_IPv4Header) + 8;
              GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
              make_up_icmpv4_payload (ts, ipp, udp);
            }
            break;
 
          case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
            icmp->type = GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED;
            {
              struct GNUNET_TUN_IPv4Header *ipp =
                (struct GNUNET_TUN_IPv4Header *) &icmp[1];
              struct GNUNET_TUN_UdpHeader *udp =
                (struct GNUNET_TUN_UdpHeader *) &ipp[1];
 
              if (mlen != 0)
              {
                /* sender did not strip ICMP payload? */
                GNUNET_break_op (0);
                return;
              }
              size += sizeof(struct GNUNET_TUN_IPv4Header) + 8;
              GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
              make_up_icmpv4_payload (ts, ipp, udp);
            }
            break;
 
          case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
          case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
            GNUNET_STATISTICS_update (
              stats,
              gettext_noop ("# ICMPv6 packets dropped (impossible PT to v4)"),
              1,
              GNUNET_NO);
            return;
 
          case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
            icmp->type = GNUNET_TUN_ICMPTYPE_ECHO_REQUEST;
            break;
 
          case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
            icmp->type = GNUNET_TUN_ICMPTYPE_ECHO_REPLY;
            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:
          GNUNET_break_op (0);
          return;
        }
        msg->size = htons (size);
        GNUNET_TUN_calculate_icmp_checksum (icmp, &i2v[1], mlen);
        (void) GNUNET_HELPER_send (helper_handle, msg, GNUNET_YES, NULL, NULL);
      }
    }
    break;
 
  case AF_INET6: {
      size_t size = sizeof(struct GNUNET_TUN_IPv6Header)
                    + sizeof(struct GNUNET_TUN_IcmpHeader)
                    + sizeof(struct GNUNET_MessageHeader)
                    + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + mlen;
      {
        char buf[size + sizeof(struct GNUNET_TUN_IPv6Header) + 8] GNUNET_ALIGN;
        struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) buf;
        struct GNUNET_TUN_Layer2PacketHeader *tun =
          (struct GNUNET_TUN_Layer2PacketHeader *) &msg[1];
        struct GNUNET_TUN_IPv6Header *ipv6 =
          (struct GNUNET_TUN_IPv6Header *) &tun[1];
        struct GNUNET_TUN_IcmpHeader *icmp =
          (struct GNUNET_TUN_IcmpHeader *) &ipv6[1];
        msg->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
        tun->flags = htons (0);
        tun->proto = htons (ETH_P_IPV6);
        GNUNET_TUN_initialize_ipv6_header (ipv6,
                                           IPPROTO_ICMPV6,
                                           sizeof(struct GNUNET_TUN_IcmpHeader)
                                           + mlen,
                                           &ts->destination_ip.v6,
                                           &ts->source_ip.v6);
        *icmp = i2v->icmp_header;
        GNUNET_memcpy (&icmp[1], &i2v[1], mlen);
 
        /* For some ICMP types, we need to adjust (make up) the payload here.
             Also, depending on the AF used on the other side, we have to
             do ICMP PT (translate ICMP types) */
        switch (ntohl (i2v->af))
        {
        case AF_INET:
          /* ICMP PT 4-to-6 and possibly making up payloads */
          switch (icmp->type)
          {
          case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
            icmp->type = GNUNET_TUN_ICMPTYPE6_ECHO_REPLY;
            break;
 
          case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
            icmp->type = GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST;
            break;
 
          case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
            icmp->type = GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE;
            {
              struct GNUNET_TUN_IPv6Header *ipp =
                (struct GNUNET_TUN_IPv6Header *) &icmp[1];
              struct GNUNET_TUN_UdpHeader *udp =
                (struct GNUNET_TUN_UdpHeader *) &ipp[1];
 
              if (mlen != 0)
              {
                /* sender did not strip ICMP payload? */
                GNUNET_break_op (0);
                return;
              }
              size += sizeof(struct GNUNET_TUN_IPv6Header) + 8;
              GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
              make_up_icmpv6_payload (ts, ipp, udp);
            }
            break;
 
          case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
            icmp->type = GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED;
            {
              struct GNUNET_TUN_IPv6Header *ipp =
                (struct GNUNET_TUN_IPv6Header *) &icmp[1];
              struct GNUNET_TUN_UdpHeader *udp =
                (struct GNUNET_TUN_UdpHeader *) &ipp[1];
 
              if (mlen != 0)
              {
                /* sender did not strip ICMP payload? */
                GNUNET_break_op (0);
                return;
              }
              size += sizeof(struct GNUNET_TUN_IPv6Header) + 8;
              GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
              make_up_icmpv6_payload (ts, ipp, udp);
            }
            break;
 
          case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
            GNUNET_STATISTICS_update (
              stats,
              gettext_noop ("# ICMPv4 packets dropped (impossible PT to v6)"),
              1,
              GNUNET_NO);
            return;
 
          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:
          switch (icmp->type)
          {
          case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
          case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
          case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
          case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM: {
              struct GNUNET_TUN_IPv6Header *ipp =
                (struct GNUNET_TUN_IPv6Header *) &icmp[1];
              struct GNUNET_TUN_UdpHeader *udp =
                (struct GNUNET_TUN_UdpHeader *) &ipp[1];
 
              if (mlen != 0)
              {
                /* sender did not strip ICMP payload? */
                GNUNET_break_op (0);
                return;
              }
              size += sizeof(struct GNUNET_TUN_IPv6Header) + 8;
              GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
              make_up_icmpv6_payload (ts, ipp, udp);
            }
            break;
 
          case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
            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:
          GNUNET_break_op (0);
          return;
        }
        msg->size = htons (size);
        GNUNET_TUN_calculate_icmp_checksum (icmp, &i2v[1], mlen);
        (void) GNUNET_HELPER_send (helper_handle, msg, GNUNET_YES, NULL, NULL);
      }
    }
    break;
 
  default:
    GNUNET_assert (0);
  }
  GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
                                     GNUNET_TIME_absolute_get ().abs_value_us);
  GNUNET_CADET_receive_done (ts->channel);
}

References GNUNET_EXIT_IcmpToVPNMessage::af, ChannelState::af, ChannelState::channel, ChannelState::destination_ip, ETH_P_IPV4, ETH_P_IPV6, GNUNET_TUN_Layer2PacketHeader::flags, gettext_noop, GNUNET_ALIGN, GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_heap_update_cost(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TUN_calculate_icmp_checksum(), 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_TUN_initialize_ipv4_header(), GNUNET_TUN_initialize_ipv6_header(), GNUNET_YES, GNUNET_EXIT_IcmpToVPNMessage::header, ChannelState::heap_node, helper_handle, GNUNET_EXIT_IcmpToVPNMessage::icmp_header, ipv4, ipv6, make_up_icmpv4_payload(), make_up_icmpv6_payload(), msg, GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_MessageHeader::size, size, ChannelState::source_ip, stats, GNUNET_MessageHeader::type, GNUNET_TUN_IcmpHeader::type, udp, ChannelState::v4, and ChannelState::v6.

Here is the call graph for this function:

check_udp_back()

static int check_udp_back ( void *  cls, const struct GNUNET_EXIT_UdpReplyMessage *  reply  )

static

We got a UDP packet back from the CADET channel.

Check that it is OK.

Parameters

cls	our struct ChannelState *
reply	the actual message

Returns

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

Definition at line 1078 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
 
  if (NULL == ts->heap_node)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (AF_UNSPEC == ts->af)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References ChannelState::af, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and ChannelState::heap_node.

handle_udp_back()

static void handle_udp_back ( void *  cls, const struct GNUNET_EXIT_UdpReplyMessage *  reply  )

static

We got a UDP packet back from the CADET channel.

Pass it on to the local virtual interface via the helper.

Parameters

cls	our struct ChannelState *
reply	the actual message

Definition at line 1104 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
  size_t mlen;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# UDP packets received from cadet"),
                            1,
                            GNUNET_NO);
  mlen =
    ntohs (reply->header.size) - sizeof(struct GNUNET_EXIT_UdpReplyMessage);
  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];
 
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Received UDP reply from cadet, sending %u bytes from [%s]:%u -> [%s]:%u via TUN\n",
      (unsigned int) mlen,
      inet_ntop (ts->af, &ts->destination_ip, sbuf, sizeof(sbuf)),
      ts->destination_port,
      inet_ntop (ts->af, &ts->source_ip, dbuf, sizeof(dbuf)),
      ts->source_port);
  }
  switch (ts->af)
  {
  case AF_INET: {
      size_t size = sizeof(struct GNUNET_TUN_IPv4Header)
                    + sizeof(struct GNUNET_TUN_UdpHeader)
                    + sizeof(struct GNUNET_MessageHeader)
                    + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + mlen;
      {
        char buf[size] GNUNET_ALIGN;
        struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) buf;
        struct GNUNET_TUN_Layer2PacketHeader *tun =
          (struct GNUNET_TUN_Layer2PacketHeader *) &msg[1];
        struct GNUNET_TUN_IPv4Header *ipv4 =
          (struct GNUNET_TUN_IPv4Header *) &tun[1];
        struct GNUNET_TUN_UdpHeader *udp =
          (struct GNUNET_TUN_UdpHeader *) &ipv4[1];
        msg->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
        msg->size = htons (size);
        tun->flags = htons (0);
        tun->proto = htons (ETH_P_IPV4);
        GNUNET_TUN_initialize_ipv4_header (ipv4,
                                           IPPROTO_UDP,
                                           sizeof(struct GNUNET_TUN_UdpHeader)
                                           + mlen,
                                           &ts->destination_ip.v4,
                                           &ts->source_ip.v4);
        if (0 == ntohs (reply->source_port))
          udp->source_port = htons (ts->destination_port);
        else
          udp->source_port = reply->source_port;
        if (0 == ntohs (reply->destination_port))
          udp->destination_port = htons (ts->source_port);
        else
          udp->destination_port = reply->destination_port;
        udp->len = htons (mlen + sizeof(struct GNUNET_TUN_UdpHeader));
        GNUNET_TUN_calculate_udp4_checksum (ipv4, udp, &reply[1], mlen);
        GNUNET_memcpy (&udp[1], &reply[1], mlen);
        (void) GNUNET_HELPER_send (helper_handle, msg, GNUNET_YES, NULL, NULL);
      }
    }
    break;
 
  case AF_INET6: {
      size_t size = sizeof(struct GNUNET_TUN_IPv6Header)
                    + sizeof(struct GNUNET_TUN_UdpHeader)
                    + sizeof(struct GNUNET_MessageHeader)
                    + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + mlen;
      {
        char buf[size] GNUNET_ALIGN;
        struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) buf;
        struct GNUNET_TUN_Layer2PacketHeader *tun =
          (struct GNUNET_TUN_Layer2PacketHeader *) &msg[1];
        struct GNUNET_TUN_IPv6Header *ipv6 =
          (struct GNUNET_TUN_IPv6Header *) &tun[1];
        struct GNUNET_TUN_UdpHeader *udp =
          (struct GNUNET_TUN_UdpHeader *) &ipv6[1];
        msg->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
        msg->size = htons (size);
        tun->flags = htons (0);
        tun->proto = htons (ETH_P_IPV6);
        GNUNET_TUN_initialize_ipv6_header (ipv6,
                                           IPPROTO_UDP,
                                           sizeof(struct GNUNET_TUN_UdpHeader)
                                           + mlen,
                                           &ts->destination_ip.v6,
                                           &ts->source_ip.v6);
        if (0 == ntohs (reply->source_port))
          udp->source_port = htons (ts->destination_port);
        else
          udp->source_port = reply->source_port;
        if (0 == ntohs (reply->destination_port))
          udp->destination_port = htons (ts->source_port);
        else
          udp->destination_port = reply->destination_port;
        udp->len = htons (mlen + sizeof(struct GNUNET_TUN_UdpHeader));
        GNUNET_TUN_calculate_udp6_checksum (ipv6, udp, &reply[1], mlen);
        GNUNET_memcpy (&udp[1], &reply[1], mlen);
        (void) GNUNET_HELPER_send (helper_handle, msg, GNUNET_YES, NULL, NULL);
      }
    }
    break;
 
  default:
    GNUNET_assert (0);
  }
  GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
                                     GNUNET_TIME_absolute_get ().abs_value_us);
  GNUNET_CADET_receive_done (ts->channel);
}

References ChannelState::af, ChannelState::channel, ChannelState::destination_ip, GNUNET_EXIT_UdpReplyMessage::destination_port, ChannelState::destination_port, ETH_P_IPV4, ETH_P_IPV6, GNUNET_TUN_Layer2PacketHeader::flags, gettext_noop, GNUNET_ALIGN, GNUNET_assert, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_heap_update_cost(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TUN_calculate_udp4_checksum(), GNUNET_TUN_calculate_udp6_checksum(), GNUNET_TUN_initialize_ipv4_header(), GNUNET_TUN_initialize_ipv6_header(), GNUNET_YES, GNUNET_EXIT_UdpReplyMessage::header, ChannelState::heap_node, helper_handle, ipv4, ipv6, msg, GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_MessageHeader::size, size, ChannelState::source_ip, GNUNET_EXIT_UdpReplyMessage::source_port, ChannelState::source_port, stats, GNUNET_MessageHeader::type, udp, ChannelState::v4, and ChannelState::v6.

Here is the call graph for this function:

check_tcp_back()

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

static

We got a TCP packet back from the CADET channel.

Check it is OK.

Parameters

cls	our struct ChannelState *
data	the actual message

Returns

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

Definition at line 1228 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
 
  if (NULL == ts->heap_node)
  {
    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;
  }
  return GNUNET_OK;
}

References data, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and ChannelState::heap_node.

handle_tcp_back()

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

static

We got a TCP packet back from the CADET channel.

Pass it on to the local virtual interface via the helper.

Parameters

cls	our struct ChannelState *
data	the actual message

Definition at line 1254 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
  size_t mlen;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# TCP packets received from cadet"),
                            1,
                            GNUNET_NO);
  mlen = ntohs (data->header.size) - sizeof(struct GNUNET_EXIT_TcpDataMessage);
  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];
 
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Received TCP reply from cadet, sending %u bytes from [%s]:%u -> [%s]:%u via TUN\n",
      (unsigned int) mlen,
      inet_ntop (ts->af, &ts->destination_ip, sbuf, sizeof(sbuf)),
      ts->destination_port,
      inet_ntop (ts->af, &ts->source_ip, dbuf, sizeof(dbuf)),
      ts->source_port);
  }
  switch (ts->af)
  {
  case AF_INET: {
      size_t size = sizeof(struct GNUNET_TUN_IPv4Header)
                    + sizeof(struct GNUNET_TUN_TcpHeader)
                    + sizeof(struct GNUNET_MessageHeader)
                    + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + mlen;
      {
        char buf[size] GNUNET_ALIGN;
        struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) buf;
        struct GNUNET_TUN_Layer2PacketHeader *tun =
          (struct GNUNET_TUN_Layer2PacketHeader *) &msg[1];
        struct GNUNET_TUN_IPv4Header *ipv4 =
          (struct GNUNET_TUN_IPv4Header *) &tun[1];
        struct GNUNET_TUN_TcpHeader *tcp =
          (struct GNUNET_TUN_TcpHeader *) &ipv4[1];
        msg->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
        msg->size = htons (size);
        tun->flags = htons (0);
        tun->proto = htons (ETH_P_IPV4);
        GNUNET_TUN_initialize_ipv4_header (ipv4,
                                           IPPROTO_TCP,
                                           sizeof(struct GNUNET_TUN_TcpHeader)
                                           + mlen,
                                           &ts->destination_ip.v4,
                                           &ts->source_ip.v4);
        *tcp = data->tcp_header;
        tcp->source_port = htons (ts->destination_port);
        tcp->destination_port = htons (ts->source_port);
        GNUNET_TUN_calculate_tcp4_checksum (ipv4, tcp, &data[1], mlen);
        GNUNET_memcpy (&tcp[1], &data[1], mlen);
        (void) GNUNET_HELPER_send (helper_handle, msg, GNUNET_YES, NULL, NULL);
      }
    }
    break;
 
  case AF_INET6: {
      size_t size = sizeof(struct GNUNET_TUN_IPv6Header)
                    + sizeof(struct GNUNET_TUN_TcpHeader)
                    + sizeof(struct GNUNET_MessageHeader)
                    + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + mlen;
      {
        char buf[size] GNUNET_ALIGN;
        struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) buf;
        struct GNUNET_TUN_Layer2PacketHeader *tun =
          (struct GNUNET_TUN_Layer2PacketHeader *) &msg[1];
        struct GNUNET_TUN_IPv6Header *ipv6 =
          (struct GNUNET_TUN_IPv6Header *) &tun[1];
        struct GNUNET_TUN_TcpHeader *tcp =
          (struct GNUNET_TUN_TcpHeader *) &ipv6[1];
        msg->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
        msg->size = htons (size);
        tun->flags = htons (0);
        tun->proto = htons (ETH_P_IPV6);
        GNUNET_TUN_initialize_ipv6_header (ipv6,
                                           IPPROTO_TCP,
                                           sizeof(struct GNUNET_TUN_TcpHeader)
                                           + mlen,
                                           &ts->destination_ip.v6,
                                           &ts->source_ip.v6);
        *tcp = data->tcp_header;
        tcp->source_port = htons (ts->destination_port);
        tcp->destination_port = htons (ts->source_port);
        GNUNET_TUN_calculate_tcp6_checksum (ipv6, tcp, &data[1], mlen);
        GNUNET_memcpy (&tcp[1], &data[1], mlen);
        (void) GNUNET_HELPER_send (helper_handle, msg, GNUNET_YES, NULL, NULL);
      }
    }
    break;
  }
  GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
                                     GNUNET_TIME_absolute_get ().abs_value_us);
  GNUNET_CADET_receive_done (ts->channel);
}

References ChannelState::af, data, ChannelState::destination_ip, ChannelState::destination_port, ETH_P_IPV4, ETH_P_IPV6, GNUNET_TUN_Layer2PacketHeader::flags, gettext_noop, GNUNET_ALIGN, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_heap_update_cost(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TUN_calculate_tcp4_checksum(), GNUNET_TUN_calculate_tcp6_checksum(), GNUNET_TUN_initialize_ipv4_header(), GNUNET_TUN_initialize_ipv6_header(), GNUNET_YES, helper_handle, ipv4, ipv6, msg, GNUNET_TUN_TcpHeader::off, GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_MessageHeader::size, size, ChannelState::source_ip, ChannelState::source_port, stats, tcp, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

create_channel()

static struct GNUNET_CADET_Channel * create_channel ( struct ChannelState *  ts, const struct GNUNET_PeerIdentity *  target, const struct GNUNET_HashCode *  port  )

static

Create a channel for ts to target at port.

Parameters

ts	channel state to create the channel for
target	peer to connect to
port	destination port

Returns

the channel handle

Definition at line 1362 of file gnunet-service-vpn.c.

{
  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
  { GNUNET_MQ_hd_var_size (udp_back,
                           GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY,
                           struct GNUNET_EXIT_UdpReplyMessage,
                           ts),
    GNUNET_MQ_hd_var_size (tcp_back,
                           GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN,
                           struct GNUNET_EXIT_TcpDataMessage,
                           ts),
    GNUNET_MQ_hd_var_size (icmp_back,
                           GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN,
                           struct GNUNET_EXIT_IcmpToVPNMessage,
                           ts),
    GNUNET_MQ_handler_end () };
 
  return GNUNET_CADET_channel_create (cadet_handle,
                                      ts,
                                      target,
                                      port,
                                      NULL,
                                      &channel_cleaner,
                                      cadet_handlers);
}

References cadet_handle, channel_cleaner(), GNUNET_CADET_channel_create(), GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN, GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN, GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, and port.

Referenced by create_channel_to_destination(), and handle_regex_result().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_regex_result()

static void handle_regex_result ( void *  cls, const struct GNUNET_PeerIdentity *  id, const struct GNUNET_PeerIdentity *  get_path, unsigned int  get_path_length, const struct GNUNET_PeerIdentity *  put_path, unsigned int  put_path_length  )

static

Regex has found a potential exit peer for us; consider using it.

Parameters

cls	the struct ChannelState
id	Peer providing a regex that matches the string.
get_path	Path of the get request.
get_path_length	Length of get_path.
put_path	Path of the put request.
put_path_length	Length of the put_path.

Definition at line 1402 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = cls;
  struct GNUNET_HashCode port;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Exit %s found for destination %s!\n",
              GNUNET_i2s (id),
              print_channel_destination (&ts->destination));
  GNUNET_REGEX_search_cancel (ts->search);
  ts->search = NULL;
  switch (ts->af)
  {
  case AF_INET:
    /* these must match the strings used in gnunet-daemon-exit */
    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_IPV4_GATEWAY,
                        strlen (GNUNET_APPLICATION_PORT_IPV4_GATEWAY),
                        &port);
    break;
 
  case AF_INET6:
    /* these must match the strings used in gnunet-daemon-exit */
    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_IPV6_GATEWAY,
                        strlen (GNUNET_APPLICATION_PORT_IPV6_GATEWAY),
                        &port);
    break;
 
  default:
    GNUNET_break (0);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Creating tunnel to %s for destination %s!\n",
              GNUNET_i2s (id),
              print_channel_destination (&ts->destination));
  ts->channel = create_channel (ts, id, &port);
}

References ChannelState::af, ChannelState::channel, create_channel(), ChannelState::destination, GNUNET_APPLICATION_PORT_IPV4_GATEWAY, GNUNET_APPLICATION_PORT_IPV6_GATEWAY, GNUNET_break, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_REGEX_search_cancel(), port, print_channel_destination(), and ChannelState::search.

Referenced by create_channel_to_destination().

Here is the call graph for this function:

Here is the caller graph for this function:

create_channel_to_destination()

static struct ChannelState * create_channel_to_destination ( struct DestinationChannel *  dt, int  client_af  )

static

Initialize the given destination entry's cadet channel.

Parameters

dt	destination channel for which we need to setup a channel
client_af	address family of the address returned to the client

Returns

channel state of the channel that was created

Definition at line 1454 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# Cadet channels created"),
                            1,
                            GNUNET_NO);
  ts = GNUNET_new (struct ChannelState);
  ts->af = client_af;
  ts->destination = *dt->destination;
  ts->destination.heap_node = NULL; /* copy is NOT in destination heap */
  ts->destination_port = dt->destination_port;
  if (dt->destination->is_service)
  {
    struct GNUNET_HashCode cadet_port;
 
    GNUNET_TUN_compute_service_cadet_port (&ts->destination.details
                                           .service_destination
                                           .service_descriptor,
                                           ts->destination_port,
                                           &cadet_port);
    ts->channel =
      create_channel (ts,
                      &dt->destination->details.service_destination.target,
                      &cadet_port);
 
    if (NULL == ts->channel)
    {
      GNUNET_break (0);
      GNUNET_free (ts);
      return NULL;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating channel to peer %s offering service %s on port %u\n",
                GNUNET_i2s (
                  &dt->destination->details.service_destination.target),
                GNUNET_h2s (&ts->destination.details.service_destination
                            .service_descriptor),
                (unsigned int) ts->destination_port);
  }
  else
  {
    char *policy;
 
    switch (dt->destination->details.exit_destination.af)
    {
    case AF_INET: {
        char address[GNUNET_TUN_IPV4_REGEXLEN];
 
        GNUNET_REGEX_ipv4toregexsearch (&dt->destination->details.
                                        exit_destination
                                        .ip.v4,
                                        dt->destination_port,
                                        address);
        GNUNET_asprintf (&policy,
                         "%s%s",
                         GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
                         address);
        break;
      }
 
    case AF_INET6: {
        char address[GNUNET_TUN_IPV6_REGEXLEN];
 
        GNUNET_REGEX_ipv6toregexsearch (&dt->destination->details.
                                        exit_destination
                                        .ip.v6,
                                        dt->destination_port,
                                        address);
        GNUNET_asprintf (&policy,
                         "%s%s",
                         GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
                         address);
        break;
      }
 
    default:
      GNUNET_assert (0);
      break;
    }
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Requesting connect by string: %s\n",
                policy);
    ts->search = GNUNET_REGEX_search (cfg, policy, &handle_regex_result, ts);
    GNUNET_free (policy);
  }
  return ts;
}

References address, DestinationEntry::af, ChannelState::af, cadet_port, cfg, ChannelState::channel, create_channel(), DestinationChannel::destination, ChannelState::destination, DestinationChannel::destination_port, ChannelState::destination_port, DestinationEntry::details, DestinationEntry::exit_destination, gettext_noop, GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_REGEX_ipv4toregexsearch(), GNUNET_REGEX_ipv6toregexsearch(), GNUNET_REGEX_search(), GNUNET_STATISTICS_update(), GNUNET_TUN_compute_service_cadet_port(), GNUNET_TUN_IPV4_REGEXLEN, GNUNET_TUN_IPV6_REGEXLEN, handle_regex_result(), DestinationEntry::heap_node, DestinationEntry::ip, DestinationEntry::is_service, ChannelState::search, DestinationEntry::service_descriptor, DestinationEntry::service_destination, stats, DestinationEntry::target, DestinationEntry::v4, and DestinationEntry::v6.

Referenced by route_packet().

Here is the call graph for this function:

Here is the caller graph for this function:

expire_channel()

static void expire_channel ( struct ChannelState *  except )

static

We have too many active channels.

Clean up the oldest channel.

Parameters

except

channel that must NOT be cleaned up, even if it is the oldest

Definition at line 1552 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts;
 
  ts = GNUNET_CONTAINER_heap_peek (channel_heap);
  GNUNET_assert (NULL != ts);
  if (except == ts)
    return; /* can't do this */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Tearing down expired channel to %s\n",
              print_channel_destination (&except->destination));
  free_channel_state (ts);
}

References channel_heap, ChannelState::destination, free_channel_state(), GNUNET_assert, GNUNET_CONTAINER_heap_peek(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and print_channel_destination().

Referenced by route_packet().

Here is the call graph for this function:

Here is the caller graph for this function:

route_packet()

static void route_packet ( struct DestinationEntry *  destination, int  af, uint8_t  protocol, const void *  source_ip, const void *  destination_ip, const void *  payload, size_t  payload_length  )

static

Route a packet via cadet to the given destination.

Parameters

destination	description of the destination
af	address family on this end (AF_INET or AF_INET6)
protocol	IPPROTO_TCP or IPPROTO_UDP or IPPROTO_ICMP or IPPROTO_ICMPV6
source_ip	source IP used by the sender (struct in_addr or struct in6_addr)
destination_ip	destination IP used by the sender (struct in_addr or struct in6_addr)
payload	payload of the packet after the IP header
payload_length	number of bytes in payload

Definition at line 1579 of file gnunet-service-vpn.c.

{
  struct GNUNET_HashCode key;
  struct ChannelState *ts;
  size_t alen;
  size_t mlen;
  struct GNUNET_MQ_Envelope *env;
  const struct GNUNET_TUN_UdpHeader *udp;
  const struct GNUNET_TUN_TcpHeader *tcp;
  const struct GNUNET_TUN_IcmpHeader *icmp;
  struct DestinationChannel *dt;
  uint16_t source_port;
  uint16_t destination_port;
 
  switch (protocol)
  {
  case IPPROTO_UDP: {
      if (payload_length < sizeof(struct GNUNET_TUN_UdpHeader))
      {
        /* blame kernel? */
        GNUNET_break (0);
        return;
      }
      tcp = NULL; /* make compiler happy */
      icmp = NULL; /* make compiler happy */
      udp = payload;
      if (udp->len < sizeof(struct GNUNET_TUN_UdpHeader))
      {
        GNUNET_break_op (0);
        return;
      }
      source_port = ntohs (udp->source_port);
      destination_port = ntohs (udp->destination_port);
      get_channel_key_from_ips (af,
                                IPPROTO_UDP,
                                source_ip,
                                source_port,
                                destination_ip,
                                destination_port,
                                &key);
    }
    break;
 
  case IPPROTO_TCP: {
      if (payload_length < sizeof(struct GNUNET_TUN_TcpHeader))
      {
        /* blame kernel? */
        GNUNET_break (0);
        return;
      }
      udp = NULL; /* make compiler happy */
      icmp = NULL; /* make compiler happy */
      tcp = payload;
      if (tcp->off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
      {
        GNUNET_break_op (0);
        return;
      }
      source_port = ntohs (tcp->source_port);
      destination_port = ntohs (tcp->destination_port);
      get_channel_key_from_ips (af,
                                IPPROTO_TCP,
                                source_ip,
                                source_port,
                                destination_ip,
                                destination_port,
                                &key);
    }
    break;
 
  case IPPROTO_ICMP:
  case IPPROTO_ICMPV6: {
      if ((AF_INET == af) ^ (protocol == IPPROTO_ICMP))
      {
        GNUNET_break (0);
        return;
      }
      if (payload_length < sizeof(struct GNUNET_TUN_IcmpHeader))
      {
        /* blame kernel? */
        GNUNET_break (0);
        return;
      }
      tcp = NULL; /* make compiler happy */
      udp = NULL; /* make compiler happy */
      icmp = payload;
      source_port = 0;
      destination_port = 0;
      get_channel_key_from_ips (af,
                                protocol,
                                source_ip,
                                0,
                                destination_ip,
                                0,
                                &key);
    }
    break;
 
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Protocol %u not supported, dropping\n"),
                (unsigned int) protocol);
    return;
  }
  alen = 0;
  if (! destination->is_service)
  {
    switch (destination->details.exit_destination.af)
    {
    case AF_INET:
      alen = sizeof(struct in_addr);
      break;
 
    case AF_INET6:
      alen = sizeof(struct in6_addr);
      break;
 
    default:
      GNUNET_assert (0);
    }
 
    {
      char sbuf[INET6_ADDRSTRLEN];
      char dbuf[INET6_ADDRSTRLEN];
      char xbuf[INET6_ADDRSTRLEN];
 
      GNUNET_log (
        GNUNET_ERROR_TYPE_DEBUG,
        "Routing %s packet from [%s]:%u -> [%s]:%u to destination [%s]:%u\n",
        (protocol == IPPROTO_TCP) ? "TCP" : "UDP",
        inet_ntop (af, source_ip, sbuf, sizeof(sbuf)),
        source_port,
        inet_ntop (af, destination_ip, dbuf, sizeof(dbuf)),
        destination_port,
        inet_ntop (destination->details.exit_destination.af,
                   &destination->details.exit_destination.ip,
                   xbuf,
                   sizeof(xbuf)),
        destination_port);
    }
    for (dt = destination->dt_head; NULL != dt; dt = dt->next)
      if (dt->destination_port == destination_port)
        break;
  }
  else
  {
    {
      char sbuf[INET6_ADDRSTRLEN];
      char dbuf[INET6_ADDRSTRLEN];
 
      GNUNET_log (
        GNUNET_ERROR_TYPE_DEBUG,
        "Routing %s packet from [%s]:%u -> [%s]:%u to service %s at peer %s\n",
        (protocol == IPPROTO_TCP) ? "TCP" : "UDP",
        inet_ntop (af, source_ip, sbuf, sizeof(sbuf)),
        source_port,
        inet_ntop (af, destination_ip, dbuf, sizeof(dbuf)),
        destination_port,
        GNUNET_h2s (
          &destination->details.service_destination.service_descriptor),
        GNUNET_i2s (&destination->details.service_destination.target));
    }
    for (dt = destination->dt_head; NULL != dt; dt = dt->next)
      if (dt->destination_port == destination_port)
        break;
  }
  if (NULL == dt)
  {
    dt = GNUNET_new (struct DestinationChannel);
    dt->destination = destination;
    GNUNET_CONTAINER_DLL_insert (destination->dt_head,
                                 destination->dt_tail,
                                 dt);
    dt->destination_port = destination_port;
  }
 
  /* see if we have an existing channel for this destination */
  ts = GNUNET_CONTAINER_multihashmap_get (channel_map, &key);
  if (NULL == ts)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating new channel for key %s\n",
                GNUNET_h2s (&key));
    /* need to either use the existing channel from the destination (if still
       available) or create a fresh one */
    ts = create_channel_to_destination (dt, af);
    if (NULL == ts)
      return;
    /* now bind existing "unbound" channel to our IP/port tuple */
    ts->protocol = protocol;
    ts->af = af;
    if (AF_INET == af)
    {
      ts->source_ip.v4 = *(const struct in_addr *) source_ip;
      ts->destination_ip.v4 = *(const struct in_addr *) destination_ip;
    }
    else
    {
      ts->source_ip.v6 = *(const struct in6_addr *) source_ip;
      ts->destination_ip.v6 = *(const struct in6_addr *) destination_ip;
    }
    ts->source_port = source_port;
    ts->destination_port = destination_port;
    ts->heap_node =
      GNUNET_CONTAINER_heap_insert (channel_heap,
                                    ts,
                                    GNUNET_TIME_absolute_get ().abs_value_us);
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_put (
                     channel_map,
                     &key,
                     ts,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    GNUNET_STATISTICS_update (stats,
                              gettext_noop ("# Active channels"),
                              1,
                              GNUNET_NO);
    while (GNUNET_CONTAINER_multihashmap_size (channel_map) >
           max_channel_mappings)
      expire_channel (ts);
  }
  else
  {
    GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
                                       GNUNET_TIME_absolute_get ()
                                       .abs_value_us);
  }
  if (NULL == ts->channel)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Packet dropped, channel to %s not yet ready (%s)\n",
                print_channel_destination (&ts->destination),
                (NULL == ts->search) ? "EXIT search failed"
                : "EXIT search active");
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "# Packets dropped (channel not yet online)"),
                              1,
                              GNUNET_NO);
    return;
  }
 
  /* send via channel */
  switch (protocol)
  {
  case IPPROTO_UDP:
    if (destination->is_service)
    {
      struct GNUNET_EXIT_UdpServiceMessage *usm;
 
      mlen = sizeof(struct GNUNET_EXIT_UdpServiceMessage) + payload_length
             - sizeof(struct GNUNET_TUN_UdpHeader);
      if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
      {
        GNUNET_break (0);
        return;
      }
      env = GNUNET_MQ_msg_extra (usm,
                                 payload_length
                                 - sizeof(struct GNUNET_TUN_UdpHeader),
                                 GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE);
      /* if the source port is below 32000, we assume it has a special
         meaning; if not, we pick a random port (this is a heuristic) */
      usm->source_port =
        (ntohs (udp->source_port) < 32000) ? udp->source_port : 0;
      usm->destination_port = udp->destination_port;
      GNUNET_memcpy (&usm[1],
                     &udp[1],
                     payload_length - sizeof(struct GNUNET_TUN_UdpHeader));
    }
    else
    {
      struct GNUNET_EXIT_UdpInternetMessage *uim;
      struct in_addr *ip4dst;
      struct in6_addr *ip6dst;
      void *payload_tmp;
 
      mlen = sizeof(struct GNUNET_EXIT_UdpInternetMessage) + alen
             + payload_length - sizeof(struct GNUNET_TUN_UdpHeader);
      if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
      {
        GNUNET_break (0);
        return;
      }
      env = GNUNET_MQ_msg_extra (uim,
                                 payload_length + alen
                                 - sizeof(struct GNUNET_TUN_UdpHeader),
                                 GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET);
      uim->af = htonl (destination->details.exit_destination.af);
      uim->source_port =
        (ntohs (udp->source_port) < 32000) ? udp->source_port : 0;
      uim->destination_port = udp->destination_port;
      switch (destination->details.exit_destination.af)
      {
      case AF_INET:
        ip4dst = (struct in_addr *) &uim[1];
        *ip4dst = destination->details.exit_destination.ip.v4;
        payload_tmp = &ip4dst[1];
        break;
 
      case AF_INET6:
        ip6dst = (struct in6_addr *) &uim[1];
        *ip6dst = destination->details.exit_destination.ip.v6;
        payload_tmp = &ip6dst[1];
        break;
 
      default:
        GNUNET_assert (0);
      }
      GNUNET_memcpy (payload_tmp,
                     &udp[1],
                     payload_length - sizeof(struct GNUNET_TUN_UdpHeader));
    }
    break;
 
  case IPPROTO_TCP:
    if (GNUNET_NO == ts->is_established)
    {
      if (destination->is_service)
      {
        struct GNUNET_EXIT_TcpServiceStartMessage *tsm;
 
        mlen = sizeof(struct GNUNET_EXIT_TcpServiceStartMessage)
               + payload_length - sizeof(struct GNUNET_TUN_TcpHeader);
        if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
        {
          GNUNET_break (0);
          return;
        }
        env =
          GNUNET_MQ_msg_extra (tsm,
                               payload_length
                               - sizeof(struct GNUNET_TUN_TcpHeader),
                               GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START);
        tsm->reserved = htonl (0);
        tsm->tcp_header = *tcp;
        GNUNET_memcpy (&tsm[1],
                       &tcp[1],
                       payload_length - sizeof(struct GNUNET_TUN_TcpHeader));
      }
      else
      {
        struct GNUNET_EXIT_TcpInternetStartMessage *tim;
        struct in_addr *ip4dst;
        struct in6_addr *ip6dst;
        void *payload_tmp;
 
        mlen = sizeof(struct GNUNET_EXIT_TcpInternetStartMessage) + alen
               + payload_length - sizeof(struct GNUNET_TUN_TcpHeader);
        if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
        {
          GNUNET_break (0);
          return;
        }
        env =
          GNUNET_MQ_msg_extra (tim,
                               payload_length + alen
                               - sizeof(struct GNUNET_TUN_TcpHeader),
                               GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START);
        tim->af = htonl (destination->details.exit_destination.af);
        tim->tcp_header = *tcp;
        switch (destination->details.exit_destination.af)
        {
        case AF_INET:
          ip4dst = (struct in_addr *) &tim[1];
          *ip4dst = destination->details.exit_destination.ip.v4;
          payload_tmp = &ip4dst[1];
          break;
 
        case AF_INET6:
          ip6dst = (struct in6_addr *) &tim[1];
          *ip6dst = destination->details.exit_destination.ip.v6;
          payload_tmp = &ip6dst[1];
          break;
 
        default:
          GNUNET_assert (0);
        }
        GNUNET_memcpy (payload_tmp,
                       &tcp[1],
                       payload_length - sizeof(struct GNUNET_TUN_TcpHeader));
      }
    }
    else
    {
      struct GNUNET_EXIT_TcpDataMessage *tdm;
 
      mlen = sizeof(struct GNUNET_EXIT_TcpDataMessage) + payload_length
             - sizeof(struct GNUNET_TUN_TcpHeader);
      if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
      {
        GNUNET_break (0);
        return;
      }
      env = GNUNET_MQ_msg_extra (tdm,
                                 payload_length
                                 - sizeof(struct GNUNET_TUN_TcpHeader),
                                 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT);
      tdm->reserved = htonl (0);
      tdm->tcp_header = *tcp;
      GNUNET_memcpy (&tdm[1],
                     &tcp[1],
                     payload_length - sizeof(struct GNUNET_TUN_TcpHeader));
    }
    break;
 
  case IPPROTO_ICMP:
  case IPPROTO_ICMPV6:
    if (destination->is_service)
    {
      struct GNUNET_EXIT_IcmpServiceMessage *ism;
 
      /* ICMP protocol translation will be done by the receiver (as we don't know
         the target AF); however, we still need to possibly discard the payload
         depending on the ICMP type */
      switch (af)
      {
      case AF_INET:
        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:
          /* throw away ICMP payload, won't be useful for the other side anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        default:
          GNUNET_STATISTICS_update (stats,
                                    gettext_noop (
                                      "# ICMPv4 packets dropped (not allowed)"),
                                    1,
                                    GNUNET_NO);
          return;
        }
        /* end of AF_INET */
        break;
 
      case AF_INET6:
        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:
          /* throw away ICMP payload, won't be useful for the other side anyway */
          payload_length = 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 (not allowed)"),
                                    1,
                                    GNUNET_NO);
          return;
        }
        /* end of AF_INET6 */
        break;
 
      default:
        GNUNET_assert (0);
        break;
      }
 
      /* update length calculations, as payload_length may have changed */
      mlen = sizeof(struct GNUNET_EXIT_IcmpServiceMessage) + alen
             + payload_length - sizeof(struct GNUNET_TUN_IcmpHeader);
      if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
      {
        GNUNET_break (0);
        return;
      }
 
      env = GNUNET_MQ_msg_extra (ism,
                                 payload_length
                                 - sizeof(struct GNUNET_TUN_IcmpHeader),
                                 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE);
      ism->af = htonl (af);    /* need to tell destination ICMP protocol family! */
      ism->icmp_header = *icmp;
      GNUNET_memcpy (&ism[1],
                     &icmp[1],
                     payload_length - sizeof(struct GNUNET_TUN_IcmpHeader));
    }
    else
    {
      struct GNUNET_EXIT_IcmpInternetMessage *iim;
      struct in_addr *ip4dst;
      struct in6_addr *ip6dst;
      void *payload_tmp;
      uint8_t new_type;
 
      new_type = icmp->type;
      /* Perform ICMP protocol-translation (depending on destination AF and source AF)
         and throw away ICMP payload depending on ICMP message type */
      switch (af)
      {
      case AF_INET:
        switch (icmp->type)
        {
        case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
          if (destination->details.exit_destination.af == AF_INET6)
            new_type = GNUNET_TUN_ICMPTYPE6_ECHO_REPLY;
          break;
 
        case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
          if (destination->details.exit_destination.af == AF_INET6)
            new_type = GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST;
          break;
 
        case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
          if (destination->details.exit_destination.af == AF_INET6)
            new_type = GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE;
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
          if (destination->details.exit_destination.af == AF_INET6)
            new_type = GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED;
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
          if (destination->details.exit_destination.af == AF_INET6)
          {
            GNUNET_STATISTICS_update (
              stats,
              gettext_noop ("# ICMPv4 packets dropped (impossible PT to v6)"),
              1,
              GNUNET_NO);
            return;
          }
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        default:
          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 (icmp->type)
        {
        case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
          if (destination->details.exit_destination.af == AF_INET)
            new_type = GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE;
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
          if (destination->details.exit_destination.af == AF_INET)
            new_type = GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED;
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
          if (destination->details.exit_destination.af == AF_INET)
          {
            GNUNET_STATISTICS_update (
              stats,
              gettext_noop ("# ICMPv6 packets dropped (impossible PT to v4)"),
              1,
              GNUNET_NO);
            return;
          }
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
          if (destination->details.exit_destination.af == AF_INET)
          {
            GNUNET_STATISTICS_update (
              stats,
              gettext_noop ("# ICMPv6 packets dropped (impossible PT to v4)"),
              1,
              GNUNET_NO);
            return;
          }
          /* throw away IP-payload, exit will have to make it up anyway */
          payload_length = sizeof(struct GNUNET_TUN_IcmpHeader);
          break;
 
        case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
          if (destination->details.exit_destination.af == AF_INET)
            new_type = GNUNET_TUN_ICMPTYPE_ECHO_REQUEST;
          break;
 
        case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
          if (destination->details.exit_destination.af == AF_INET)
            new_type = GNUNET_TUN_ICMPTYPE_ECHO_REPLY;
          break;
 
        default:
          GNUNET_STATISTICS_update (
            stats,
            gettext_noop ("# ICMPv6 packets dropped (type not allowed)"),
            1,
            GNUNET_NO);
          return;
        }
        /* end of AF_INET6 */
        break;
 
      default:
        GNUNET_assert (0);
      }
 
      /* update length calculations, as payload_length may have changed */
      mlen = sizeof(struct GNUNET_EXIT_IcmpInternetMessage) + alen
             + payload_length - sizeof(struct GNUNET_TUN_IcmpHeader);
      if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
      {
        GNUNET_break (0);
        return;
      }
      env = GNUNET_MQ_msg_extra (iim,
                                 alen + payload_length
                                 - sizeof(struct GNUNET_TUN_IcmpHeader),
                                 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET);
      iim->icmp_header = *icmp;
      iim->icmp_header.type = new_type;
      iim->af = htonl (destination->details.exit_destination.af);
      switch (destination->details.exit_destination.af)
      {
      case AF_INET:
        ip4dst = (struct in_addr *) &iim[1];
        *ip4dst = destination->details.exit_destination.ip.v4;
        payload_tmp = &ip4dst[1];
        break;
 
      case AF_INET6:
        ip6dst = (struct in6_addr *) &iim[1];
        *ip6dst = destination->details.exit_destination.ip.v6;
        payload_tmp = &ip6dst[1];
        break;
 
      default:
        GNUNET_assert (0);
      }
      GNUNET_memcpy (payload_tmp,
                     &icmp[1],
                     payload_length - sizeof(struct GNUNET_TUN_IcmpHeader));
    }
    break;
 
  default:
    /* not supported above, how can we get here !? */
    GNUNET_assert (0);
    break;
  }
  ts->is_established = GNUNET_YES;
  send_to_channel (ts, env);
}

References _, GNUNET_EXIT_TcpInternetStartMessage::af, GNUNET_EXIT_UdpInternetMessage::af, GNUNET_EXIT_IcmpServiceMessage::af, GNUNET_EXIT_IcmpInternetMessage::af, DestinationEntry::af, ChannelState::af, ChannelState::channel, channel_heap, channel_map, create_channel_to_destination(), DestinationChannel::destination, ChannelState::destination, ChannelState::destination_ip, GNUNET_EXIT_UdpServiceMessage::destination_port, GNUNET_EXIT_UdpInternetMessage::destination_port, DestinationChannel::destination_port, ChannelState::destination_port, DestinationEntry::details, DestinationEntry::dt_head, DestinationEntry::dt_tail, env, DestinationEntry::exit_destination, expire_channel(), get_channel_key_from_ips(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_update_cost(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET, GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE, GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT, GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START, GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START, GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET, GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE, GNUNET_MQ_msg_extra, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), 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_YES, ChannelState::heap_node, GNUNET_EXIT_IcmpServiceMessage::icmp_header, GNUNET_EXIT_IcmpInternetMessage::icmp_header, DestinationEntry::ip, ChannelState::is_established, DestinationEntry::is_service, key, max_channel_mappings, DestinationChannel::next, payload, print_channel_destination(), ChannelState::protocol, GNUNET_EXIT_TcpServiceStartMessage::reserved, GNUNET_EXIT_TcpDataMessage::reserved, ChannelState::search, send_to_channel(), DestinationEntry::service_descriptor, DestinationEntry::service_destination, ChannelState::source_ip, GNUNET_EXIT_UdpServiceMessage::source_port, GNUNET_EXIT_UdpInternetMessage::source_port, ChannelState::source_port, stats, DestinationEntry::target, tcp, GNUNET_EXIT_TcpServiceStartMessage::tcp_header, GNUNET_EXIT_TcpInternetStartMessage::tcp_header, GNUNET_EXIT_TcpDataMessage::tcp_header, GNUNET_TUN_IcmpHeader::type, udp, DestinationEntry::v4, ChannelState::v4, DestinationEntry::v6, and ChannelState::v6.

Referenced by message_token().

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 (someone send to the local virtual channel interface).

Find the destination mapping, and if it exists, identify the correct CADET channel (or possibly create it) and forward the packet.

Parameters

cls	closure, NULL
message	message we got from the client (VPN channel interface)

Returns

GNUNET_OK on success, GNUNET_NO to stop further processing (no error) GNUNET_SYSERR to stop further processing with error

Definition at line 2273 of file gnunet-service-vpn.c.

{
  const struct GNUNET_TUN_Layer2PacketHeader *tun;
  size_t mlen;
  struct GNUNET_HashCode key;
  struct DestinationEntry *de;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop (
                              "# Packets received from TUN interface"),
                            1,
                            GNUNET_NO);
  mlen = ntohs (message->size);
  if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER) ||
      (mlen < sizeof(struct GNUNET_MessageHeader)
       + sizeof(struct GNUNET_TUN_Layer2PacketHeader)))
  {
    GNUNET_break (0);
    return GNUNET_OK;
  }
  tun = (const struct GNUNET_TUN_Layer2PacketHeader *) &message[1];
  mlen -= (sizeof(struct GNUNET_MessageHeader)
           + sizeof(struct GNUNET_TUN_Layer2PacketHeader));
  switch (ntohs (tun->proto))
  {
  case ETH_P_IPV6: {
      const struct GNUNET_TUN_IPv6Header *pkt6;
 
      if (mlen < sizeof(struct GNUNET_TUN_IPv6Header))
      {
        /* blame kernel */
        GNUNET_break (0);
        return GNUNET_OK;
      }
      pkt6 = (const struct GNUNET_TUN_IPv6Header *) &tun[1];
      get_destination_key_from_ip (AF_INET6, &pkt6->destination_address, &key);
      de = GNUNET_CONTAINER_multihashmap_get (destination_map, &key);
      if (NULL == de)
      {
        char buf[INET6_ADDRSTRLEN];
 
        GNUNET_log (
          GNUNET_ERROR_TYPE_INFO,
          _ ("Packet received for unmapped destination `%s' (dropping it)\n"),
          inet_ntop (AF_INET6, &pkt6->destination_address, buf, sizeof(buf)));
        return GNUNET_OK;
      }
      route_packet (de,
                    AF_INET6,
                    pkt6->next_header,
                    &pkt6->source_address,
                    &pkt6->destination_address,
                    &pkt6[1],
                    mlen - sizeof(struct GNUNET_TUN_IPv6Header));
    }
    break;
 
  case ETH_P_IPV4: {
      struct GNUNET_TUN_IPv4Header *pkt4;
 
      if (mlen < sizeof(struct GNUNET_TUN_IPv4Header))
      {
        /* blame kernel */
        GNUNET_break (0);
        return GNUNET_OK;
      }
      pkt4 = (struct GNUNET_TUN_IPv4Header *) &tun[1];
      get_destination_key_from_ip (AF_INET, &pkt4->destination_address, &key);
      de = GNUNET_CONTAINER_multihashmap_get (destination_map, &key);
      if (NULL == de)
      {
        char buf[INET_ADDRSTRLEN];
 
        GNUNET_log (
          GNUNET_ERROR_TYPE_INFO,
          _ ("Packet received for unmapped destination `%s' (dropping it)\n"),
          inet_ntop (AF_INET, &pkt4->destination_address, buf, sizeof(buf)));
        return GNUNET_OK;
      }
      if (pkt4->header_length * 4 != sizeof(struct GNUNET_TUN_IPv4Header))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                    _ ("Received IPv4 packet with options (dropping it)\n"));
        return GNUNET_OK;
      }
      route_packet (de,
                    AF_INET,
                    pkt4->protocol,
                    &pkt4->source_address,
                    &pkt4->destination_address,
                    &pkt4[1],
                    mlen - sizeof(struct GNUNET_TUN_IPv4Header));
    }
    break;
 
  default:
    GNUNET_log (
      GNUNET_ERROR_TYPE_INFO,
      _ ("Received packet of unknown protocol %d from TUN (dropping it)\n"),
      (unsigned int) ntohs (tun->proto));
    break;
  }
  return GNUNET_OK;
}

References _, GNUNET_TUN_IPv4Header::destination_address, GNUNET_TUN_IPv6Header::destination_address, destination_map, ETH_P_IPV4, ETH_P_IPV6, get_destination_key_from_ip(), gettext_noop, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MESSAGE_TYPE_VPN_HELPER, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TUN_IPv4Header::header_length, key, GNUNET_TUN_IPv6Header::next_header, GNUNET_TUN_Layer2PacketHeader::proto, GNUNET_TUN_IPv4Header::protocol, route_packet(), GNUNET_MessageHeader::size, GNUNET_TUN_IPv4Header::source_address, GNUNET_TUN_IPv6Header::source_address, stats, and GNUNET_MessageHeader::type.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_v4_address()

static int allocate_v4_address ( struct in_addr *  v4 )

static

Allocate an IPv4 address from the range of the channel for a new redirection.

Parameters

v4	where to store the address

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2388 of file gnunet-service-vpn.c.

{
  const char *ipv4addr = vpn_argv[4];
  const char *ipv4mask = vpn_argv[5];
  struct in_addr addr;
  struct in_addr mask;
  struct in_addr rnd;
  struct GNUNET_HashCode key;
  unsigned int tries;
 
  GNUNET_assert (1 == inet_pton (AF_INET, ipv4addr, &addr));
  GNUNET_assert (1 == inet_pton (AF_INET, ipv4mask, &mask));
  /* 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;
  tries = 0;
  do
  {
    tries++;
    if (tries > 16)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "Failed to find unallocated IPv4 address in VPN's range\n"))
      ;
      return GNUNET_SYSERR;
    }
    /* Pick random IPv4 address within the subnet, except 'addr' or 'mask' itself */
    rnd.s_addr =
      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
    v4->s_addr = (addr.s_addr | rnd.s_addr) & mask.s_addr;
    get_destination_key_from_ip (AF_INET, v4, &key);
  }
  while ((GNUNET_YES ==
          GNUNET_CONTAINER_multihashmap_contains (destination_map, &key)) ||
         (v4->s_addr == addr.s_addr) || (v4->s_addr == mask.s_addr));
  return GNUNET_OK;
}

References _, destination_map, get_destination_key_from_ip(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, key, and vpn_argv.

Referenced by allocate_response_ip().

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_v6_address()

static int allocate_v6_address ( struct in6_addr *  v6 )

static

Allocate an IPv6 address from the range of the channel for a new redirection.

Parameters

v6	where to store the address

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2437 of file gnunet-service-vpn.c.

{
  const char *ipv6addr = vpn_argv[2];
  struct in6_addr addr;
  struct in6_addr mask;
  struct in6_addr rnd;
  int i;
  struct GNUNET_HashCode key;
  unsigned int tries;
 
  GNUNET_assert (1 == inet_pton (AF_INET6, ipv6addr, &addr));
  GNUNET_assert (ipv6prefix < 128);
  /* 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 */
  tries = 0;
  do
  {
    tries++;
    if (tries > 16)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "Failed to find unallocated IPv6 address in VPN's range\n"))
      ;
      return GNUNET_SYSERR;
    }
    for (i = 0; i < 16; i++)
    {
      rnd.s6_addr[i] =
        (unsigned char) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                                  256);
      v6->s6_addr[i] = (addr.s6_addr[i] | rnd.s6_addr[i]) & mask.s6_addr[i];
    }
    get_destination_key_from_ip (AF_INET6, v6, &key);
  }
  while ((GNUNET_YES ==
          GNUNET_CONTAINER_multihashmap_contains (destination_map, &key)) ||
         (0 == GNUNET_memcmp (v6, &addr)) ||
         (0 == GNUNET_memcmp (v6, &mask)));
  return GNUNET_OK;
}

References _, destination_map, get_destination_key_from_ip(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcmp, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ipv6prefix, key, and vpn_argv.

Referenced by allocate_response_ip().

Here is the call graph for this function:

Here is the caller graph for this function:

free_destination_entry()

static void free_destination_entry ( struct DestinationEntry *  de )

static

Free resources occupied by a destination entry.

Parameters

de	entry to free

Definition at line 2491 of file gnunet-service-vpn.c.

{
  struct DestinationChannel *dt;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Cleaning up destination entry `%s'\n",
              print_channel_destination (de));
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# Active destinations"),
                            -1,
                            GNUNET_NO);
  while (NULL != (dt = de->dt_head))
  {
    GNUNET_CONTAINER_DLL_remove (de->dt_head, de->dt_tail, dt);
    GNUNET_free (dt);
  }
  if (NULL != de->heap_node)
  {
    GNUNET_CONTAINER_heap_remove_node (de->heap_node);
    de->heap_node = NULL;
    GNUNET_assert (
      GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_remove (destination_map, &de->key, de));
  }
  GNUNET_free (de);
}

References destination_map, DestinationEntry::dt_head, DestinationEntry::dt_tail, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, DestinationEntry::heap_node, DestinationEntry::key, print_channel_destination(), and stats.

Referenced by cleanup_destination(), and expire_destination().

Here is the call graph for this function:

Here is the caller graph for this function:

expire_destination()

static void expire_destination ( struct DestinationEntry *  except )

static

We have too many active destinations.

Clean up the oldest destination.

Parameters

except

destination that must NOT be cleaned up, even if it is the oldest

Definition at line 2525 of file gnunet-service-vpn.c.

{
  struct DestinationEntry *de;
 
  de = GNUNET_CONTAINER_heap_peek (destination_heap);
  GNUNET_assert (NULL != de);
  if (except == de)
    return; /* can't do this */
  free_destination_entry (de);
}

References destination_heap, free_destination_entry(), GNUNET_assert, and GNUNET_CONTAINER_heap_peek().

Referenced by handle_client_redirect_to_ip(), and handle_client_redirect_to_service().

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_response_ip()

static int allocate_response_ip ( int *  result_af, void **  addr, struct in_addr *  v4, struct in6_addr *  v6  )

static

Allocate an IP address for the response.

Parameters

result_af	desired address family; set to the actual address family; can initially be AF_UNSPEC if there is no preference; will be set to AF_UNSPEC if the allocation failed
addr	set to either v4 or v6 depending on which storage location was used; set to NULL if allocation failed
v4	storage space for an IPv4 address
v6	storage space for an IPv6 address

Returns

GNUNET_OK normally, GNUNET_SYSERR if * result_af was an unsupported address family (not AF_INET, AF_INET6 or AF_UNSPEC)

Definition at line 2552 of file gnunet-service-vpn.c.

{
  *addr = NULL;
  switch (*result_af)
  {
  case AF_INET:
    if (GNUNET_OK != allocate_v4_address (v4))
      *result_af = AF_UNSPEC;
    else
      *addr = v4;
    break;
 
  case AF_INET6:
    if (GNUNET_OK != allocate_v6_address (v6))
      *result_af = AF_UNSPEC;
    else
      *addr = v6;
    break;
 
  case AF_UNSPEC:
    if (GNUNET_OK == allocate_v4_address (v4))
    {
      *addr = v4;
      *result_af = AF_INET;
    }
    else if (GNUNET_OK == allocate_v6_address (v6))
    {
      *addr = v6;
      *result_af = AF_INET6;
    }
    break;
 
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References allocate_v4_address(), allocate_v6_address(), GNUNET_break, GNUNET_OK, GNUNET_SYSERR, DestinationEntry::v4, and DestinationEntry::v6.

Referenced by handle_client_redirect_to_ip(), and handle_client_redirect_to_service().

Here is the call graph for this function:

Here is the caller graph for this function:

check_client_redirect_to_ip()

static int check_client_redirect_to_ip ( void *  cls, const struct RedirectToIpRequestMessage *  msg  )

static

A client asks us to setup a redirection via some exit node to a particular IP.

Check if msg is well-formed. allocated IP.

Parameters

cls	client requesting client
msg	redirection request

Returns

GNUNET_OK if msg is well-formed

Definition at line 2605 of file gnunet-service-vpn.c.

{
  size_t alen;
  int addr_af;
 
  alen = ntohs (msg->header.size) - sizeof(struct RedirectToIpRequestMessage);
  addr_af = (int) htonl (msg->addr_af);
  switch (addr_af)
  {
  case AF_INET:
    if (alen != sizeof(struct in_addr))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    break;
 
  case AF_INET6:
    if (alen != sizeof(struct in6_addr))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    break;
 
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References RedirectToIpRequestMessage::addr_af, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

handle_client_redirect_to_ip()

static void handle_client_redirect_to_ip ( void *  cls, const struct RedirectToIpRequestMessage *  msg  )

static

A client asks us to setup a redirection via some exit node to a particular IP.

Setup the redirection and give the client the allocated IP.

Parameters

cls	client requesting client
msg	redirection request

Definition at line 2648 of file gnunet-service-vpn.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  size_t alen;
  int addr_af;
  int result_af;
  struct in_addr v4;
  struct in6_addr v6;
  void *addr;
  struct DestinationEntry *de;
  struct GNUNET_HashCode key;
 
  alen = ntohs (msg->header.size) - sizeof(struct RedirectToIpRequestMessage);
  addr_af = (int) htonl (msg->addr_af);
  /* allocate response IP */
  result_af = (int) htonl (msg->result_af);
  if (GNUNET_OK != allocate_response_ip (&result_af, &addr, &v4, &v6))
  {
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  /* send reply with our IP address */
  send_client_reply (client, msg->request_id, result_af, addr);
  if (result_af == AF_UNSPEC)
  {
    /* failure, we're done */
    GNUNET_SERVICE_client_continue (client);
    return;
  }
 
  {
    char sbuf[INET6_ADDRSTRLEN];
    char dbuf[INET6_ADDRSTRLEN];
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Allocated address %s for redirection via exit to %s\n",
                inet_ntop (result_af, addr, sbuf, sizeof(sbuf)),
                inet_ntop (addr_af, &msg[1], dbuf, sizeof(dbuf)));
  }
 
  /* setup destination record */
  de = GNUNET_new (struct DestinationEntry);
  de->is_service = GNUNET_NO;
  de->details.exit_destination.af = addr_af;
  GNUNET_memcpy (&de->details.exit_destination.ip, &msg[1], alen);
  get_destination_key_from_ip (result_af, addr, &key);
  de->key = key;
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
                   destination_map,
                   &key,
                   de,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  de->heap_node = GNUNET_CONTAINER_heap_insert (destination_heap,
                                                de,
                                                GNUNET_TIME_absolute_ntoh (
                                                  msg->expiration_time)
                                                .abs_value_us);
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# Active destinations"),
                            1,
                            GNUNET_NO);
  while (GNUNET_CONTAINER_multihashmap_size (destination_map) >
         max_destination_mappings)
    expire_destination (de);
  GNUNET_SERVICE_client_continue (client);
}

References GNUNET_TIME_Absolute::abs_value_us, RedirectToIpRequestMessage::addr_af, DestinationEntry::af, allocate_response_ip(), destination_heap, destination_map, DestinationEntry::details, DestinationEntry::exit_destination, expire_destination(), get_destination_key_from_ip(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), DestinationEntry::heap_node, DestinationEntry::ip, DestinationEntry::is_service, key, DestinationEntry::key, max_destination_mappings, msg, RedirectToIpRequestMessage::result_af, send_client_reply(), GNUNET_MessageHeader::size, and stats.

Here is the call graph for this function:

handle_client_redirect_to_service()

static void handle_client_redirect_to_service ( void *  cls, const struct RedirectToServiceRequestMessage *  msg  )

static

A client asks us to setup a redirection to a particular peer offering a service.

Setup the redirection and give the client the allocated IP.

Parameters

cls	requesting client
msg	redirection request

Definition at line 2726 of file gnunet-service-vpn.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  int result_af;
  struct in_addr v4;
  struct in6_addr v6;
  void *addr;
  struct DestinationEntry *de;
  struct GNUNET_HashCode key;
  struct DestinationChannel *dt;
 
  /* allocate response IP */
  result_af = (int) htonl (msg->result_af);
  if (GNUNET_OK != allocate_response_ip (&result_af, &addr, &v4, &v6))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  send_client_reply (client, msg->request_id, result_af, addr);
  if (result_af == AF_UNSPEC)
  {
    /* failure, we're done */
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to allocate IP address for new destination\n"));
    GNUNET_SERVICE_client_continue (client);
    return;
  }
 
  {
    char sbuf[INET6_ADDRSTRLEN];
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Allocated address %s for redirection to service %s on peer %s\n",
                inet_ntop (result_af, addr, sbuf, sizeof(sbuf)),
                GNUNET_h2s (&msg->service_descriptor),
                GNUNET_i2s (&msg->target));
  }
 
  /* setup destination record */
  de = GNUNET_new (struct DestinationEntry);
  de->is_service = GNUNET_YES;
  de->details.service_destination.target = msg->target;
  de->details.service_destination.service_descriptor = msg->service_descriptor;
  get_destination_key_from_ip (result_af, addr, &key);
  de->key = key;
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
                   destination_map,
                   &key,
                   de,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  de->heap_node = GNUNET_CONTAINER_heap_insert (destination_heap,
                                                de,
                                                GNUNET_TIME_absolute_ntoh (
                                                  msg->expiration_time)
                                                .abs_value_us);
  while (GNUNET_CONTAINER_multihashmap_size (destination_map) >
         max_destination_mappings)
    expire_destination (de);
 
  dt = GNUNET_new (struct DestinationChannel);
  dt->destination = de;
  GNUNET_CONTAINER_DLL_insert (de->dt_head, de->dt_tail, dt);
  /* we're done */
  GNUNET_SERVICE_client_continue (client);
}

References _, GNUNET_TIME_Absolute::abs_value_us, allocate_response_ip(), DestinationChannel::destination, destination_heap, destination_map, DestinationEntry::details, DestinationEntry::dt_head, DestinationEntry::dt_tail, expire_destination(), get_destination_key_from_ip(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, DestinationEntry::heap_node, DestinationEntry::is_service, key, DestinationEntry::key, max_destination_mappings, msg, send_client_reply(), DestinationEntry::service_descriptor, DestinationEntry::service_destination, and DestinationEntry::target.

Here is the call graph for this function:

cleanup_destination()

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

static

Free memory occupied by an entry in the destination map.

Parameters

cls	unused
key	unused
value	a struct DestinationEntry *

Returns

GNUNET_OK (continue to iterate)

Definition at line 2805 of file gnunet-service-vpn.c.

{
  struct DestinationEntry *de = value;
 
  free_destination_entry (de);
  return GNUNET_OK;
}

References free_destination_entry(), GNUNET_OK, and value.

Referenced by cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_channel()

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

static

Free memory occupied by an entry in the channel map.

Parameters

cls	unused
key	unused
value	a struct ChannelState *

Returns

GNUNET_OK (continue to iterate)

Definition at line 2823 of file gnunet-service-vpn.c.

{
  struct ChannelState *ts = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Tearing down channel to `%s' during cleanup\n",
              print_channel_destination (&ts->destination));
  free_channel_state (ts);
  return GNUNET_OK;
}

References ChannelState::destination, free_channel_state(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, print_channel_destination(), and value.

Referenced by cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup()

static void cleanup ( void *  cls )

static

Function scheduled as very last function, cleans up after us.

Parameters

cls

unused

Definition at line 2841 of file gnunet-service-vpn.c.

{
  unsigned int i;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "VPN is shutting down\n");
  if (NULL != destination_map)
  {
    GNUNET_CONTAINER_multihashmap_iterate (destination_map,
                                           &cleanup_destination,
                                           NULL);
    GNUNET_CONTAINER_multihashmap_destroy (destination_map);
    destination_map = NULL;
  }
  if (NULL != destination_heap)
  {
    GNUNET_CONTAINER_heap_destroy (destination_heap);
    destination_heap = NULL;
  }
  if (NULL != channel_map)
  {
    GNUNET_CONTAINER_multihashmap_iterate (channel_map, &cleanup_channel, NULL);
    GNUNET_CONTAINER_multihashmap_destroy (channel_map);
    channel_map = NULL;
  }
  if (NULL != channel_heap)
  {
    GNUNET_CONTAINER_heap_destroy (channel_heap);
    channel_heap = NULL;
  }
  if (NULL != cadet_handle)
  {
    GNUNET_CADET_disconnect (cadet_handle);
    cadet_handle = NULL;
  }
  if (NULL != helper_handle)
  {
    GNUNET_HELPER_kill (helper_handle, GNUNET_NO);
    GNUNET_HELPER_wait (helper_handle);
    helper_handle = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  for (i = 0; i < 5; i++)
    GNUNET_free (vpn_argv[i]);
}

References cadet_handle, channel_heap, channel_map, cleanup_channel(), cleanup_destination(), destination_heap, destination_map, GNUNET_CADET_disconnect(), GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELPER_kill(), GNUNET_HELPER_wait(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_destroy(), helper_handle, stats, and vpn_argv.

Here is the call graph for this function:

client_connect_cb()

static void * client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, struct GNUNET_MQ_Handle *  mq  )

static

Callback called when a client connects to the service.

Parameters

cls	closure for the service
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

c

Definition at line 2900 of file gnunet-service-vpn.c.

{
  return c;
}

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, void *  internal_cls  )

static

Callback called when a client disconnected from the service.

Parameters

cls	closure for the service
c	the client that disconnected
internal_cls	should be equal to c

Definition at line 2916 of file gnunet-service-vpn.c.

{
  GNUNET_assert (c == internal_cls);
}

References GNUNET_assert.

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg_, struct GNUNET_SERVICE_Handle *  service  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
cfg_	configuration
service	the initialized service

Definition at line 2932 of file gnunet-service-vpn.c.

{
  char *ifname;
  char *ipv6addr;
  char *ipv6prefix_s;
  char *ipv4addr;
  char *ipv4mask;
  struct in_addr v4;
  struct in6_addr v6;
  char *binary;
 
  cfg = cfg_;
  binary = GNUNET_OS_get_suid_binary_path (GNUNET_OS_project_data_gnunet (),
                                           cfg,
                                           "gnunet-helper-vpn");
 
  if (GNUNET_YES !=
      GNUNET_OS_check_helper_binary (
        binary,
        GNUNET_YES,
        "-d gnunet-vpn - - 169.1.3.3.7 255.255.255.0")) // ipv4 only please!
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "`%s' is not SUID or the path is invalid, refusing to run.\n",
                binary);
    GNUNET_free (binary);
    global_ret = 1;
    /* we won't "really" exit here, as the 'service' is still running;
       however, as no handlers are registered, the service won't do
       anything either */
    return;
  }
  stats = GNUNET_STATISTICS_create ("vpn", cfg);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "VPN",
                                             "MAX_MAPPING",
                                             &max_destination_mappings))
    max_destination_mappings = 200;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "VPN",
                                             "MAX_TUNNELS",
                                             &max_channel_mappings))
    max_channel_mappings = 200;
 
  destination_map =
    GNUNET_CONTAINER_multihashmap_create (max_destination_mappings * 2,
                                          GNUNET_NO);
  destination_heap =
    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  channel_map =
    GNUNET_CONTAINER_multihashmap_create (max_channel_mappings * 2, GNUNET_NO);
  channel_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
 
 
  vpn_argv[0] = GNUNET_strdup ("vpn-gnunet");
  if (GNUNET_SYSERR ==
      GNUNET_CONFIGURATION_get_value_string (cfg, "VPN", "IFNAME", &ifname))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "VPN", "IFNAME");
    GNUNET_free (binary);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  vpn_argv[1] = ifname;
  ipv6addr = NULL;
  if (GNUNET_OK == GNUNET_NETWORK_test_pf (PF_INET6))
  {
    if (((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
                                                                  "VPN",
                                                                  "IPV6ADDR",
                                                                  &ipv6addr)) ||
         (1 != inet_pton (AF_INET6, ipv6addr, &v6))))
    {
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 "VPN",
                                 "IPV6ADDR",
                                 _ ("Must specify valid IPv6 address"));
      GNUNET_free (binary);
      GNUNET_SCHEDULER_shutdown ();
      GNUNET_free (ipv6addr);
      return;
    }
    vpn_argv[2] = ipv6addr;
    ipv6prefix_s = NULL;
    if (GNUNET_SYSERR ==
        GNUNET_CONFIGURATION_get_value_string (cfg,
                                               "VPN",
                                               "IPV6PREFIX",
                                               &ipv6prefix_s))
    {
      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                 "VPN",
                                 "IPV6PREFIX");
      GNUNET_SCHEDULER_shutdown ();
      GNUNET_free (ipv6prefix_s);
      return;
    }
    vpn_argv[3] = ipv6prefix_s;
    if ((GNUNET_OK !=
         GNUNET_CONFIGURATION_get_value_number (cfg,
                                                "VPN",
                                                "IPV6PREFIX",
                                                &ipv6prefix)) ||
        (ipv6prefix >= 127))
    {
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 "VPN",
                                 "IPV4MASK",
                                 _ ("Must specify valid IPv6 mask"));
      GNUNET_free (binary);
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "IPv6 support disabled as this system does not support IPv6\n"));
    vpn_argv[2] = GNUNET_strdup ("-");
    vpn_argv[3] = GNUNET_strdup ("-");
  }
  if (GNUNET_OK == GNUNET_NETWORK_test_pf (PF_INET))
  {
    ipv4addr = NULL;
    if (((GNUNET_SYSERR ==
          GNUNET_CONFIGURATION_get_value_string (cfg,
                                                 "vpn",
                                                 "IPV4ADDR",
                                                 &ipv4addr)) ||
         (1 != inet_pton (AF_INET, ipv4addr, &v4))))
    {
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 "VPN",
                                 "IPV4ADDR",
                                 _ ("Must specify valid IPv4 address"));
      GNUNET_free (binary);
      GNUNET_SCHEDULER_shutdown ();
      GNUNET_free (ipv4addr);
      return;
    }
    vpn_argv[4] = ipv4addr;
    ipv4mask = NULL;
    if (((GNUNET_SYSERR ==
          GNUNET_CONFIGURATION_get_value_string (cfg,
                                                 "vpn",
                                                 "IPV4MASK",
                                                 &ipv4mask)) ||
         (1 != inet_pton (AF_INET, ipv4mask, &v4))))
    {
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 "VPN",
                                 "IPV4MASK",
                                 _ ("Must specify valid IPv4 mask"));
      GNUNET_free (binary);
      GNUNET_SCHEDULER_shutdown ();
      GNUNET_free (ipv4mask);
      return;
    }
    vpn_argv[5] = ipv4mask;
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "IPv4 support disabled as this system does not support IPv4\n"));
    vpn_argv[4] = GNUNET_strdup ("-");
    vpn_argv[5] = GNUNET_strdup ("-");
  }
  vpn_argv[6] = NULL;
 
  cadet_handle = GNUNET_CADET_connect (cfg_);
  // FIXME never opens ports???
  helper_handle = GNUNET_HELPER_start (GNUNET_OS_project_data_gnunet (),
                                       GNUNET_NO,
                                       binary,
                                       vpn_argv,
                                       &message_token,
                                       NULL,
                                       NULL);
  GNUNET_free (binary);
  GNUNET_SCHEDULER_add_shutdown (&cleanup, NULL);
}

References _, cadet_handle, cfg, channel_heap, channel_map, cleanup(), destination_heap, destination_map, global_ret, GNUNET_CADET_connect(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELPER_start(), GNUNET_log, GNUNET_log_config_invalid(), GNUNET_log_config_missing(), GNUNET_NETWORK_test_pf(), GNUNET_NO, GNUNET_OK, GNUNET_OS_check_helper_binary(), GNUNET_OS_get_suid_binary_path(), GNUNET_OS_project_data_gnunet(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, helper_handle, ipv6prefix, max_channel_mappings, max_destination_mappings, message_token(), stats, and vpn_argv.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"vpn"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(client_redirect_to_ip, GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_IP, struct RedirectToIpRequestMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_redirect_to_service, GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_SERVICE, struct RedirectToServiceRequestMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

global_ret

int global_ret

static

Return value from main().

Definition at line 304 of file gnunet-service-vpn.c.

Referenced by run().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration we use.

Definition at line 309 of file gnunet-service-vpn.c.

Referenced by create_channel_to_destination(), and run().

cadet_handle

struct GNUNET_CADET_Handle* cadet_handle

static

Handle to the cadet service.

Definition at line 314 of file gnunet-service-vpn.c.

Referenced by cleanup(), create_channel(), and run().

destination_map

struct GNUNET_CONTAINER_MultiHashMap* destination_map

static

Map from IP address to destination information (possibly with a CADET channel handle for fast setup).

Definition at line 320 of file gnunet-service-vpn.c.

Referenced by allocate_v4_address(), allocate_v6_address(), cleanup(), free_destination_entry(), handle_client_redirect_to_ip(), handle_client_redirect_to_service(), message_token(), and run().

destination_heap

struct GNUNET_CONTAINER_Heap* destination_heap

static

Min-Heap sorted by activity time to expire old mappings.

Definition at line 325 of file gnunet-service-vpn.c.

Referenced by cleanup(), expire_destination(), handle_client_redirect_to_ip(), handle_client_redirect_to_service(), and run().

channel_map

struct GNUNET_CONTAINER_MultiHashMap* channel_map

static

Map from source and destination address (IP+port) to connection information (mostly with the respective CADET channel handle).

Definition at line 331 of file gnunet-service-vpn.c.

Referenced by cleanup(), free_channel_state(), route_packet(), and run().

channel_heap

struct GNUNET_CONTAINER_Heap* channel_heap

static

Min-Heap sorted by activity time to expire old mappings; values are of type 'struct ChannelState'.

Definition at line 337 of file gnunet-service-vpn.c.

Referenced by cleanup(), expire_channel(), route_packet(), and run().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Statistics.

Definition at line 342 of file gnunet-service-vpn.c.

Referenced by cleanup(), create_channel_to_destination(), free_channel_state(), free_destination_entry(), handle_client_redirect_to_ip(), handle_icmp_back(), handle_tcp_back(), handle_udp_back(), message_token(), route_packet(), run(), and send_to_channel().

helper_handle

struct GNUNET_HELPER_Handle* helper_handle

static

The handle to the VPN helper process "gnunet-helper-vpn".

Definition at line 347 of file gnunet-service-vpn.c.

Referenced by cleanup(), handle_icmp_back(), handle_tcp_back(), handle_udp_back(), and run().

vpn_argv

char* vpn_argv[7]

static

Arguments to the vpn helper.

Definition at line 352 of file gnunet-service-vpn.c.

Referenced by allocate_v4_address(), allocate_v6_address(), cleanup(), and run().

ipv6prefix

unsigned long long ipv6prefix

static

Length of the prefix of the VPN's IPv6 network.

Definition at line 357 of file gnunet-service-vpn.c.

Referenced by allocate_v6_address(), and run().

max_destination_mappings

unsigned long long max_destination_mappings

static

If there are more than this number of address-mappings, old ones will be removed.

Definition at line 363 of file gnunet-service-vpn.c.

Referenced by handle_client_redirect_to_ip(), handle_client_redirect_to_service(), and run().

max_channel_mappings

unsigned long long max_channel_mappings

static

If there are more than this number of open channels, old ones will be removed.

Definition at line 369 of file gnunet-service-vpn.c.

Referenced by route_packet(), and run().