gnunet-nat.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_nat_service.h"

Include dependency graph for gnunet-nat.c:

Go to the source code of this file.

Functions
static void	test_finished ()
	Test if all activities have finished, and if so, terminate. More...
static void	address_cb (void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
	Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes. More...
static void	reversal_cb (void *cls, const struct sockaddr *remote_addr, socklen_t remote_addrlen)
	Signature of the callback passed to GNUNET_NAT_register(). More...
static void	do_shutdown (void *cls)
	Task run on shutdown. More...
static void	stun_read_task (void *cls)
	Task to receive incoming packets for STUN processing. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run. More...
int	main (int argc, char *const argv[])
	Main function of gnunet-nat. More...

Variables
static int	global_ret
	Value to return from main(). More...
static char *	section_name
	Name of section in configuration file to use for additional options. More...
static int	use_udp
	Flag set to 1 if we use IPPROTO_UDP. More...
static int	listen_reversal
	Flag set to 1 if we are to listen for connection reversal requests. More...
static int	use_tcp
	Flag set to 1 if we use IPPROTO_TCP. More...
static uint8_t	proto
	Protocol to use. More...
static char *	local_addr
	Local address to use for connection reversal request. More...
static char *	remote_addr
	Remote address to use for connection reversal request. More...
static int	do_stun
	Should we actually bind to #bind_addr and receive and process STUN requests? More...
static struct GNUNET_NAT_Handle *	nh
	Handle to NAT operation. More...
static struct GNUNET_NETWORK_Handle *	ls
	Listen socket for STUN processing. More...
static struct GNUNET_SCHEDULER_Task *	rtask
	Task for reading STUN packets. More...

Function Documentation

test_finished()

static void test_finished ( void  )

static

Test if all activities have finished, and if so, terminate.

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

{
  if (NULL != nh)
    return;
  if (NULL != rtask)
    return;
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_shutdown(), nh, and rtask.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

address_cb()

static void address_cb ( void *  cls, void **  app_ctx, int  add_remove, enum GNUNET_NAT_AddressClass  ac, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes.

Parameters

	cls	closure, NULL
[in,out]	app_ctx	location where the app can store stuff on add and retrieve it on remove
	add_remove	GNUNET_YES to add a new public IP address, GNUNET_NO to remove a previous (now invalid) one
	ac	address class the address belongs to
	addr	either the previous or the new public IP address
	addrlen	actual length of the addr

Definition at line 122 of file gnunet-nat.c.

{
  (void) cls;
  (void) app_ctx;
 
  fprintf (stdout,
           "%s %s (%d)\n",
           add_remove ? "+" : "-",
           GNUNET_a2s (addr, addrlen),
           (int) ac);
}

References GNUNET_a2s().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

reversal_cb()

static void reversal_cb ( void *  cls, const struct sockaddr *  remote_addr, socklen_t  remote_addrlen  )

static

Signature of the callback passed to GNUNET_NAT_register().

for a function to call whenever someone asks us to do connection reversal.

Parameters

cls	closure, NULL
remote_addr	public IP address of the other peer
remote_addrlen	actual length of the remote_addr

Definition at line 150 of file gnunet-nat.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
              "Connection reversal requested by %s\n",
              GNUNET_a2s (remote_addr, remote_addrlen));
}

References GNUNET_a2s(), GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, and remote_addr.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Task run on shutdown.

Parameters

cls

NULL

Definition at line 166 of file gnunet-nat.c.

{
  if (NULL != nh)
  {
    GNUNET_NAT_unregister (nh);
    nh = NULL;
  }
  if (NULL != ls)
  {
    GNUNET_NETWORK_socket_close (ls);
    ls = NULL;
  }
  if (NULL != rtask)
  {
    GNUNET_SCHEDULER_cancel (rtask);
    rtask = NULL;
  }
}

References GNUNET_NAT_unregister(), GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), ls, nh, and rtask.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

stun_read_task()

static void stun_read_task ( void *  cls )

static

Task to receive incoming packets for STUN processing.

Definition at line 190 of file gnunet-nat.c.

{
  ssize_t size;
 
  rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                         ls,
                                         &stun_read_task,
                                         NULL);
  size = GNUNET_NETWORK_socket_recvfrom_amount (ls);
  if (size > 0)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    global_ret = 1;
    return;
  }
  {
    char buf[size + 1];
    struct sockaddr_storage sa;
    socklen_t salen = sizeof(sa);
    ssize_t ret;
 
    ret = GNUNET_NETWORK_socket_recvfrom (ls,
                                          buf,
                                          size + 1,
                                          (struct sockaddr *) &sa,
                                          &salen);
    if (ret != size)
    {
      GNUNET_break (0);
      GNUNET_SCHEDULER_shutdown ();
      global_ret = 1;
      return;
    }
    (void) GNUNET_NAT_stun_handle_packet (nh,
                                          (const struct sockaddr *) &sa,
                                          salen,
                                          buf,
                                          ret);
  }
}

