nat_api.c File Reference

#include "platform.h"
#include "gnunet_nat_service.h"
#include "nat.h"
#include "nat_stun.h"

Include dependency graph for nat_api.c:

Go to the source code of this file.

Data Structures
struct	AddrEntry
	Entry in DLL of addresses of this peer. More...
struct	GNUNET_NAT_Handle
	Handle for active NAT registrations. More...

Functions
static void	do_connect (void *cls)
	Task to connect to the NAT service.
static void	reconnect (struct GNUNET_NAT_Handle *nh)
	Task to connect to the NAT service.
static int	check_connection_reversal_request (void *cls, const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm)
	Check connection reversal request.
static void	handle_connection_reversal_request (void *cls, const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm)
	Handle connection reversal request.
static int	check_address_change_notification (void *cls, const struct GNUNET_NAT_AddressChangeNotificationMessage *acn)
	Check address change notification.
static void	handle_address_change_notification (void *cls, const struct GNUNET_NAT_AddressChangeNotificationMessage *acn)
	Handle connection reversal request.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Handle queue errors by reconnecting to NAT.
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.
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.
static enum GNUNET_GenericReturnValue	test_stun_packet (const void *data, size_t len)
	Check if an incoming message is a STUN message.
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.
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.
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).
void	GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *nh)
	Stop port redirection and public IP address detection for the given handle.

Detailed Description

Author

Christian Grothoff

Milan Bouchet-Valat

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

Definition in file nat_api.c.

Function Documentation

do_connect()

static void do_connect ( void *  cls )

static

Task to connect to the NAT service.

Parameters

cls	our struct GNUNET_NAT_Handle *

Definition at line 329 of file nat_api.c.

{
  struct GNUNET_NAT_Handle *nh = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (
      connection_reversal_request,
      GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED,
      struct GNUNET_NAT_ConnectionReversalRequestedMessage,
      nh),
    GNUNET_MQ_hd_var_size (
      address_change_notification,
      GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE,
      struct GNUNET_NAT_AddressChangeNotificationMessage,
      nh),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *env;
 
  nh->reconnect_task = NULL;
  nh->mq =
    GNUNET_CLIENT_connect (nh->cfg,
                           "nat",
                           handlers,
                           &mq_error_handler,
                           nh);
  if (NULL == nh->mq)
  {
    reconnect (nh);
    return;
  }
  env = GNUNET_MQ_msg_copy (nh->reg);
  GNUNET_MQ_send (nh->mq,
                  env);
}

References GNUNET_NAT_Handle::cfg, env, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE, GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), handlers, GNUNET_NAT_Handle::mq, mq_error_handler(), nh, reconnect(), GNUNET_NAT_Handle::reconnect_task, and GNUNET_NAT_Handle::reg.

