NAT library

Service for handling UPnP and NAT-PMP port forwarding and external IP address retrieval. More...

Collaboration diagram for NAT library:

Data Structures
struct	GNUNET_BurstSync
	Wrapper struct with the average RTT of message to some peer and if this peer und us is ready to sync. More...
struct	GNUNET_BurstMessage
	Message send during burst mode. More...
struct	GNUNET_StartBurstCls
	Struct wrapping information we use for starting the burst. More...
struct	GNUNET_UdpSocketInfo
	Struct with the socket we like to use to send messages to another peer. More...

Macros
#define	GNUNET_NAT_LIB_H

Typedefs
typedef void(*	GNUNET_NAT_AUTO_AutoResultCallback) (void *cls, const struct GNUNET_CONFIGURATION_Handle *diff, enum GNUNET_NAT_StatusCode result, enum GNUNET_NAT_Type type)
	Function called with the result from the autoconfiguration. More...
typedef void(*	GNUNET_NotifyUdpSocket) (struct GNUNET_UdpSocketInfo *sock_info)
typedef void(*	GNUNET_NAT_AddressCallback) (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...
typedef void(*	GNUNET_NAT_ReversalCallback) (void *cls, const struct sockaddr *remote_addr, socklen_t remote_addrlen)
	Signature of the callback passed to GNUNET_NAT_register(). More...
typedef void(*	GNUNET_NAT_TestCallback) (void *cls, enum GNUNET_NAT_StatusCode result)
	Function called to report success or failure for NAT configuration test. More...

Enumerations
enum	GNUNET_NAT_AddressClass {   GNUNET_NAT_AC_NONE = 0 , GNUNET_NAT_AC_OTHER = 1 , GNUNET_NAT_AC_PRIVATE = 2 , GNUNET_NAT_AC_GLOBAL = 4 ,   GNUNET_NAT_AC_GLOBAL_PRIVATE = 6 , GNUNET_NAT_AC_LAN = 8 , GNUNET_NAT_AC_LAN_PRIVATE = 10 , GNUNET_NAT_AC_WLAN = 16 ,   GNUNET_NAT_AC_BT = 32 , GNUNET_NAT_AC_LOOPBACK = 64 , GNUNET_NAT_AC_EXTERN = 128 , GNUNET_NAT_AC_MANUAL = 256 ,   GNUNET_NAT_AC_ANY = 65535 }
	Some addresses contain sensitive information or are not suitable for global distribution. More...
enum	GNUNET_NAT_StatusCode {   GNUNET_NAT_ERROR_SUCCESS = GNUNET_OK , GNUNET_NAT_ERROR_IPC_FAILURE , GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR , GNUNET_NAT_ERROR_TIMEOUT ,   GNUNET_NAT_ERROR_NOT_ONLINE , GNUNET_NAT_ERROR_UPNPC_NOT_FOUND , GNUNET_NAT_ERROR_UPNPC_FAILED , GNUNET_NAT_ERROR_UPNPC_TIMEOUT ,   GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED , GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND , GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED , GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID ,   GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID , GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO , GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND , GNUNET_NAT_ERROR_NAT_TEST_START_FAILED ,   GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT , GNUNET_NAT_ERROR_NAT_REGISTER_FAILED , GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND }
	Error Types for the NAT subsystem (which can then later be converted/resolved to a string) More...
enum	GNUNET_NAT_Type {   GNUNET_NAT_TYPE_NO_NAT = GNUNET_OK , GNUNET_NAT_TYPE_UNREACHABLE_NAT , GNUNET_NAT_TYPE_STUN_PUNCHED_NAT , GNUNET_NAT_TYPE_UPNP_NAT ,   GNUNET_NAT_TYPE_UNKNOWN }
	What the situation of the NAT connectivity. More...

Functions
struct GNUNET_NAT_AUTO_Test *	GNUNET_NAT_AUTO_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, uint8_t proto, const char *section_name, GNUNET_NAT_TestCallback report, void *report_cls)
	Start testing if NAT traversal works using the given configuration. More...
void	GNUNET_NAT_AUTO_test_stop (struct GNUNET_NAT_AUTO_Test *tst)
	Stop an active NAT test. More...
const char *	GNUNET_NAT_AUTO_status2string (enum GNUNET_NAT_StatusCode err)
	Converts enum GNUNET_NAT_StatusCode to string. More...
struct GNUNET_NAT_AUTO_AutoHandle *	GNUNET_NAT_AUTO_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NAT_AUTO_AutoResultCallback cb, void *cb_cls)
	Start auto-configuration routine. More...
void	GNUNET_NAT_AUTO_autoconfig_cancel (struct GNUNET_NAT_AUTO_AutoHandle *ah)
	Abort autoconfiguration. More...
struct GNUNET_BurstSync *	GNUNET_get_burst_sync_msg (struct GNUNET_TIME_Relative rtt_average, enum GNUNET_GenericReturnValue sync_ready)
	Create GNUNET_BurstSync message. More...
void	GNUNET_is_burst_ready (struct GNUNET_TIME_Relative rtt_average, struct GNUNET_BurstSync *burst_sync, GNUNET_SCHEDULER_TaskCallback task, struct GNUNET_StartBurstCls *task_cls)
	Checks if we are ready and starts burst when we and the other peer is ready. More...
struct GNUNET_SCHEDULER_Task *	GNUNET_get_udp_socket (struct GNUNET_UdpSocketInfo *sock_info, GNUNET_NotifyUdpSocket nus)
	Method to get a UDP socket for a peer that is natted. More...
void	GNUNET_stop_burst (struct GNUNET_NETWORK_Handle *do_not_touch)
	Method to stop all sockets we established to the other peer. More...
struct GNUNET_NAT_Handle *	GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, uint8_t proto, unsigned int num_addrs, const struct sockaddr **addrs, const socklen_t *addrlens, GNUNET_NAT_AddressCallback address_callback, GNUNET_NAT_ReversalCallback reversal_callback, void *callback_cls)
	Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on the local network. More...
void	GNUNET_NAT_add_global_address (struct GNUNET_NAT_Handle *nh, char *addr, unsigned int address_length)
	Add global address to the list of addresses and notify clients. More...
int	GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *nh, const void *addr, socklen_t addrlen)
	Test if the given address is (currently) a plausible IP address for this peer. More...
int	GNUNET_NAT_request_reversal (struct GNUNET_NAT_Handle *nh, const struct sockaddr_in *local_sa, const struct sockaddr_in *remote_sa)
	We learned about a peer (possibly behind NAT) so run the gnunet-nat-client to send dummy ICMP responses to cause that peer to connect to us (connection reversal). More...