References global_ret, GNUNET_break, GNUNET_NAT_stun_handle_packet(), GNUNET_NETWORK_socket_recvfrom(), GNUNET_NETWORK_socket_recvfrom_amount(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_UNIT_FOREVER_REL, ls, nh, ret, rtask, size, and stun_read_task().

Referenced by run(), and stun_read_task().

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 *  c  )

static

Main function that will be run.

Parameters

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

Definition at line 242 of file gnunet-nat.c.

{
  uint8_t af;
  struct sockaddr *local_sa;
  struct sockaddr *remote_sa;
  socklen_t local_len;
  size_t remote_len;
 
  if (use_tcp && use_udp)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n");
    global_ret = 1;
    return;
  }
  proto = 0;
  if (use_tcp)
    proto = IPPROTO_TCP;
  if (use_udp)
    proto = IPPROTO_UDP;
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
  if (0 == proto)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Must specify either TCP or UDP\n");
    global_ret = 1;
    return;
  }
  local_len = 0;
  local_sa = NULL;
  remote_len = 0;
  remote_sa = NULL;
  if (NULL != local_addr)
  {
    local_len =
      (socklen_t) GNUNET_STRINGS_parse_socket_addr (local_addr, &af, &local_sa);
    if (0 == local_len)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Invalid socket address `%s'\n",
                  local_addr);
      goto fail_and_shutdown;
    }
  }
 
  if (NULL != remote_addr)
  {
    remote_len =
      GNUNET_STRINGS_parse_socket_addr (remote_addr, &af, &remote_sa);
    if (0 == remote_len)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Invalid socket address `%s'\n",
                  remote_addr);
      goto fail_and_shutdown;
    }
  }
 
  if (NULL != local_addr)
  {
    if (NULL == section_name)
      section_name = GNUNET_strdup ("undefined");
    nh = GNUNET_NAT_register (c,
                              section_name,
                              proto,
                              1,
                              (const struct sockaddr **) &local_sa,
                              &local_len,
                              &address_cb,
                              (listen_reversal) ? &reversal_cb : NULL,
                              NULL);
  }
  else if (listen_reversal)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                "Use of `-W` only effective in combination with `-i`\n");
    goto fail_and_shutdown;
  }
 
  if (NULL != remote_addr)
  {
    int ret;
 
    if ((NULL == nh) || (sizeof(struct sockaddr_in) != local_len))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Require IPv4 local address to initiate connection reversal\n");
      goto fail_and_shutdown;
    }
    if (sizeof(struct sockaddr_in) != remote_len)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Require IPv4 reversal target address\n");
      goto fail_and_shutdown;
    }
    GNUNET_assert (AF_INET == local_sa->sa_family);
    GNUNET_assert (AF_INET == remote_sa->sa_family);
    ret = GNUNET_NAT_request_reversal (nh,
                                       (const struct sockaddr_in *) local_sa,
                                       (const struct sockaddr_in *) remote_sa);
    switch (ret)
    {
    case GNUNET_SYSERR:
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Connection reversal internal error\n");
      break;
 
    case GNUNET_NO:
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Connection reversal unavailable\n");
      break;
 
    case GNUNET_OK:
      /* operation in progress */
      break;
    }
  }
 
  if (do_stun)
  {
    if (NULL == local_addr)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Require local address to support STUN requests\n");
      goto fail_and_shutdown;
    }
    if (IPPROTO_UDP != proto)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "STUN only supported over UDP\n");
      goto fail_and_shutdown;
    }
    ls = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, IPPROTO_UDP);
    if (NULL == ls)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Failed to create socket\n");
      goto fail_and_shutdown;
    }
    if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ls, local_sa, local_len))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to bind to %s: %s\n",
                  GNUNET_a2s (local_sa, local_len),
                  strerror (errno));
      goto fail_and_shutdown;
    }
    rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                           ls,
                                           &stun_read_task,
                                           NULL);
  }
  GNUNET_free (remote_sa);
  GNUNET_free (local_sa);
  test_finished ();
  return;
fail_and_shutdown:
  global_ret = 1;
  GNUNET_SCHEDULER_shutdown ();
  GNUNET_free (remote_sa);
  GNUNET_free (local_sa);
}

References address_cb(), do_shutdown(), do_stun, global_ret, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_free, GNUNET_log, GNUNET_NAT_register(), GNUNET_NAT_request_reversal(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_STRINGS_parse_socket_addr(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, listen_reversal, local_addr, ls, nh, proto, remote_addr, ret, reversal_cb(), rtask, section_name, stun_read_task(), test_finished(), use_tcp, and use_udp.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

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

Main function of gnunet-nat.

Parameters

argc	number of command-line arguments
argv	command line

Returns

0 on success, -1 on error

Definition at line 415 of file gnunet-nat.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string (
      'i',
      "in",
      "ADDRESS",
      gettext_noop ("which IP and port are we locally using to bind/listen to"),
      &local_addr),
 
    GNUNET_GETOPT_option_string (
      'r',
      "remote",
      "ADDRESS",
      gettext_noop (
        "which remote IP and port should be asked for connection reversal"),
      &remote_addr),
 
    GNUNET_GETOPT_option_string (
      'S',
      "section",
      NULL,
      gettext_noop (
        "name of configuration section to find additional options, such as manual host punching data"),
      &section_name),
 
    GNUNET_GETOPT_option_flag ('s',
                               "stun",
                               gettext_noop ("enable STUN processing"),
                               &do_stun),
 
    GNUNET_GETOPT_option_flag ('t', "tcp", gettext_noop ("use TCP"), &use_tcp),
 
    GNUNET_GETOPT_option_flag ('u', "udp", gettext_noop ("use UDP"), &use_udp),
 
    GNUNET_GETOPT_option_flag ('W',
                               "watch",
                               gettext_noop (
                                 "watch for connection reversal requests"),
                               &listen_reversal),
    GNUNET_GETOPT_OPTION_END
  };
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (argc,
                          argv,
                          "gnunet-nat [options]",
                          _ ("GNUnet NAT traversal autoconfigure daemon"),
                          options,
                          &run,
                          NULL))
  {
    global_ret = 1;
  }
  GNUNET_free_nz ((void *) argv);
  return global_ret;
}

References _, do_stun, gettext_noop, global_ret, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), listen_reversal, local_addr, options, remote_addr, run(), section_name, use_tcp, and use_udp.

Here is the call graph for this function:

Variable Documentation

global_ret

int global_ret

static

Value to return from main().

Definition at line 34 of file gnunet-nat.c.

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

section_name

char* section_name

static

Name of section in configuration file to use for additional options.

Definition at line 40 of file gnunet-nat.c.

Referenced by main(), and run().

use_udp

int use_udp

static

Flag set to 1 if we use IPPROTO_UDP.

Definition at line 45 of file gnunet-nat.c.

Referenced by main(), and run().

listen_reversal

int listen_reversal

static

Flag set to 1 if we are to listen for connection reversal requests.

Definition at line 50 of file gnunet-nat.c.

Referenced by main(), and run().

use_tcp

int use_tcp

static

Flag set to 1 if we use IPPROTO_TCP.

Definition at line 55 of file gnunet-nat.c.

Referenced by main(), and run().

proto

uint8_t proto

static

Protocol to use.

Definition at line 60 of file gnunet-nat.c.

Referenced by run().

local_addr

char* local_addr

static

Local address to use for connection reversal request.

Definition at line 65 of file gnunet-nat.c.

Referenced by create_conn(), main(), mq_init(), run(), and sock_read().

remote_addr

char* remote_addr

static

Remote address to use for connection reversal request.

Definition at line 70 of file gnunet-nat.c.

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

do_stun

int do_stun

static

Should we actually bind to #bind_addr and receive and process STUN requests?

Definition at line 75 of file gnunet-nat.c.

Referenced by main(), and run().

nh

struct GNUNET_NAT_Handle* nh

static

Handle to NAT operation.

Definition at line 80 of file gnunet-nat.c.

Referenced by do_shutdown(), run(), stun_read_task(), and test_finished().

ls

struct GNUNET_NETWORK_Handle* ls

static

Listen socket for STUN processing.

Definition at line 85 of file gnunet-nat.c.

Referenced by bind_v4(), bind_v6(), do_shutdown(), new_service_channel(), run(), setup_service(), start_process(), and stun_read_task().

rtask

struct GNUNET_SCHEDULER_Task* rtask

static

Task for reading STUN packets.

Definition at line 90 of file gnunet-nat.c.

Referenced by do_shutdown(), run(), stun_read_task(), and test_finished().