gnunet-vpn.c File Reference

Tool to manually request VPN tunnels to be created. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_tun_lib.h"
#include "gnunet_vpn_service.h"

Include dependency graph for gnunet-vpn.c:

Go to the source code of this file.

Functions
static void	do_disconnect (void *cls)
	Shutdown. More...
static void	allocation_cb (void *cls, int af, const void *address)
	Callback invoked from the VPN service once a redirection is available. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)

Variables
static struct GNUNET_VPN_Handle *	handle
	Handle to vpn service. More...
static struct GNUNET_VPN_RedirectionRequest *	request
	Opaque redirection request handle. More...
static char *	peer_id
	Option -p: destination peer identity for service. More...
static char *	service_name
	Option -s: service name (hash to get service descriptor) More...
static char *	target_ip
	Option -i: target IP. More...
static int	ipv4
	Option -4: IPv4 requested. More...
static int	ipv6
	Option -6: IPv6 requested. More...
static int	tcp
	Option -t: TCP requested. More...
static int	udp
	Option -u: UDP requested. More...
static unsigned int	verbosity
	Selected level of verbosity. More...
static int	ret
	Global return value. More...
static struct GNUNET_TIME_Relative	duration = { 5 * 60 * 1000 }
	Option '-d': duration of the mapping. More...

Detailed Description

Tool to manually request VPN tunnels to be created.

Author

Christian Grothoff

Definition in file gnunet-vpn.c.

Function Documentation

do_disconnect()

static void do_disconnect ( void *  cls )

static

Shutdown.

Definition at line 98 of file gnunet-vpn.c.

References GNUNET_free_non_null, GNUNET_VPN_cancel_request(), GNUNET_VPN_disconnect(), peer_id, service_name, and target_ip.

Referenced by run().

{
  if (NULL != request)
  {
    GNUNET_VPN_cancel_request (request);
    request = NULL;
  }
  if (NULL != handle)
  {
    GNUNET_VPN_disconnect (handle);
    handle = NULL;
  }
  GNUNET_free_non_null (peer_id);
  GNUNET_free_non_null (service_name);
  GNUNET_free_non_null (target_ip);
}

Here is the call graph for this function:

Here is the caller graph for this function:

allocation_cb()

static void allocation_cb ( void *  cls, int  af, const void *  address  )

static

Callback invoked from the VPN service once a redirection is available.

Provides the IP address that can now be used to reach the requested destination.

Parameters

cls	closure
af	address family, AF_INET or AF_INET6; AF_UNSPEC on error; will match 'result_af' from the request
address	IP address (struct in_addr or struct in_addr6, depending on 'af') that the VPN allocated for the redirection; traffic to this IP will now be redirected to the specified target peer; NULL on error

Definition at line 130 of file gnunet-vpn.c.

References _, buf, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), and ret.

Referenced by run().

{
  char buf[INET6_ADDRSTRLEN];

  request = NULL;
  switch (af)
  {
  case AF_INET6:
  case AF_INET:
    fprintf (stdout, "%s\n", inet_ntop (af, address, buf, sizeof(buf)));
    break;

  case AF_UNSPEC:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Error creating tunnel\n"));
    ret = 1;
    break;

  default:
    break;
  }
  GNUNET_SCHEDULER_shutdown ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 163 of file gnunet-vpn.c.

References _, allocation_cb(), do_disconnect(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_relative_to_absolute(), GNUNET_TUN_service_name_to_hash(), GNUNET_VPN_connect(), GNUNET_VPN_redirect_to_ip(), GNUNET_VPN_redirect_to_peer(), ipv4, ipv6, peer_id, GNUNET_PeerIdentity::public_key, ret, service_name, target_ip, tcp, and udp.

Referenced by main().

{
  int dst_af;
  int req_af;
  struct GNUNET_PeerIdentity peer;
  struct GNUNET_HashCode sd;
  const void *addr;
  struct in_addr v4;
  struct in6_addr v6;
  uint8_t protocol;
  struct GNUNET_TIME_Absolute etime;

  etime = GNUNET_TIME_relative_to_absolute (duration);
  GNUNET_SCHEDULER_add_shutdown (&do_disconnect, NULL);
  handle = GNUNET_VPN_connect (cfg);
  if (NULL == handle)
    goto error;
  req_af = AF_UNSPEC;
  if (ipv4)
  {
    if (ipv6)
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense with option `%s'.\n"),
               "-4",
               "-6");
      goto error;
    }
    req_af = AF_INET;
  }
  if (ipv6)
    req_af = AF_INET6;

  if (NULL == target_ip)
  {
    if (NULL == service_name)
    {
      fprintf (stderr, _ ("Option `%s' or `%s' is required.\n"), "-i", "-s");
      goto error;
    }
    if (NULL == peer_id)
    {
      fprintf (stderr,
               _ ("Option `%s' is required when using option `%s'.\n"),
               "-p",
               "-s");
      goto error;
    }
    if (! (tcp | udp))
    {
      fprintf (stderr,
               _ ("Option `%s' or `%s' is required when using option `%s'.\n"),
               "-t",
               "-u",
               "-s");
      goto error;
    }
    if (tcp & udp)
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense with option `%s'.\n"),
               "-t",
               "-u");
      goto error;
    }
    if (tcp)
      protocol = IPPROTO_TCP;
    if (udp)
      protocol = IPPROTO_UDP;
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id,
                                                    strlen (peer_id),
                                                    &peer.public_key))
    {
      fprintf (stderr, _ ("`%s' is not a valid peer identifier.\n"), peer_id);
      goto error;
    }
    GNUNET_TUN_service_name_to_hash (service_name, &sd);
    request = GNUNET_VPN_redirect_to_peer (handle,
                                           req_af,
                                           protocol,
                                           &peer,
                                           &sd,
                                           etime,
                                           &allocation_cb,
                                           NULL);
  }
  else
  {
    if (1 != inet_pton (AF_INET6, target_ip, &v6))
    {
      if (1 != inet_pton (AF_INET, target_ip, &v4))
      {
        fprintf (stderr, _ ("`%s' is not a valid IP address.\n"), target_ip);
        goto error;
      }
      else
      {
        dst_af = AF_INET;
        addr = &v4;
      }
    }
    else
    {
      dst_af = AF_INET6;
      addr = &v6;
    }
    request = GNUNET_VPN_redirect_to_ip (handle,
                                         req_af,
                                         dst_af,
                                         addr,
                                         etime,
                                         &allocation_cb,
                                         NULL);
  }
  return;

error:
  GNUNET_SCHEDULER_shutdown ();
  ret = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

Definition at line 290 of file gnunet-vpn.c.

References gettext_noop, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_verbose(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), ipv4, ipv6, peer_id, ret, run(), service_name, target_ip, tcp, udp, and verbosity.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag ('4',
                               "ipv4",
                               gettext_noop (
                                 "request that result should be an IPv4 address"),
                               &ipv4),

    GNUNET_GETOPT_option_flag ('6',
                               "ipv6",
                               gettext_noop (
                                 "request that result should be an IPv6 address"),
                               &ipv6),

    GNUNET_GETOPT_option_relative_time (
      'd',
      "duration",
      "TIME",
      gettext_noop ("how long should the mapping be valid for new tunnels?"),
      &duration),

    GNUNET_GETOPT_option_string ('i',
                                 "ip",
                                 "IP",
                                 gettext_noop (
                                   "destination IP for the tunnel"),
                                 &target_ip),

    GNUNET_GETOPT_option_string (
      'p',
      "peer",
      "PEERID",
      gettext_noop ("peer offering the service we would like to access"),
      &peer_id),

    GNUNET_GETOPT_option_string ('s',
                                 "service",
                                 "NAME",
                                 gettext_noop (
                                   "name of the service we would like to access"),
                                 &service_name),

    GNUNET_GETOPT_option_flag ('t',
                               "tcp",
                               gettext_noop ("service is offered via TCP"),
                               &tcp),

    GNUNET_GETOPT_option_flag ('u',
                               "udp",
                               gettext_noop ("service is offered via UDP"),
                               &udp),

    GNUNET_GETOPT_option_verbose (&verbosity),

    GNUNET_GETOPT_OPTION_END };

  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;

  ret =
    (GNUNET_OK == GNUNET_PROGRAM_run (argc,
                                      argv,
                                      "gnunet-vpn",
                                      gettext_noop ("Setup tunnels via VPN."),
                                      options,
                                      &run,
                                      NULL))
    ? ret
    : 1;
  GNUNET_free ((void *) argv);
  return ret;
}

Here is the call graph for this function:

Variable Documentation

handle

struct GNUNET_VPN_Handle* handle

static

Handle to vpn service.

Definition at line 36 of file gnunet-vpn.c.

request

struct GNUNET_VPN_RedirectionRequest* request

static

Opaque redirection request handle.

Definition at line 41 of file gnunet-vpn.c.

Referenced by create_response(), dns_result_processor(), do_timeout(), generate_gns_certificate(), GSF_cadet_start_server(), handle_request(), listen_connect(), lookup_it_error(), lookup_it_finished(), lookup_it_processor(), open_device(), post_iterator(), put_continuation(), reconnect(), request_completed_callback(), result_processor(), zone_to_name_cb(), and zone_to_name_error().

peer_id

char* peer_id

static

Option -p: destination peer identity for service.

Definition at line 46 of file gnunet-vpn.c.

Referenced by do_disconnect(), main(), and run().

service_name

char* service_name

static

Option -s: service name (hash to get service descriptor)

Definition at line 51 of file gnunet-vpn.c.

Referenced by do_disconnect(), GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), main(), and run().

target_ip

char* target_ip

static

Option -i: target IP.

Definition at line 56 of file gnunet-vpn.c.

Referenced by do_disconnect(), main(), and run().

ipv4

int ipv4

static

Option -4: IPv4 requested.

Definition at line 61 of file gnunet-vpn.c.

Referenced by GNUNET_HOSTLIST_server_start(), handle_icmp_back(), handle_tcp_back(), handle_udp_back(), main(), and run().

ipv6

int ipv6

static

Option -6: IPv6 requested.

Definition at line 66 of file gnunet-vpn.c.

Referenced by GNUNET_HOSTLIST_server_start(), handle_icmp_back(), handle_tcp_back(), handle_udp_back(), main(), and run().

tcp

int tcp

static

Option -t: TCP requested.

Definition at line 71 of file gnunet-vpn.c.

Referenced by handle_tcp_back(), main(), route_packet(), and run().

udp

int udp

static

Option -u: UDP requested.

Definition at line 76 of file gnunet-vpn.c.

Referenced by handle_icmp_back(), handle_icmp_remote(), handle_udp_back(), icmp_from_helper(), main(), make_up_icmp_service_payload(), process_helper_messages(), request_done(), route_packet(), run(), and udp_plugin_send().

verbosity

unsigned int verbosity

static

Selected level of verbosity.

Definition at line 81 of file gnunet-vpn.c.

Referenced by main().

ret

int ret

static

Global return value.

Definition at line 86 of file gnunet-vpn.c.

Referenced by allocation_cb(), main(), and run().

duration

struct GNUNET_TIME_Relative duration = { 5 * 60 * 1000 }

static

Option '-d': duration of the mapping.

Definition at line 91 of file gnunet-vpn.c.