void	GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *nh)
	Stop port redirection and public IP address detection for the given handle. More...
int	GNUNET_NAT_stun_handle_packet (struct GNUNET_NAT_Handle *nh, const struct sockaddr *sender_addr, size_t sender_addr_len, const void *data, size_t data_size)
	Handle an incoming STUN message. More...
struct GNUNET_NAT_STUN_Handle *	GNUNET_NAT_stun_make_request (const char *server, uint16_t port, struct GNUNET_NETWORK_Handle *sock, GNUNET_NAT_TestCallback cb, void *cb_cls)
	Make Generic STUN request. More...
void	GNUNET_NAT_stun_make_request_cancel (struct GNUNET_NAT_STUN_Handle *rh)
	Cancel active STUN request. More...

Detailed Description

Service for handling UPnP and NAT-PMP port forwarding and external IP address retrieval.

Macro Definition Documentation

GNUNET_NAT_LIB_H

#define GNUNET_NAT_LIB_H

Definition at line 38 of file gnunet_nat_lib.h.

Typedef Documentation

GNUNET_NAT_AUTO_AutoResultCallback

typedef void(* GNUNET_NAT_AUTO_AutoResultCallback) (void *cls, const struct GNUNET_CONFIGURATION_Handle *diff, enum GNUNET_NAT_StatusCode result, enum GNUNET_NAT_Type type)

Function called with the result from the autoconfiguration.

Parameters

cls	closure
diff	minimal suggested changes to the original configuration to make it work (as best as we can)
result	GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
type	what the situation of the NAT

Definition at line 101 of file gnunet_nat_auto_service.h.

GNUNET_NotifyUdpSocket

typedef void(* GNUNET_NotifyUdpSocket) (struct GNUNET_UdpSocketInfo *sock_info)

Definition at line 114 of file gnunet_nat_lib.h.

GNUNET_NAT_AddressCallback

typedef void(* GNUNET_NAT_AddressCallback) (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.

Parameters

cls	closure
app_ctx[in,out]	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 285 of file gnunet_nat_service.h.

GNUNET_NAT_ReversalCallback

typedef void(* GNUNET_NAT_ReversalCallback) (void *cls, const struct sockaddr *remote_addr, socklen_t remote_addrlen)

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
remote_addr	public IP address of the other peer
remote_addrlen	actual length of the remote_addr

Definition at line 303 of file gnunet_nat_service.h.

GNUNET_NAT_TestCallback

typedef void(* GNUNET_NAT_TestCallback) (void *cls, enum GNUNET_NAT_StatusCode result)

Function called to report success or failure for NAT configuration test.

Parameters

cls	closure
result	GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code

Definition at line 460 of file gnunet_nat_service.h.

Enumeration Type Documentation

GNUNET_NAT_AddressClass

enum GNUNET_NAT_AddressClass

Some addresses contain sensitive information or are not suitable for global distribution.

We use address classes to filter addresses by which domain they make sense to be used in. These are used in a bitmask.

FIXME: might want to define this elsewhere; we have an equivalent enum in gnunet_transport_hello_service.h; might ultimately belong with the new HELLO definition.

Enumerator
GNUNET_NAT_AC_NONE	No address.
GNUNET_NAT_AC_OTHER	Addresses that fall into no other category (i.e. incoming which we cannot use elsewhere).
GNUNET_NAT_AC_PRIVATE	Flag for addresses that are highly sensitive (i.e. IPv6 with our MAC).
GNUNET_NAT_AC_GLOBAL	Addresses that are global (i.e. IPv4).
GNUNET_NAT_AC_GLOBAL_PRIVATE	Addresses that are global and are sensitive (i.e. IPv6 with our MAC).
GNUNET_NAT_AC_LAN	Addresses useful in the local wired network, i.e. a MAC. Sensitive, but obvious to people nearby. Useful for broadcasts.
GNUNET_NAT_AC_LAN_PRIVATE	Addresses useful in the local wired network, i.e. a MAC. Sensitive, but obvious to people nearby. Useful for broadcasts.
GNUNET_NAT_AC_WLAN	Addresses useful in the local wireless network, i.e. a MAC. Sensitive, but obvious to people nearby. Useful for broadcasts.
GNUNET_NAT_AC_BT	Addresses useful in the local bluetooth network. Sensitive, but obvious to people nearby. Useful for broadcasts.
GNUNET_NAT_AC_LOOPBACK	Loopback addresses, only useful under special circumstances.
GNUNET_NAT_AC_EXTERN	Addresses that should be our external IP address on the outside of a NAT. Might be incorrectly determined. Used as a bit in combination with GNUNET_NAT_AC_GLOBAL, or in case of double-NAT with GNUNET_NAT_AC_LAN.
GNUNET_NAT_AC_MANUAL	Addresses that were manually configured by the user. Used as a bit in combination with GNUNET_NAT_AC_GLOBAL.
GNUNET_NAT_AC_ANY	Bitmask for "any" address.

Definition at line 53 of file gnunet_nat_service.h.

{
  GNUNET_NAT_AC_NONE = 0,
 
  GNUNET_NAT_AC_OTHER = 1,
 
  GNUNET_NAT_AC_PRIVATE = 2,
 
  GNUNET_NAT_AC_GLOBAL = 4,
 
  GNUNET_NAT_AC_GLOBAL_PRIVATE = 6,
 
  GNUNET_NAT_AC_LAN = 8,
 
  GNUNET_NAT_AC_LAN_PRIVATE = 10,
 
  GNUNET_NAT_AC_WLAN = 16,
 
  GNUNET_NAT_AC_BT = 32,
 
  GNUNET_NAT_AC_LOOPBACK = 64,
 
  GNUNET_NAT_AC_EXTERN = 128,
 
  GNUNET_NAT_AC_MANUAL = 256,
 
  GNUNET_NAT_AC_ANY = 65535
};

GNUNET_NAT_StatusCode

enum GNUNET_NAT_StatusCode

Error Types for the NAT subsystem (which can then later be converted/resolved to a string)

Enumerator
GNUNET_NAT_ERROR_SUCCESS	Just the default.
GNUNET_NAT_ERROR_IPC_FAILURE	IPC Failure.
GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR	Failure in network subsystem, check permissions.
GNUNET_NAT_ERROR_TIMEOUT	test timed out
GNUNET_NAT_ERROR_NOT_ONLINE	detected that we are offline
GNUNET_NAT_ERROR_UPNPC_NOT_FOUND	upnpc command not found
GNUNET_NAT_ERROR_UPNPC_FAILED	Failed to run upnpc command.
GNUNET_NAT_ERROR_UPNPC_TIMEOUT	‘upnpc’ command took too long, process killed
GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED	‘upnpc’ command failed to establish port mapping
GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND	‘external-ip’ command not found
GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED	Failed to run external-ip command.
GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID	‘external-ip’ command output invalid
GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID	"no valid address was returned by `external-ip'"
GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO	Could not determine interface with internal/local network address.
GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND	No working gnunet-helper-nat-server found.
GNUNET_NAT_ERROR_NAT_TEST_START_FAILED	NAT test could not be initialized.
GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT	NAT test timeout.
GNUNET_NAT_ERROR_NAT_REGISTER_FAILED	NAT test failed to initiate.
GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND

Definition at line 141 of file gnunet_nat_service.h.

{
  GNUNET_NAT_ERROR_SUCCESS = GNUNET_OK,
 
  GNUNET_NAT_ERROR_IPC_FAILURE,
 
  GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR,
 
  GNUNET_NAT_ERROR_TIMEOUT,
 
  GNUNET_NAT_ERROR_NOT_ONLINE,
 
  GNUNET_NAT_ERROR_UPNPC_NOT_FOUND,
 
  GNUNET_NAT_ERROR_UPNPC_FAILED,
 
  GNUNET_NAT_ERROR_UPNPC_TIMEOUT,
 
  GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED,
 
  GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND,
 
  GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED,
 
  GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID,
 
  GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID,
 
  GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO,
 
  GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND,
 
  GNUNET_NAT_ERROR_NAT_TEST_START_FAILED,
 
  GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT,
 
  GNUNET_NAT_ERROR_NAT_REGISTER_FAILED,
 
  GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND
};

GNUNET_NAT_Type

enum GNUNET_NAT_Type

What the situation of the NAT connectivity.

Enumerator
GNUNET_NAT_TYPE_NO_NAT	We have a direct connection.
GNUNET_NAT_TYPE_UNREACHABLE_NAT	We are under a NAT but cannot traverse it.
GNUNET_NAT_TYPE_STUN_PUNCHED_NAT	We can traverse using STUN.
GNUNET_NAT_TYPE_UPNP_NAT	We can traverse using UPNP.
GNUNET_NAT_TYPE_UNKNOWN	We know nothing about the NAT.

Definition at line 243 of file gnunet_nat_service.h.

{
  GNUNET_NAT_TYPE_NO_NAT = GNUNET_OK,
 
  GNUNET_NAT_TYPE_UNREACHABLE_NAT,
 
  GNUNET_NAT_TYPE_STUN_PUNCHED_NAT,
 
  GNUNET_NAT_TYPE_UPNP_NAT,
 
  GNUNET_NAT_TYPE_UNKNOWN
};

Function Documentation

GNUNET_NAT_AUTO_test_start()

struct GNUNET_NAT_AUTO_Test * GNUNET_NAT_AUTO_test_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		uint8_t	proto,
		const char *	section_name,
		GNUNET_NAT_TestCallback	report,
		void *	report_cls
	)

Start testing if NAT traversal works using the given configuration.

The transport adapters should be down while using this function.

Parameters

cfg	configuration for the NAT traversal
proto	protocol to test, i.e. IPPROTO_TCP or IPPROTO_UDP
section_name	configuration section to use for configuration
report	function to call with the result of the test
report_cls	closure for report

Returns

handle to cancel NAT test

Definition at line 426 of file nat_auto_api_test.c.

{
  struct GNUNET_NAT_AUTO_Test *nh;
  unsigned long long bnd_port;
  struct sockaddr_in sa;
  const struct sockaddr *addrs[] = { (const struct sockaddr *) &sa };
  const socklen_t addrlens[] = { sizeof(sa) };
 
  if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                           section_name,
                                                           "PORT",
                                                           &bnd_port)) ||
      (bnd_port > 65535))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to find valid PORT in section `%s'\n"),
                section_name);
    return NULL;
  }
 
  memset (&sa, 0, sizeof(sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons ((uint16_t) bnd_port);
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa.sin_len = sizeof(sa);
#endif
 
  nh = GNUNET_new (struct GNUNET_NAT_AUTO_Test);
  nh->cfg = cfg;
  nh->proto = proto;
  nh->section_name = GNUNET_strdup (section_name);
  nh->report = report;
  nh->report_cls = report_cls;
  nh->status = GNUNET_NAT_ERROR_SUCCESS;
  if (0 == bnd_port)
  {
    nh->nat = GNUNET_NAT_register (cfg,
                                   section_name,
                                   proto,
                                   0,
                                   NULL,
                                   NULL,
                                   &addr_cb,
                                   &reversal_cb,
                                   nh);
  }
  else
  {
    nh->lsock =
      GNUNET_NETWORK_socket_create (AF_INET,
                                    (IPPROTO_UDP == proto) ? SOCK_DGRAM
                                    : SOCK_STREAM,
                                    proto);
    if ((NULL == nh->lsock) ||
        (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock,
                                                  (const struct sockaddr *) &sa,
                                                  sizeof(sa))))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Failed to create socket bound to `%s' for NAT test: %s\n"),
           GNUNET_a2s ((const struct sockaddr *) &sa, sizeof(sa)),
           strerror (errno));
      if (NULL != nh->lsock)
      {
        GNUNET_NETWORK_socket_close (nh->lsock);
        nh->lsock = NULL;
      }
      nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR;
      nh->ttask = GNUNET_SCHEDULER_add_now (&do_fail, nh);
      return nh;
    }
    if (IPPROTO_TCP == proto)
    {
      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5));
      nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 nh->lsock,
                                                 &do_accept,
                                                 nh);
    }
    else
    {
      nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 nh->lsock,
                                                 &do_udp_read,
                                                 nh);
    }
    LOG (GNUNET_ERROR_TYPE_INFO,
         "NAT test listens on port %llu (%s)\n",
         bnd_port,
         (IPPROTO_TCP == proto) ? "tcp" : "udp");
    nh->nat = GNUNET_NAT_register (cfg,
                                   section_name,
                                   proto,
                                   1,
                                   addrs,
                                   addrlens,
                                   &addr_cb,
                                   NULL,
                                   nh);
    if (NULL == nh->nat)
    {
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("NAT test failed to start NAT library\n"));
      if (NULL != nh->ltask)
      {
        GNUNET_SCHEDULER_cancel (nh->ltask);
        nh->ltask = NULL;
      }
      if (NULL != nh->lsock)
      {
        GNUNET_NETWORK_socket_close (nh->lsock);
        nh->lsock = NULL;
      }
      nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED;
      nh->ttask = GNUNET_SCHEDULER_add_now (&do_fail, nh);
      return nh;
    }
  }
  return nh;
}

References _, addr_cb(), cfg, GNUNET_NAT_Handle::cfg, do_accept(), do_fail(), do_udp_read(), GNUNET_a2s(), GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR, GNUNET_NAT_ERROR_NAT_REGISTER_FAILED, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_register(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_listen(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, LOG, nh, proto, reversal_cb(), and section_name.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_AUTO_test_stop()

void GNUNET_NAT_AUTO_test_stop

(

struct GNUNET_NAT_AUTO_Test *

tst

)

Stop an active NAT test.

Parameters

tst	test to stop.

Definition at line 558 of file nat_auto_api_test.c.

{
  struct NatActivity *pos;
  struct ClientActivity *cpos;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n");
  while (NULL != (cpos = tst->ca_head))
  {
    GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos);
    GNUNET_MQ_destroy (cpos->mq);
    GNUNET_free (cpos);
  }
  while (NULL != (pos = tst->na_head))
  {
    GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos);
    GNUNET_SCHEDULER_cancel (pos->rtask);
    GNUNET_NETWORK_socket_close (pos->sock);
    GNUNET_free (pos);
  }
  if (NULL != tst->ttask)
  {
    GNUNET_SCHEDULER_cancel (tst->ttask);
    tst->ttask = NULL;
  }
  if (NULL != tst->ltask)
  {
    GNUNET_SCHEDULER_cancel (tst->ltask);
    tst->ltask = NULL;
  }
  if (NULL != tst->lsock)
  {
    GNUNET_NETWORK_socket_close (tst->lsock);
    tst->lsock = NULL;
  }
  if (NULL != tst->nat)
  {
    GNUNET_NAT_unregister (tst->nat);
    tst->nat = NULL;
  }
  GNUNET_free (tst->section_name);
  GNUNET_free (tst);
}

References GNUNET_NAT_AUTO_Test::ca_head, GNUNET_NAT_AUTO_Test::ca_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NAT_unregister(), GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), LOG, GNUNET_NAT_AUTO_Test::lsock, GNUNET_NAT_AUTO_Test::ltask, ClientActivity::mq, GNUNET_NAT_AUTO_Test::na_head, GNUNET_NAT_AUTO_Test::na_tail, GNUNET_NAT_AUTO_Test::nat, NatActivity::rtask, GNUNET_NAT_AUTO_Test::section_name, NatActivity::sock, and GNUNET_NAT_AUTO_Test::ttask.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_AUTO_status2string()

const char * GNUNET_NAT_AUTO_status2string

(

enum GNUNET_NAT_StatusCode

err

)

Converts enum GNUNET_NAT_StatusCode to string.

Parameters

err	error code to resolve to a string

Returns

point to a static string containing the error code

Definition at line 68 of file nat_auto_api.c.

{
  switch (err)
  {
  case GNUNET_NAT_ERROR_SUCCESS:
    return _ ("Operation Successful");
 
  case GNUNET_NAT_ERROR_IPC_FAILURE:
    return _ ("IPC failure");
 
  case GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR:
    return _ ("Failure in network subsystem, check permissions.");
 
  case GNUNET_NAT_ERROR_TIMEOUT:
    return _ ("Encountered timeout while performing operation");
 
  case GNUNET_NAT_ERROR_NOT_ONLINE:
    return _ ("detected that we are offline");
 
  case GNUNET_NAT_ERROR_UPNPC_NOT_FOUND:
    return _ ("`upnpc` command not found");
 
  case GNUNET_NAT_ERROR_UPNPC_FAILED:
    return _ ("Failed to run `upnpc` command");
 
  case GNUNET_NAT_ERROR_UPNPC_TIMEOUT:
    return _ ("`upnpc' command took too long, process killed");
 
  case GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED:
    return _ ("`upnpc' command failed to establish port mapping");
 
  case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND:
    return _ ("`external-ip' command not found");
 
  case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED:
    return _ ("Failed to run `external-ip` command");
 
  case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID:
    return _ ("`external-ip' command output invalid");
 
  case GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID:
    return _ ("no valid address was returned by `external-ip'");
 
  case GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO:
    return _ (
      "Could not determine interface with internal/local network address");
 
  case GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND:
    return _ ("No functioning gnunet-helper-nat-server installation found");
 
  case GNUNET_NAT_ERROR_NAT_TEST_START_FAILED:
    return _ ("NAT test could not be initialized");
 
  case GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT:
    return _ ("NAT test timeout reached");
 
  case GNUNET_NAT_ERROR_NAT_REGISTER_FAILED:
    return _ ("could not register NAT");
 
  case GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND:
    return _ ("No working gnunet-helper-nat-client installation found");
 
  default:
    return "unknown status code";
  }
}

References _, GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID, GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED, GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND, GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID, GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND, GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND, GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR, GNUNET_NAT_ERROR_IPC_FAILURE, GNUNET_NAT_ERROR_NAT_REGISTER_FAILED, GNUNET_NAT_ERROR_NAT_TEST_START_FAILED, GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT, GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO, GNUNET_NAT_ERROR_NOT_ONLINE, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_ERROR_TIMEOUT, GNUNET_NAT_ERROR_UPNPC_FAILED, GNUNET_NAT_ERROR_UPNPC_NOT_FOUND, GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED, and GNUNET_NAT_ERROR_UPNPC_TIMEOUT.

Referenced by auto_config_cb(), and test_report_cb().

Here is the caller graph for this function:

GNUNET_NAT_AUTO_autoconfig_start()

struct GNUNET_NAT_AUTO_AutoHandle * GNUNET_NAT_AUTO_autoconfig_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_NAT_AUTO_AutoResultCallback	cb,
		void *	cb_cls
	)

Start auto-configuration routine.

The transport adapters should be stopped while this function is called.

Parameters

cfg	initial configuration
cb	function to call with autoconfiguration result
cb_cls	closure for cb

Returns

handle to cancel operation

Definition at line 223 of file nat_auto_api.c.