Referenced by GNUNET_NAT_register(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

reconnect()

static void reconnect ( struct GNUNET_NAT_Handle *  nh )

static

Task to connect to the NAT service.

Parameters

nh	handle to reconnect

Definition at line 140 of file nat_api.c.

{
  struct AddrEntry *ae;
 
  if (NULL != nh->mq)
  {
    GNUNET_MQ_destroy (nh->mq);
    nh->mq = NULL;
  }
  while (NULL != (ae = nh->ae_head))
  {
    GNUNET_CONTAINER_DLL_remove (nh->ae_head, nh->ae_tail, ae);
    nh->address_callback (nh->callback_cls,
                          &ae->app_ctx,
                          GNUNET_NO,
                          ae->ac,
                          (const struct sockaddr *) &ae[1],
                          ae->addrlen);
    GNUNET_free (ae);
  }
  nh->reconnect_delay = GNUNET_TIME_STD_BACKOFF (nh->reconnect_delay);
  nh->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (nh->reconnect_delay, &do_connect, nh);
}

References AddrEntry::ac, GNUNET_NAT_Handle::address_callback, AddrEntry::addrlen, GNUNET_NAT_Handle::ae_head, GNUNET_NAT_Handle::ae_tail, AddrEntry::app_ctx, GNUNET_NAT_Handle::callback_cls, do_connect(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_NAT_Handle::mq, nh, GNUNET_NAT_Handle::reconnect_delay, and GNUNET_NAT_Handle::reconnect_task.

Here is the call graph for this function:

check_connection_reversal_request()

static int check_connection_reversal_request ( void *  cls, const struct GNUNET_NAT_ConnectionReversalRequestedMessage *  crm  )

static

Check connection reversal request.

Parameters

cls	our struct GNUNET_NAT_Handle
crm	the message

Returns

GNUNET_OK if crm is well-formed

Definition at line 174 of file nat_api.c.

{
  if (ntohs (crm->header.size) != sizeof(*crm) + sizeof(struct sockaddr_in))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_NAT_ConnectionReversalRequestedMessage::header, and GNUNET_MessageHeader::size.

handle_connection_reversal_request()

static void handle_connection_reversal_request ( void *  cls, const struct GNUNET_NAT_ConnectionReversalRequestedMessage *  crm  )

static

Handle connection reversal request.

Parameters

cls	our struct GNUNET_NAT_Handle
crm	the message

Definition at line 194 of file nat_api.c.

{
  struct GNUNET_NAT_Handle *nh = cls;
 
  nh->reversal_callback (nh->callback_cls,
                         (const struct sockaddr *) &crm[1],
                         sizeof(struct sockaddr_in));
}

References GNUNET_NAT_Handle::callback_cls, nh, and GNUNET_NAT_Handle::reversal_callback.

check_address_change_notification()

static int check_address_change_notification ( void *  cls, const struct GNUNET_NAT_AddressChangeNotificationMessage *  acn  )

static

Check address change notification.

Parameters

cls	our struct GNUNET_NAT_Handle
acn	the message

Returns

GNUNET_OK if crm is well-formed

Definition at line 214 of file nat_api.c.

{
  size_t alen = ntohs (acn->header.size) - sizeof(*acn);
 
  switch (alen)
  {
  case sizeof(struct sockaddr_in): {
      const struct sockaddr_in *s4 = (const struct sockaddr_in *) &acn[1];
      if (AF_INET != s4->sin_family)
      {
        GNUNET_break (0);
        return GNUNET_SYSERR;
      }
    }
    break;
 
  case sizeof(struct sockaddr_in6): {
      const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) &acn[1];
      if (AF_INET6 != s6->sin6_family)
      {
        GNUNET_break (0);
        return GNUNET_SYSERR;
      }
    }
    break;
 
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_NAT_AddressChangeNotificationMessage::header, and GNUNET_MessageHeader::size.

handle_address_change_notification()

static void handle_address_change_notification ( void *  cls, const struct GNUNET_NAT_AddressChangeNotificationMessage *  acn  )

static

Handle connection reversal request.

Parameters

cls	our struct GNUNET_NAT_Handle
acn	the message

Definition at line 257 of file nat_api.c.

{
  struct GNUNET_NAT_Handle *nh = cls;
  size_t alen = ntohs (acn->header.size) - sizeof(*acn);
  const struct sockaddr *sa = (const struct sockaddr *) &acn[1];
  enum GNUNET_NAT_AddressClass ac;
  struct AddrEntry *ae;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received address change notification\n");
  ac = ntohl (acn->addr_class);
  if (GNUNET_YES == ntohl (acn->add_remove))
  {
    ae = GNUNET_malloc (sizeof(*ae) + alen);
    ae->ac = ac;
    ae->addrlen = alen;
    GNUNET_memcpy (&ae[1], sa, alen);
    GNUNET_CONTAINER_DLL_insert (nh->ae_head, nh->ae_tail, ae);
    nh->address_callback (nh->callback_cls,
                          &ae->app_ctx,
                          ntohl (acn->add_remove),
                          ac,
                          sa,
                          alen);
  }
  else
  {
    for (ae = nh->ae_head; NULL != ae; ae = ae->next)
      if ((ae->addrlen == alen) && (0 == memcmp (&ae[1], sa, alen)))
        break;
    if (NULL == ae)
    {
      GNUNET_break (0);
      reconnect (nh);
      return;
    }
    GNUNET_CONTAINER_DLL_remove (nh->ae_head, nh->ae_tail, ae);
    nh->address_callback (nh->callback_cls,
                          &ae->app_ctx,
                          ntohl (acn->add_remove),
                          ac,
                          sa,
                          alen);
    GNUNET_free (ae);
  }
}

References AddrEntry::ac, GNUNET_NAT_AddressChangeNotificationMessage::add_remove, GNUNET_NAT_AddressChangeNotificationMessage::addr_class, GNUNET_NAT_Handle::address_callback, AddrEntry::addrlen, GNUNET_NAT_Handle::ae_head, GNUNET_NAT_Handle::ae_tail, AddrEntry::app_ctx, GNUNET_NAT_Handle::callback_cls, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_YES, GNUNET_NAT_AddressChangeNotificationMessage::header, AddrEntry::next, nh, reconnect(), and GNUNET_MessageHeader::size.

Here is the call graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Handle queue errors by reconnecting to NAT.

Parameters

cls	the struct GNUNET_NAT_Handle *
error	details about the error

Definition at line 314 of file nat_api.c.

{
  struct GNUNET_NAT_Handle *nh = cls;
 
  reconnect (nh);
}

References nh, and reconnect().

Referenced by do_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

test_stun_packet()

static enum GNUNET_GenericReturnValue test_stun_packet ( const void *  data, size_t  len  )

static

Check if an incoming message is a STUN message.

Parameters

data	the packet
len	the length of the packet in data

Returns

GNUNET_YES if data is a STUN packet, GNUNET_NO if the packet is invalid (not a stun packet)

Definition at line 497 of file nat_api.c.

{
  const struct stun_header *hdr;
  const struct stun_attr *attr;
  uint32_t advertised_message_size;
  uint32_t message_magic_cookie;
 
  /* On entry, 'len' is the length of the UDP payload. After the
   * initial checks it becomes the size of unprocessed options,
   * while 'data' is advanced accordingly.
   */
  if (len < sizeof(struct stun_header))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "STUN packet too short (only %d, wanting at least %d)\n",
                (int) len,
                (int) sizeof(struct stun_header));
    return GNUNET_NO;
  }
  hdr = (const struct stun_header *) data;
  /* Skip header as it is already in hdr */
  len -= sizeof(struct stun_header);
  data += sizeof(struct stun_header);
 
  /* len as advertised in the message */
  advertised_message_size = ntohs (hdr->msglen);
 
  message_magic_cookie = ntohl (hdr->magic);
  /* Compare if the cookie match */
  if (STUN_MAGIC_COOKIE != message_magic_cookie)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Invalid magic cookie for STUN\n");
    return GNUNET_NO;
  }
 
  if (advertised_message_size > len)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Scrambled STUN packet length (got %d, expecting %d)\n",
                advertised_message_size,
                (int) len);
    return GNUNET_NO;
  }
  len = advertised_message_size;
  while (len > 0)
  {
    if (len < sizeof(struct stun_attr))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Attribute too short in STUN packet (got %d, expecting %d)\n",
                  (int) len,
                  (int) sizeof(struct stun_attr));
      return GNUNET_NO;
    }
    attr = (const struct stun_attr *) data;
 
    /* compute total attribute length */
    advertised_message_size = ntohs (attr->len) + sizeof(struct stun_attr);
 
    /* Check if we still have space in our buffer */
    if (advertised_message_size > len)
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_DEBUG,
        "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n",
        advertised_message_size,
        (int) len);
      return GNUNET_NO;
    }
    data += advertised_message_size;
    len -= advertised_message_size;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "STUN Packet, msg %04x, length: %d\n",
              ntohs (hdr->msgtype),
              advertised_message_size);
  return GNUNET_OK;
}

References stun_attr::attr, data, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, stun_attr::len, stun_header::magic, stun_header::msglen, stun_header::msgtype, and STUN_MAGIC_COOKIE.

Referenced by GNUNET_NAT_stun_handle_packet().

Here is the caller graph for this function: