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.