{
  struct GNUNET_NAT_AUTO_AutoHandle *ah = GNUNET_new (struct
                                                      GNUNET_NAT_AUTO_AutoHandle);
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (auto_result,
                           GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT,
                           struct GNUNET_NAT_AUTO_AutoconfigResultMessage,
                           ah),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *req;
  char *buf;
  size_t size;
 
  buf = GNUNET_CONFIGURATION_serialize (cfg,
                                        &size);
  if (size > GNUNET_MAX_MESSAGE_SIZE - sizeof(*req))
  {
    GNUNET_break (0);
    GNUNET_free (buf);
    GNUNET_free (ah);
    return NULL;
  }
  ah->arc = cb;
  ah->arc_cls = cb_cls;
  ah->mq = GNUNET_CLIENT_connect (cfg,
                                  "nat",
                                  handlers,
                                  &ah_error_handler,
                                  ah);
  if (NULL == ah->mq)
  {
    GNUNET_break (0);
    GNUNET_free (buf);
    GNUNET_free (ah);
    return NULL;
  }
  env = GNUNET_MQ_msg_extra (req,
                             size,
                             GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG);
  GNUNET_memcpy (&req[1],
                 buf,
                 size);
  GNUNET_free (buf);
  GNUNET_MQ_send (ah->mq,
                  env);
  return ah;
}

References ah, ah_error_handler(), GNUNET_NAT_AUTO_AutoHandle::arc, GNUNET_NAT_AUTO_AutoHandle::arc_cls, cfg, env, GNUNET_break, GNUNET_CLIENT_connect(), GNUNET_CONFIGURATION_serialize(), GNUNET_free, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT, GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, handlers, GNUNET_NAT_AUTO_AutoHandle::mq, and size.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_AUTO_autoconfig_cancel()

void GNUNET_NAT_AUTO_autoconfig_cancel

(

struct GNUNET_NAT_AUTO_AutoHandle *

ah

)

Abort autoconfiguration.

Parameters

ah	handle for operation to abort

Definition at line 283 of file nat_auto_api.c.

{
  GNUNET_MQ_destroy (ah->mq);
  GNUNET_free (ah);
}

References ah, GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_NAT_AUTO_AutoHandle::mq.

Referenced by ah_error_handler(), do_shutdown(), and handle_auto_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_get_burst_sync_msg()

struct GNUNET_BurstSync * GNUNET_get_burst_sync_msg	(	struct GNUNET_TIME_Relative	rtt_average,
		enum GNUNET_GenericReturnValue	sync_ready
	)

Create GNUNET_BurstSync message.

Parameters

rtt_average	The average RTT for the peer to communicate with.
sync_ready	Is this peer already ready to sync.

Returns

The GNUNET_BurstSync message to send to the other peer.

Parameters

rtt_average	The average RTT for the peer to communicate with.
sync_ready	Is this peer already ready to sync.

Definition at line 66 of file nat.c.

{
  struct GNUNET_BurstSync *burst_sync = GNUNET_new (struct GNUNET_BurstSync);
 
  burst_sync->rtt_average = GNUNET_TIME_relative_hton (rtt_average);
  burst_sync->sync_ready = sync_ready;
 
  return burst_sync;
}

References GNUNET_new, GNUNET_TIME_relative_hton(), GNUNET_BurstSync::rtt_average, and GNUNET_BurstSync::sync_ready.

Here is the call graph for this function:

GNUNET_is_burst_ready()

void GNUNET_is_burst_ready	(	struct GNUNET_TIME_Relative	rtt_average,
		struct GNUNET_BurstSync *	burst_sync,
		GNUNET_SCHEDULER_TaskCallback	task,
		struct GNUNET_StartBurstCls *	task_cls
	)

Checks if we are ready and starts burst when we and the other peer is ready.

Parameters

rtt_average	The average RTT for the peer to communicate with.
sync_ready	Is this peer already ready to sync.
burst_sync	The GNUNET_BurstSync from the other peer.
task	Task to be executed if both peers are ready.
task_cls	Closure for the task.

Returns

Are we burst ready. This is independent from the other peer being ready.

Parameters

rtt_average	The average RTT for the peer to communicate with.
burst_sync	The GNUNET_BurstSync from the other peer.
task	Task to be executed if both peers are ready.
task_cls	Closure for the task.

Returns

Are we burst ready. This is independent from the other peer being ready.

Definition at line 89 of file nat.c.

{
  struct GNUNET_TIME_Relative other_rtt;
  struct GNUNET_TIME_Relative rel1;
  struct GNUNET_TIME_Relative rel2;
 
  other_rtt = GNUNET_TIME_relative_ntoh (burst_sync->rtt_average);
  rel1 = GNUNET_TIME_relative_subtract (other_rtt, rtt_average);
  rel2 = GNUNET_TIME_relative_subtract (rtt_average, other_rtt);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "other sync ready %u, other rtt %lu and rtt %lu rel1 %lu rel2 %lu\n",
              burst_sync->sync_ready,
              (unsigned long) other_rtt.rel_value_us,
              (unsigned long) rtt_average.rel_value_us,
              (unsigned long) rel1.rel_value_us,
              (unsigned long) rel2.rel_value_us);
  if ((other_rtt.rel_value_us != GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us &&
       rtt_average.rel_value_us != GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) &&
      rel1.rel_value_us  < RTT_DIFF.rel_value_us &&
      rel2.rel_value_us < RTT_DIFF.rel_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "other sync ready 1\n");
    if (GNUNET_YES == burst_sync->sync_ready)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "other sync ready 2\n");
      task_cls->delay = GNUNET_TIME_relative_saturating_multiply (rtt_average,
                                                                  2);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "other sync ready 3\n");
      task_cls->delay  = GNUNET_TIME_relative_saturating_multiply (rtt_average,
                                                                   4);
    }
    task_cls->sync_ready = GNUNET_YES;
    task (task_cls);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "other sync ready 6\n");
    task_cls->sync_ready = GNUNET_NO;
  }
}

References GNUNET_StartBurstCls::delay, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_TIME_relative_ntoh(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_TIME_relative_subtract(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GNUNET_TIME_Relative::rel_value_us, GNUNET_BurstSync::rtt_average, RTT_DIFF, GNUNET_BurstSync::sync_ready, and GNUNET_StartBurstCls::sync_ready.

Referenced by handle_flow_control().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_get_udp_socket()

struct GNUNET_SCHEDULER_Task * GNUNET_get_udp_socket	(	struct GNUNET_UdpSocketInfo *	sock_info,
		GNUNET_NotifyUdpSocket	nus
	)

Method to get a UDP socket for a peer that is natted.

Parameters

sock_info	Struct with information correlated to a specific port at the other peer.
nus	Callback to give the caller the struct GNUNET_UdpSocketInfo to use to connect the other peer.

Returns

The initial read task to read from the default socket.

Definition at line 509 of file nat.c.

{
  struct GNUNET_BurstMessage bm = {0};
  struct GNUNET_UdpSocketInfo *si = GNUNET_new (struct GNUNET_UdpSocketInfo);
  char dgram[sizeof (struct GNUNET_BurstMessage)];
  char *address;
  struct sockaddr *in;
  socklen_t in_len;
 
  GNUNET_asprintf (&address,
                   "%s:%u",
                   sock_info->address,
                   sock_info->std_port);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "2 sock addr %s addr %s rtt %s %u\n",
              sock_info->address,
              address,
              GNUNET_TIME_relative2s (sock_info->rtt,
                                      false),
              sock_info->std_port);
  bm.local_port = sock_info->std_port;
  in = udp_address_to_sockaddr (address, &in_len);
  memcpy (dgram, &bm, sizeof(bm));
  if (-1 == GNUNET_NETWORK_socket_sendto (sock_info->udp_sock,
                                          dgram,
                                          sizeof(dgram),
                                          in,
                                          in_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending burst to %s family %d failed sock %p\n",
                GNUNET_a2s (in,
                            in_len),
                in->sa_family,
                sock_info->udp_sock);
  }
 
  nr_open_sockets = 0;
  udp_port = 1024;
  sock_info->has_port = GNUNET_NO;
  sock_info->nus = nus;
 
  GNUNET_memcpy (si, sock_info, sizeof (struct GNUNET_UdpSocketInfo));
 
  read_send_task = GNUNET_SCHEDULER_add_delayed (SEND_DELAY,
                                                 &read_send,
                                                 si);
  GNUNET_free (in);
  GNUNET_free (address);
  return read_send_task;
}

References address, GNUNET_UdpSocketInfo::address, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_NETWORK_socket_sendto(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative2s(), GNUNET_UdpSocketInfo::has_port, GNUNET_BurstMessage::local_port, nr_open_sockets, GNUNET_UdpSocketInfo::nus, read_send(), read_send_task, GNUNET_UdpSocketInfo::rtt, SEND_DELAY, GNUNET_UdpSocketInfo::std_port, udp_address_to_sockaddr(), udp_port, and GNUNET_UdpSocketInfo::udp_sock.

Referenced by start_burst().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_stop_burst()

void GNUNET_stop_burst

(

struct GNUNET_NETWORK_Handle *

do_not_touch

)

Method to stop all sockets we established to the other peer.

Parameters

do_not_touch

The network handle we will use to connect to the other peer. This socket must not be closed.

Definition at line 564 of file nat.c.

{
  struct GNUNET_UdpSocketInfo *sock_info;
  struct GNUNET_UdpSocketInfo *pos;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "stopping burst\n");
  if (NULL != read_send_task)
  {
    GNUNET_SCHEDULER_cancel (read_send_task);
    read_send_task = NULL;
  }
  pos = sock_infos_head;
  while (NULL != pos)
  {
    sock_info = pos;
    pos = sock_info->next;
    GNUNET_CONTAINER_DLL_remove (sock_infos_head,
                                 sock_infos_tail,
                                 sock_info);
    if (NULL != sock_info->read_task)
      GNUNET_SCHEDULER_cancel (sock_info->read_task);
    if (NULL != sock_info->timeout_task)
      GNUNET_SCHEDULER_cancel (sock_info->timeout_task);
    if (do_not_touch != sock_info->udp_sock)
    {
      GNUNET_NETWORK_socket_close (sock_info->udp_sock);
      if (NULL != sock_info->address)
        GNUNET_free (sock_info->address);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "freeing sock_info %p\n",
                  sock_info);
      GNUNET_free (sock_info);
    }
  }
}

References GNUNET_UdpSocketInfo::address, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), GNUNET_UdpSocketInfo::next, read_send_task, GNUNET_UdpSocketInfo::read_task, sock_infos_head, sock_infos_tail, GNUNET_UdpSocketInfo::timeout_task, and GNUNET_UdpSocketInfo::udp_sock.

Referenced by do_shutdown(), sock_read(), and start_burst().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_register()

struct GNUNET_NAT_Handle * GNUNET_NAT_register	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	config_section,
		uint8_t	proto,
		unsigned int	num_addrs,
		const struct sockaddr **	addrs,
		const socklen_t *	addrlens,
		GNUNET_NAT_AddressCallback	address_callback,
		GNUNET_NAT_ReversalCallback	reversal_callback,
		void *	callback_cls
	)

Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on the local network.

Use addr to specify to which of the local host's addresses should the external port be mapped. The port is taken from the corresponding sockaddr_in[6] field. The NAT module should call the given address_callback for any 'plausible' external address.

Parameters

cfg	configuration to use
config_section	name of the configuration section for options
proto	protocol this is about, IPPROTO_TCP or IPPROTO_UDP
num_addrs	number of addresses in addrs
addrs	list of local addresses packets should be redirected to
addrlens	actual lengths of the addresses in addrs
address_callback	function to call every time the public IP address changes
reversal_callback	function to call if someone wants connection reversal from us, NULL if connection reversal is not supported
callback_cls	closure for callbacks

Returns

NULL on error, otherwise handle that can be used to unregister

Definition at line 366 of file nat_api.c.

{
  struct GNUNET_NAT_Handle *nh;
  struct GNUNET_NAT_RegisterMessage *rm;
  size_t len;
  size_t str_len;
  char *off;
 
  len = 0;
  for (unsigned int i = 0; i < num_addrs; i++)
    len += addrlens[i];
  str_len = strlen (config_section) + 1;
  len += str_len;
  if ( (len > GNUNET_MAX_MESSAGE_SIZE - sizeof(*rm)) ||
       (num_addrs > UINT16_MAX) ||
       (str_len > UINT16_MAX) )
  {
    GNUNET_break (0);
    return NULL;
  }
  rm = GNUNET_malloc (sizeof(*rm) + len);
  rm->header.size = htons (sizeof(*rm) + len);
  rm->header.type = htons (GNUNET_MESSAGE_TYPE_NAT_REGISTER);
  rm->flags = GNUNET_NAT_RF_NONE;
  if (NULL != address_callback)
    rm->flags |= GNUNET_NAT_RF_ADDRESSES;
  if (NULL != reversal_callback)
    rm->flags |= GNUNET_NAT_RF_REVERSAL;
  rm->proto = proto;
  rm->str_len = htons (str_len);
  rm->num_addrs = htons ((uint16_t) num_addrs);
  off = (char *) &rm[1];
  for (unsigned int i = 0; i < num_addrs; i++)
  {
    switch (addrs[i]->sa_family)
    {
    case AF_INET:
      if (sizeof(struct sockaddr_in) != addrlens[i])
      {
        GNUNET_break (0);
        GNUNET_free (rm);
        return NULL;
      }
      break;
 
    case AF_INET6:
      if (sizeof(struct sockaddr_in6) != addrlens[i])
      {
        GNUNET_break (0);
        GNUNET_free (rm);
        return NULL;
      }
      break;
 
#if AF_UNIX
    case AF_UNIX:
      if (sizeof(struct sockaddr_un) != addrlens[i])
      {
        GNUNET_break (0);
        GNUNET_free (rm);
        return NULL;
      }
      break;
#endif
    default:
      GNUNET_break (0);
      GNUNET_free (rm);
      return NULL;
    }
    GNUNET_memcpy (off, addrs[i], addrlens[i]);
    off += addrlens[i];
  }
  GNUNET_memcpy (off, config_section, str_len);
 
  nh = GNUNET_new (struct GNUNET_NAT_Handle);
  nh->reg = &rm->header;
  nh->cfg = cfg;
  nh->address_callback = address_callback;
  nh->reversal_callback = reversal_callback;
  nh->callback_cls = callback_cls;
  do_connect (nh);
  return nh;
}

References GNUNET_NAT_Handle::address_callback, GNUNET_NAT_Handle::callback_cls, cfg, GNUNET_NAT_Handle::cfg, do_connect(), GNUNET_NAT_RegisterMessage::flags, GNUNET_break, GNUNET_free, GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAT_REGISTER, GNUNET_NAT_RF_ADDRESSES, GNUNET_NAT_RF_NONE, GNUNET_NAT_RF_REVERSAL, GNUNET_new, GNUNET_NAT_RegisterMessage::header, nh, GNUNET_NAT_RegisterMessage::num_addrs, proto, GNUNET_NAT_RegisterMessage::proto, GNUNET_NAT_Handle::reg, reversal_callback(), GNUNET_NAT_Handle::reversal_callback, GNUNET_MessageHeader::size, GNUNET_NAT_RegisterMessage::str_len, and GNUNET_MessageHeader::type.

Referenced by GNUNET_NAT_AUTO_test_start(), GNUNET_NAT_test_start(), nat_register(), run(), and try_anat().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_add_global_address()

void GNUNET_NAT_add_global_address	(	struct GNUNET_NAT_Handle *	nh,
		char *	addr,
		unsigned int	address_length
	)

Add global address to the list of addresses and notify clients.

Parameters

nh	the handle returned by register
addr	IP address to add.
address_length	number of bytes in addr

Definition at line 460 of file nat_api.c.

{
  struct GNUNET_NAT_AddGlobalAddressMessage *aam;
  struct GNUNET_MQ_Envelope *env;
  //char *address_without_port = get_address_without_port (addr);
  //unsigned int address_len_without_port = strlen (address_without_port);
  char *off;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "natting address %s length %u\n",
              addr,
              address_length);
 
  env = GNUNET_MQ_msg_extra (aam,
                             address_length,
                             GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS);
  aam->address_length = htons (address_length);
  off = (char *) &aam[1];
  GNUNET_memcpy (off, addr, address_length);
  GNUNET_MQ_send (nh->mq,
                   env);
  //GNUNET_free (address_without_port);
}

References GNUNET_NAT_AddGlobalAddressMessage::address_length, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NAT_Handle::mq, and nh.

Referenced by handle_flow_control().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_test_address()

int GNUNET_NAT_test_address	(	struct GNUNET_NAT_Handle *	nh,
		const void *	addr,
		socklen_t	addrlen
	)

Test if the given address is (currently) a plausible IP address for this peer.

Mostly a convenience function so that clients do not have to explicitly track all IPs that the GNUNET_NAT_AddressCallback has returned so far.

Parameters

nh	the handle returned by register
addr	IP address to test (IPv4 or IPv6)
addrlen	number of bytes in addr

Returns

GNUNET_YES if the address is plausible, GNUNET_NO if the address is not plausible, GNUNET_SYSERR if the address is malformed

Definition at line 643 of file nat_api.c.

{
  struct AddrEntry *ae;
 
  if ((addrlen != sizeof(struct sockaddr_in)) &&
      (addrlen != sizeof(struct sockaddr_in6)))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  for (ae = nh->ae_head; NULL != ae; ae = ae->next)
    if ((addrlen == ae->addrlen) && (0 == memcmp (addr, &ae[1], addrlen)))
      return GNUNET_YES;
  return GNUNET_NO;
}

References AddrEntry::addrlen, GNUNET_NAT_Handle::ae_head, GNUNET_break, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, AddrEntry::next, and nh.

GNUNET_NAT_request_reversal()

int GNUNET_NAT_request_reversal	(	struct GNUNET_NAT_Handle *	nh,
		const struct sockaddr_in *	local_sa,
		const struct sockaddr_in *	remote_sa
	)

We learned about a peer (possibly behind NAT) so run the gnunet-nat-client to send dummy ICMP responses to cause that peer to connect to us (connection reversal).

Parameters

nh	handle (used for configuration)
local_sa	our local address of the peer (IPv4-only)
remote_sa	the remote address of the peer (IPv4-only)

Returns

GNUNET_SYSERR on error, GNUNET_NO if connection reversal is unavailable, GNUNET_OK otherwise (presumably in progress)

Definition at line 675 of file nat_api.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAT_RequestConnectionReversalMessage *req;
  char *buf;
 
  if (NULL == nh->mq)
    return GNUNET_SYSERR;
  GNUNET_break (AF_INET == local_sa->sin_family);
  GNUNET_break (AF_INET == remote_sa->sin_family);
  env =
    GNUNET_MQ_msg_extra (req,
                         2 * sizeof(struct sockaddr_in),
                         GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL);
  req->local_addr_size = htons (sizeof(struct sockaddr_in));
  req->remote_addr_size = htons (sizeof(struct sockaddr_in));
  buf = (char *) &req[1];
  GNUNET_memcpy (buf, local_sa, sizeof(struct sockaddr_in));
  buf += sizeof(struct sockaddr_in);
  GNUNET_memcpy (buf, remote_sa, sizeof(struct sockaddr_in));
  GNUNET_MQ_send (nh->mq, env);
  return GNUNET_OK;
}

References env, GNUNET_break, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_NAT_RequestConnectionReversalMessage::local_addr_size, GNUNET_NAT_Handle::mq, nh, and GNUNET_NAT_RequestConnectionReversalMessage::remote_addr_size.

Referenced by mq_init(), run(), and try_anat().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_unregister()

void GNUNET_NAT_unregister

(

struct GNUNET_NAT_Handle *

nh

)

Stop port redirection and public IP address detection for the given handle.

This frees the handle, after having sent the needed commands to close open ports.

FIXME: No, the implementation of this API does not do anything beyond cleaning up the handle. This is a problem for applications that use GNUNET_NAT_AddressCallback and use the app_ctx to store objects, because the callback will never be called for cleanup on unregister.

Parameters

nh	the handle to unregister

Definition at line 703 of file nat_api.c.

{
  struct AddrEntry *ae;
  struct AddrEntry *next;
 
  if (NULL != nh->mq)
  {
    GNUNET_MQ_destroy (nh->mq);
    nh->mq = NULL;
  }
  if (NULL != nh->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (nh->reconnect_task);
    nh->reconnect_task = NULL;
  }
  next = nh->ae_head;
  while (NULL != next)
  {
    ae = next;
    next = next->next;
    GNUNET_CONTAINER_DLL_remove (nh->ae_head, nh->ae_tail, ae);
    GNUNET_free (ae);
  }
  GNUNET_free (nh->reg);
  GNUNET_free (nh);
}

References GNUNET_NAT_Handle::ae_head, GNUNET_NAT_Handle::ae_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_NAT_Handle::mq, AddrEntry::next, nh, GNUNET_NAT_Handle::reconnect_task, and GNUNET_NAT_Handle::reg.

Referenced by do_shutdown(), GNUNET_NAT_AUTO_test_stop(), GNUNET_NAT_test_stop(), and try_anat().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_stun_handle_packet()

int GNUNET_NAT_stun_handle_packet	(	struct GNUNET_NAT_Handle *	nh,
		const struct sockaddr *	sender_addr,
		size_t	sender_addr_len,
		const void *	data,
		size_t	data_size
	)

Handle an incoming STUN message.

This function is useful as some GNUnet service may be listening on a UDP port and might thus receive STUN messages while trying to receive other data. In this case, this function can be used to process replies to STUN requests.

The function does some basic sanity checks on packet size and content, try to extract a bit of information.

At the moment this only processes BIND requests, and returns the externally visible address of the request to the rest of the NAT logic.

Parameters

nh	handle to the NAT service
sender_addr	address from which we got data
sender_addr_len	number of bytes in sender_addr
data	the packet
data_size	number of bytes in data

Returns

GNUNET_OK on success GNUNET_NO if the packet is not a STUN packet GNUNET_SYSERR on internal error handling the packet

Definition at line 601 of file nat_api.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAT_HandleStunMessage *hsn;
  char *buf;
 
  if (GNUNET_YES != test_stun_packet (data, data_size))
    return GNUNET_NO;
  if (NULL == nh->mq)
    return GNUNET_SYSERR;
  env = GNUNET_MQ_msg_extra (hsn,
                             data_size + sender_addr_len,
                             GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN);
  hsn->sender_addr_size = htons ((uint16_t) sender_addr_len);
  hsn->payload_size = htons ((uint16_t) data_size);
  buf = (char *) &hsn[1];
  GNUNET_memcpy (buf, sender_addr, sender_addr_len);
  buf += sender_addr_len;
  GNUNET_memcpy (buf, data, data_size);
  GNUNET_MQ_send (nh->mq, env);
  return GNUNET_OK;
}

References data, data_size, env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_NAT_Handle::mq, nh, GNUNET_NAT_HandleStunMessage::payload_size, GNUNET_NAT_HandleStunMessage::sender_addr_size, and test_stun_packet().

Referenced by do_udp_read(), and stun_read_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_stun_make_request()

struct GNUNET_NAT_STUN_Handle * GNUNET_NAT_stun_make_request	(	const char *	server,
		uint16_t	port,
		struct GNUNET_NETWORK_Handle *	sock,
		GNUNET_NAT_TestCallback	cb,
		void *	cb_cls
	)

Make Generic STUN request.

Sends a generic stun request to the server specified using the specified socket. If we do this, we need to watch for possible responses and call GNUNET_NAT_stun_handle_packet() on incoming packets.

Parameters

server	the address of the stun server
port	port of the stun server, in host byte order
sock	the socket used to send the request, must be a UDP socket
cb	callback in case of error
cb_cls	closure for cb

Returns

NULL on error

Sends a generic stun request to the server specified using the specified socket.

Parameters

server	the address of the stun server
port	port of the stun server, in host byte order
sock	the socket used to send the request
cb	callback in case of error
cb_cls	closure for cb

Returns

NULL on error

Definition at line 211 of file nat_api_stun.c.

{
  struct GNUNET_NAT_STUN_Handle *rh;
 
  rh = GNUNET_new (struct GNUNET_NAT_STUN_Handle);
  rh->sock = sock;
  rh->cb = cb;
  rh->cb_cls = cb_cls;
  rh->stun_server = GNUNET_strdup (server);
  rh->stun_port = port;
  rh->dns_success = GNUNET_NO;
  rh->dns_active = GNUNET_RESOLVER_ip_get (rh->stun_server,
                                           AF_INET,
                                           TIMEOUT,
                                           &stun_dns_callback,
                                           rh);
  if (NULL == rh->dns_active)
  {
    GNUNET_NAT_stun_make_request_cancel (rh);
    return NULL;
  }
  return rh;
}

References GNUNET_NAT_STUN_Handle::cb, GNUNET_NAT_STUN_Handle::cb_cls, GNUNET_NAT_STUN_Handle::dns_active, GNUNET_NAT_STUN_Handle::dns_success, GNUNET_NAT_stun_make_request_cancel(), GNUNET_new, GNUNET_NO, GNUNET_RESOLVER_ip_get(), GNUNET_strdup, port, GNUNET_NAT_STUN_Handle::sock, stun_dns_callback(), GNUNET_NAT_STUN_Handle::stun_port, GNUNET_NAT_STUN_Handle::stun_server, and TIMEOUT.

Referenced by test_stun().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_stun_make_request_cancel()

void GNUNET_NAT_stun_make_request_cancel

(

struct GNUNET_NAT_STUN_Handle *

rh

)

Cancel active STUN request.

Frees associated resources and ensures that the callback is no longer invoked.

Parameters

rh	request to cancel

Definition at line 247 of file nat_api_stun.c.

{
  if (NULL != rh->dns_active)
  {
    GNUNET_RESOLVER_request_cancel (rh->dns_active);
    rh->dns_active = NULL;
  }
  GNUNET_free (rh->stun_server);
  GNUNET_free (rh);
}

References GNUNET_NAT_STUN_Handle::dns_active, GNUNET_free, GNUNET_RESOLVER_request_cancel(), and GNUNET_NAT_STUN_Handle::stun_server.

Referenced by GNUNET_NAT_stun_make_request(), and stun_dns_callback().

Here is the call graph for this function:

Here is the caller graph for this function: