gnunet-communicator-unix.c File Reference

Transport plugin using unix domain sockets (!) Clearly, can only be used locally on Unix/Linux hosts... ONLY INTENDED FOR TESTING!!! More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_communication_service.h"

Include dependency graph for gnunet-communicator-unix.c:

Go to the source code of this file.

Data Structures
struct	UNIXMessage
	UNIX Message-Packet header. More...
struct	Queue
	Handle for a queue. More...
struct	LookupCtx
	Closure to lookup_queue_it(). More...

Macros
#define	DEFAULT_MAX_QUEUE_LENGTH   8000
	How many messages do we keep at most in the queue to the transport service before we start to drop (default, can be changed via the configuration file). More...
#define	COMMUNICATOR_ADDRESS_PREFIX   "unix"
	Address prefix used by the communicator. More...
#define	COMMUNICATOR_CONFIG_SECTION   "communicator-unix"
	Configuration section used by the communicator. More...
#define	UNIX_MTU   UINT16_MAX
	Our MTU. More...

Functions
static void	queue_destroy (struct Queue *queue)
	Functions with this signature are called whenever we need to close a queue due to a disconnect or failure to establish a connection. More...
static void	queue_timeout (void *cls)
	Queue was idle for too long, so disconnect it. More...
static void	reschedule_queue_timeout (struct Queue *queue)
	Increment queue timeout due to activity. More...
static struct sockaddr_un *	unix_address_to_sockaddr (const char *unixpath, socklen_t *sock_len)
	Convert unix path to a struct sockaddr_un * More...
static int	lookup_queue_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Function called to find a queue by address. More...
static struct Queue *	lookup_queue (const struct GNUNET_PeerIdentity *peer, const struct sockaddr_un *un, socklen_t un_len)
	Find an existing queue by address. More...
static void	select_write_cb (void *cls)
	We have been notified that our socket is ready to write. More...
static void	mq_send (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Signature of functions implementing the sending functionality of a message queue. More...
static void	mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Signature of functions implementing the destruction of a message queue. More...
static void	mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implementation function that cancels the currently sent message. More...
static void	mq_error (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
static struct Queue *	setup_queue (const struct GNUNET_PeerIdentity *target, enum GNUNET_TRANSPORT_ConnectionStatus cs, const struct sockaddr_un *un, socklen_t un_len)
	Creates a new outbound queue the transport service will use to send data to another peer. More...
static void	select_read_cb (void *cls)
	We have been notified that our socket has something to read. More...
static void	receive_complete_cb (void *cls, int success)
	Function called when message was successfully passed to transport service. More...
static int	mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
	Function called by the transport service to initialize a message queue given address information about another peer. More...
static int	get_queue_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
	Iterator over all message queues to clean up. More...
static void	do_shutdown (void *cls)
	Shutdown the UNIX communicator. More...
static void	enc_notify_cb (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
	Function called when the transport service has received an acknowledgement for this communicator (!) via a different return path. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Setup communicator and launch network interactions. More...
int	main (int argc, char *const *argv)
	The main function for the UNIX communicator. More...

Variables
static struct GNUNET_PeerIdentity	my_identity
	My Peer Identity. More...
static struct GNUNET_SCHEDULER_Task *	read_task
	ID of read task. More...
static struct GNUNET_SCHEDULER_Task *	write_task
	ID of write task. More...
static unsigned long long	delivering_messages
	Number of messages we currently have in our queues towards the transport service. More...
static unsigned long long	max_queue_length
	Maximum queue length before we stop reading towards the transport service. More...
static struct GNUNET_STATISTICS_Handle *	stats
	For logging statistics. More...
static struct GNUNET_TRANSPORT_CommunicatorHandle *	ch
	Our environment. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	queue_map
	Queues (map from peer identity to struct Queue) More...
static struct Queue *	queue_head
	Head of queue of messages to transmit. More...
static struct Queue *	queue_tail
	Tail of queue of messages to transmit. More...
static struct GNUNET_NETWORK_Handle *	unix_sock
	socket that we transmit all data with More...
static struct GNUNET_TRANSPORT_AddressIdentifier *	ai
	Handle to the operation that publishes our address. More...

Detailed Description

Transport plugin using unix domain sockets (!) Clearly, can only be used locally on Unix/Linux hosts... ONLY INTENDED FOR TESTING!!!

Author

Christian Grothoff

Nathan Evans

Definition in file gnunet-communicator-unix.c.

Macro Definition Documentation

DEFAULT_MAX_QUEUE_LENGTH

#define DEFAULT_MAX_QUEUE_LENGTH   8000

How many messages do we keep at most in the queue to the transport service before we start to drop (default, can be changed via the configuration file).

Should be below the level of the communicator API, as otherwise we may read messages just to have them dropped by the communicator API.

Definition at line 43 of file gnunet-communicator-unix.c.

COMMUNICATOR_ADDRESS_PREFIX

#define COMMUNICATOR_ADDRESS_PREFIX   "unix"

Address prefix used by the communicator.

Definition at line 48 of file gnunet-communicator-unix.c.

COMMUNICATOR_CONFIG_SECTION

#define COMMUNICATOR_CONFIG_SECTION   "communicator-unix"

Configuration section used by the communicator.

Definition at line 53 of file gnunet-communicator-unix.c.

UNIX_MTU

#define UNIX_MTU   UINT16_MAX

Our MTU.

Definition at line 59 of file gnunet-communicator-unix.c.

Function Documentation

queue_destroy()

static void queue_destroy ( struct Queue *  queue )

static

Functions with this signature are called whenever we need to close a queue due to a disconnect or failure to establish a connection.

Parameters

queue

queue to close down

Definition at line 216 of file gnunet-communicator-unix.c.

{
  struct GNUNET_MQ_Handle *mq;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Disconnecting queue for peer `%s'\n",
              GNUNET_i2s (&queue->target));
  if (0 != queue->bytes_in_queue)
  {
    GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue);
    queue->bytes_in_queue = 0;
  }
  if (NULL != (mq = queue->mq))
  {
    queue->mq = NULL;
    GNUNET_MQ_destroy (mq);
  }
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (queue_map, &queue->target, queue));
  GNUNET_STATISTICS_set (stats,
                         "# queues active",
                         GNUNET_CONTAINER_multipeermap_size (queue_map),
                         GNUNET_NO);
  if (NULL != queue->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (queue->timeout_task);
    queue->timeout_task = NULL;
  }
  GNUNET_free (queue->address);
  GNUNET_free (queue);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_YES, mq, queue(), queue_head, queue_map, queue_tail, and stats.

Referenced by get_queue_delete_it(), mq_destroy(), mq_error(), and queue_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_timeout()

static void queue_timeout ( void *  cls )

static

Queue was idle for too long, so disconnect it.

Parameters

cls	the struct Queue * to disconnect

Definition at line 256 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = cls;
  struct GNUNET_TIME_Relative left;
 
  queue->timeout_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
  if (0 != left.rel_value_us)
  {
    /* not actually our turn yet, but let's at least update
       the monitor, it may think we're about to die ... */
    queue->timeout_task =
      GNUNET_SCHEDULER_add_delayed (left, &queue_timeout, queue);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Queue %p was idle for %s, disconnecting\n",
              queue,
              GNUNET_STRINGS_relative_time_to_string (
                GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                GNUNET_YES));
  queue_destroy (queue);
}

References GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, queue(), queue_destroy(), queue_timeout(), and GNUNET_TIME_Relative::rel_value_us.

Referenced by queue_timeout(), and setup_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_queue_timeout()

static void reschedule_queue_timeout ( struct Queue *  queue )

static

Increment queue timeout due to activity.

We do not immediately notify the monitor here as that might generate excessive signalling.

Parameters

queue

queue for which the timeout should be rescheduled

Definition at line 289 of file gnunet-communicator-unix.c.

{
  GNUNET_assert (NULL != queue->timeout_task);
  queue->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), and queue().

Referenced by select_read_cb(), and select_write_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_address_to_sockaddr()

static struct sockaddr_un * unix_address_to_sockaddr ( const char *  unixpath, socklen_t *  sock_len  )

static

Convert unix path to a struct sockaddr_un *

Parameters

	unixpath	path to convert
[out]	sock_len	set to the length of the address
	is_abstract	is this an abstract unixpath

Returns

converted unix path

Definition at line 306 of file gnunet-communicator-unix.c.

{
  struct sockaddr_un *un;
  size_t slen;
 
  GNUNET_assert (0 < strlen (unixpath));   /* sanity check */
  un = GNUNET_new (struct sockaddr_un);
  un->sun_family = AF_UNIX;
  slen = strlen (unixpath);
  if (slen >= sizeof(un->sun_path))
    slen = sizeof(un->sun_path) - 1;
  GNUNET_memcpy (un->sun_path, unixpath, slen);
  un->sun_path[slen] = '\0';
  slen = sizeof(struct sockaddr_un);
#if HAVE_SOCKADDR_UN_SUN_LEN
  un->sun_len = (u_char) slen;
#endif
  (*sock_len) = slen;
  if ('@' == un->sun_path[0])
    un->sun_path[0] = '\0';
  return un;
}

References GNUNET_assert, GNUNET_memcpy, and GNUNET_new.

Referenced by mq_init(), and run().

Here is the caller graph for this function:

lookup_queue_it()

static int lookup_queue_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Function called to find a queue by address.

Parameters

cls	the struct LookupCtx *
key	peer we are looking for (unused)
value	a queue

Returns

GNUNET_YES if not found (continue looking), GNUNET_NO on success

Definition at line 361 of file gnunet-communicator-unix.c.

{
  struct LookupCtx *lctx = cls;
  struct Queue *queue = value;
 
  if ((queue->address_len == lctx->un_len) &&
      (0 == memcmp (lctx->un, queue->address, queue->address_len)))
  {
    lctx->res = queue;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References GNUNET_NO, GNUNET_YES, queue(), LookupCtx::res, LookupCtx::un, LookupCtx::un_len, and value.

Referenced by lookup_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_queue()

static struct Queue * lookup_queue ( const struct GNUNET_PeerIdentity *  peer, const struct sockaddr_un *  un, socklen_t  un_len  )

static

Find an existing queue by address.

Parameters

plugin	the plugin
address	the address to find

Returns

NULL if queue was not found

Definition at line 384 of file gnunet-communicator-unix.c.

{
  struct LookupCtx lctx;
 
  lctx.un = un;
  lctx.un_len = un_len;
  lctx.res = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (queue_map,
                                              peer,
                                              &lookup_queue_it,
                                              &lctx);
  return lctx.res;
}

References GNUNET_CONTAINER_multipeermap_get_multiple(), lookup_queue_it(), queue_map, LookupCtx::res, LookupCtx::un, and LookupCtx::un_len.

Referenced by mq_init(), and select_read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

select_write_cb()

static void select_write_cb ( void *  cls )

static

We have been notified that our socket is ready to write.

Then reschedule this function to be called again once more is available.

Parameters

cls

NULL

Definition at line 408 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = queue_tail;
  const struct GNUNET_MessageHeader *msg = &queue->msg->header;
  size_t msg_size = ntohs (msg->size);
  ssize_t sent;
 
  /* take queue of the ready list */
  write_task = NULL;
resend:
  /* Send the data */
  sent = GNUNET_NETWORK_socket_sendto (unix_sock,
                                       msg,
                                       msg_size,
                                       (const struct sockaddr *) queue->address,
                                       queue->address_len);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "UNIX transmitted message to %s (%d/%u: %s)\n",
              GNUNET_i2s (&queue->target),
              (int) sent,
              (unsigned int) msg_size,
              (sent < 0) ? strerror (errno) : "ok");
  if (-1 != sent)
  {
    GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue);
    if (NULL != queue_head)
      write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                   unix_sock,
                                                   &select_write_cb,
                                                   NULL);
 
    /* send 'msg' */
    GNUNET_free (queue->msg);
    queue->msg = NULL;
    GNUNET_MQ_impl_send_continue (queue->mq);
    GNUNET_STATISTICS_update (stats,
                              "# bytes sent",
                              (long long) sent,
                              GNUNET_NO);
    reschedule_queue_timeout (queue);
    return;   /* all good */
  }
  GNUNET_STATISTICS_update (stats,
                            "# network transmission failures",
                            1,
                            GNUNET_NO);
  write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                               unix_sock,
                                               &select_write_cb,
                                               NULL);
  switch (errno)
  {
  case EAGAIN:
  case ENOBUFS:
    /* We should retry later... */
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
    return;
 
  case EMSGSIZE: {
      socklen_t size = 0;
      socklen_t len = sizeof(size);
 
      GNUNET_NETWORK_socket_getsockopt (unix_sock,
                                        SOL_SOCKET,
                                        SO_SNDBUF,
                                        &size,
                                        &len);
      if (size > ntohs (msg->size))
      {
        /* Buffer is bigger than message:  error, no retry
         * This should never happen!*/
        GNUNET_break (0);
        return;
      }
      GNUNET_log (
        GNUNET_ERROR_TYPE_WARNING,
        "Trying to increase socket buffer size from %u to %u for message size %u\n",
        (unsigned int) size,
        (unsigned int) ((msg_size / 1000) + 2) * 1000,
        (unsigned int) msg_size);
      size = ((msg_size / 1000) + 2) * 1000;
      if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt (unix_sock,
                                                         SOL_SOCKET,
                                                         SO_SNDBUF,
                                                         &size,
                                                         sizeof(size)))
        goto resend; /* Increased buffer size, retry sending */
      /* Ok, then just try very modest increase */
      size = msg_size;
      if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt (unix_sock,
                                                         SOL_SOCKET,
                                                         SO_SNDBUF,
                                                         &size,
                                                         sizeof(size)))
        goto resend; /* Increased buffer size, retry sending */
      /* Could not increase buffer size: error, no retry */
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
      return;
    }
 
  default:
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "send");
    return;
  }
}

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_getsockopt(), GNUNET_NETWORK_socket_sendto(), GNUNET_NETWORK_socket_setsockopt(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_write_net(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, msg, queue(), queue_head, queue_tail, reschedule_queue_timeout(), select_write_cb(), GNUNET_MessageHeader::size, size, stats, unix_sock, and write_task.

Referenced by mq_send(), and select_write_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_send()

static void mq_send ( struct GNUNET_MQ_Handle *  mq, const struct GNUNET_MessageHeader *  msg, void *  impl_state  )

static

Signature of functions implementing the sending functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	our struct Queue

Definition at line 524 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = impl_state;
  size_t msize = ntohs (msg->size);
 
  GNUNET_assert (mq == queue->mq);
  GNUNET_assert (NULL == queue->msg);
  // Convert to UNIXMessage
  queue->msg = GNUNET_malloc (msize + sizeof (struct UNIXMessage));
  queue->msg->header.size = htons (msize + sizeof (struct UNIXMessage));
  queue->msg->sender = my_identity;
  memcpy (&queue->msg[1], msg, msize);
  GNUNET_CONTAINER_DLL_insert (queue_head, queue_tail, queue);
  GNUNET_assert (NULL != unix_sock);
  if (NULL == write_task)
    write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 unix_sock,
                                                 &select_write_cb,
                                                 NULL);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_malloc, GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, mq, msg, my_identity, queue(), queue_head, queue_tail, select_write_cb(), GNUNET_MessageHeader::size, unix_sock, and write_task.

Referenced by setup_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_destroy()

static void mq_destroy ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	our struct Queue

Definition at line 557 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = impl_state;
 
  if (mq == queue->mq)
  {
    queue->mq = NULL;
    queue_destroy (queue);
  }
}

References mq, queue(), and queue_destroy().

Referenced by setup_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_cancel()

static void mq_cancel ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Implementation function that cancels the currently sent message.

Parameters

mq	message queue
impl_state	our struct Queue

Definition at line 576 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = impl_state;
 
  GNUNET_assert (NULL != queue->msg);
  queue->msg = NULL;
  GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue);
  GNUNET_assert (NULL != write_task);
  if (NULL == queue_head)
  {
    GNUNET_SCHEDULER_cancel (write_task);
    write_task = NULL;
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_cancel(), queue(), queue_head, queue_tail, and write_task.

Referenced by setup_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error()

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

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	our struct Queue
error	error code

Definition at line 602 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "UNIX MQ error in queue to %s: %d\n",
              GNUNET_i2s (&queue->target),
              (int) error);
  queue_destroy (queue);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, queue(), and queue_destroy().

Referenced by setup_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_queue()

static struct Queue * setup_queue ( const struct GNUNET_PeerIdentity *  target, enum GNUNET_TRANSPORT_ConnectionStatus  cs, const struct sockaddr_un *  un, socklen_t  un_len  )

static

Creates a new outbound queue the transport service will use to send data to another peer.

Parameters

peer	the target peer
cs	inbound or outbound queue
un	the address
un_len	number of bytes in un

Returns

the queue or NULL of max connections exceeded

Definition at line 625 of file gnunet-communicator-unix.c.

{
  struct Queue *queue;
 
  queue = GNUNET_new (struct Queue);
  queue->target = *target;
  queue->address = GNUNET_memdup (un, un_len);
  queue->address_len = un_len;
  (void) GNUNET_CONTAINER_multipeermap_put (
    queue_map,
    &queue->target,
    queue,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_STATISTICS_set (stats,
                         "# queues active",
                         GNUNET_CONTAINER_multipeermap_size (queue_map),
                         GNUNET_NO);
  queue->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  queue->timeout_task =
    GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                  &queue_timeout,
                                  queue);
  queue->mq = GNUNET_MQ_queue_for_callbacks (&mq_send,
                                             &mq_destroy,
                                             &mq_cancel,
                                             queue,
                                             NULL,
                                             &mq_error,
                                             queue);
  {
    char *foreign_addr;
 
    if ('\0' == un->sun_path[0])
      GNUNET_asprintf (&foreign_addr,
                       "%s-@%s",
                       COMMUNICATOR_ADDRESS_PREFIX,
                       &un->sun_path[1]);
    else
      GNUNET_asprintf (&foreign_addr,
                       "%s-%s",
                       COMMUNICATOR_ADDRESS_PREFIX,
                       un->sun_path);
    queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch,
                                                      &queue->target,
                                                      foreign_addr,
                                                      UNIX_MTU - sizeof (struct
                                                                         UNIXMessage),
                                                      GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
                                                      0,
                                                      GNUNET_NT_LOOPBACK,
                                                      cs,
                                                      queue->mq);
    GNUNET_free (foreign_addr);
  }
  return queue;
}

References ch, COMMUNICATOR_ADDRESS_PREFIX, Queue::cs, GNUNET_asprintf(), GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_memdup, GNUNET_MQ_queue_for_callbacks(), GNUNET_new, GNUNET_NO, GNUNET_NT_LOOPBACK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, mq_cancel(), mq_destroy(), mq_error(), mq_send(), queue(), queue_map, queue_timeout(), stats, Queue::target, and UNIX_MTU.

Referenced by mq_init(), and select_read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

select_read_cb()

static void select_read_cb ( void *  cls )

static

We have been notified that our socket has something to read.

Do the read and reschedule this function to be called again once more is available.

Parameters

cls

NULL

Definition at line 732 of file gnunet-communicator-unix.c.

{
  char buf[65536] GNUNET_ALIGN;
  struct Queue *queue;
  const struct UNIXMessage *msg;
  struct sockaddr_un un;
  socklen_t addrlen;
  ssize_t ret;
  uint16_t msize;
 
  GNUNET_assert (NULL != unix_sock);
  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             unix_sock,
                                             &select_read_cb,
                                             NULL);
  addrlen = sizeof(un);
  memset (&un, 0, sizeof(un));
  ret = GNUNET_NETWORK_socket_recvfrom (unix_sock,
                                        buf,
                                        sizeof(buf),
                                        (struct sockaddr *) &un,
                                        &addrlen);
  if ((-1 == ret) && ((EAGAIN == errno) || (ENOBUFS == errno)))
    return;
  if (-1 == ret)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Read %d bytes from socket %s\n",
              (int) ret,
              un.sun_path);
  GNUNET_assert (AF_UNIX == (un.sun_family));
  msg = (struct UNIXMessage *) buf;
  msize = ntohs (msg->header.size);
  if ((msize < sizeof(struct UNIXMessage)) || (msize > ret))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Wrong message size: %d bytes\n",
                msize);
    GNUNET_break_op (0);
    return;
  }
  queue = lookup_queue (&msg->sender, &un, addrlen);
  if (NULL == queue)
    queue =
      setup_queue (&msg->sender, GNUNET_TRANSPORT_CS_INBOUND, &un, addrlen);
  else
    reschedule_queue_timeout (queue);
  if (NULL == queue)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ (
        "Maximum number of UNIX connections exceeded, dropping incoming message\n"));
    return;
  }
 
  {
    uint16_t tsize = msize - sizeof(struct UNIXMessage);
 
    const struct GNUNET_MessageHeader *currhdr;
    struct GNUNET_MessageHeader al_hdr;
 
    currhdr = (const struct GNUNET_MessageHeader *) &msg[1];
    /* ensure aligned access */
    memcpy (&al_hdr, currhdr, sizeof(al_hdr));
    if ((tsize < sizeof(struct GNUNET_MessageHeader)) ||
        (tsize != ntohs (al_hdr.size)))
    {
      GNUNET_break_op (0);
      return;
    }
    ret = GNUNET_TRANSPORT_communicator_receive (ch,
                                                 &msg->sender,
                                                 currhdr,
                                                 GNUNET_TIME_UNIT_FOREVER_REL,
                                                 &receive_complete_cb,
                                                 NULL);
    if (GNUNET_SYSERR == ret)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Transport not up!\n");
      return;   /* transport not up */
    }
    if (GNUNET_NO == ret)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Error sending message to transport\n");
      return;
    }
    delivering_messages++;
  }
  if (delivering_messages >= max_queue_length)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Back pressure %llu\n", delivering_messages);
 
    /* we should try to apply 'back pressure' */
    GNUNET_SCHEDULER_cancel (read_task);
    read_task = NULL;
  }
}

References _, ch, delivering_messages, GNUNET_ALIGN, GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_communicator_receive(), GNUNET_TRANSPORT_CS_INBOUND, lookup_queue(), max_queue_length, msg, queue(), read_task, receive_complete_cb(), reschedule_queue_timeout(), ret, select_read_cb(), setup_queue(), GNUNET_MessageHeader::size, and unix_sock.

Referenced by receive_complete_cb(), run(), and select_read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

receive_complete_cb()

static void receive_complete_cb ( void *  cls, int  success  )

static

Function called when message was successfully passed to transport service.

Continue read activity.

Parameters

cls	NULL
success	GNUNET_OK on success

Definition at line 706 of file gnunet-communicator-unix.c.

{
  (void) cls;
  delivering_messages--;
  if (GNUNET_OK != success)
    GNUNET_STATISTICS_update (stats,
                              "# transport transmission failures",
                              1,
                              GNUNET_NO);
  if ((NULL == read_task) && (delivering_messages < max_queue_length) &&
      (NULL != unix_sock))
    read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                               unix_sock,
                                               &select_read_cb,
                                               NULL);
}

References delivering_messages, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, max_queue_length, read_task, select_read_cb(), stats, and unix_sock.

Referenced by select_read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_init()

static int mq_init ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const char *  address  )

static

Function called by the transport service to initialize a message queue given address information about another peer.

If and when the communication channel is established, the communicator must call GNUNET_TRANSPORT_communicator_mq_add() to notify the service that the channel is now up. It is the responsibility of the communicator to manage sane retries and timeouts for any peer/address combination provided by the transport service. Timeouts and retries do not need to be signalled to the transport service.

Parameters

cls	closure
peer	identity of the other peer
address	where to send the message, human-readable communicator-specific format, 0-terminated, UTF-8

Returns

GNUNET_OK on success, GNUNET_SYSERR if the provided address is invalid

Definition at line 856 of file gnunet-communicator-unix.c.

{
  struct Queue *queue;
  const char *path;
  struct sockaddr_un *un;
  socklen_t un_len;
 
  (void) cls;
  if (0 != strncmp (address,
                    COMMUNICATOR_ADDRESS_PREFIX "-",
                    strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
  un = unix_address_to_sockaddr (path, &un_len);
  queue = lookup_queue (peer, un, un_len);
  if (NULL != queue)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Address `%s' for %s ignored, queue exists\n",
                path,
                GNUNET_i2s (peer));
    GNUNET_free (un);
    return GNUNET_OK;
  }
  queue = setup_queue (peer, GNUNET_TRANSPORT_CS_OUTBOUND, un, un_len);
  GNUNET_free (un);
  if (NULL == queue)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Failed to setup queue to %s at `%s'\n",
                GNUNET_i2s (peer),
                path);
    return GNUNET_NO;
  }
  return GNUNET_OK;
}

References address, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_break_op, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TRANSPORT_CS_OUTBOUND, lookup_queue(), queue(), setup_queue(), and unix_address_to_sockaddr().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

get_queue_delete_it()

static int get_queue_delete_it ( void *  cls, const struct GNUNET_PeerIdentity *  target, void *  value  )

static

Iterator over all message queues to clean up.

Parameters

cls	NULL
target	unused
value	the queue to destroy

Returns

GNUNET_OK to continue to iterate

Definition at line 906 of file gnunet-communicator-unix.c.

{
  struct Queue *queue = value;
 
  (void) cls;
  (void) target;
  queue_destroy (queue);
  return GNUNET_OK;
}

References GNUNET_OK, queue(), queue_destroy(), Queue::target, and value.

Referenced by do_shutdown().

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

Shutdown the UNIX communicator.

Parameters

cls	NULL (always)

Definition at line 925 of file gnunet-communicator-unix.c.

{
  if (NULL != read_task)
  {
    GNUNET_SCHEDULER_cancel (read_task);
    read_task = NULL;
  }
  if (NULL != write_task)
  {
    GNUNET_SCHEDULER_cancel (write_task);
    write_task = NULL;
  }
  if (NULL != unix_sock)
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (unix_sock));
    unix_sock = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (queue_map);
  if (NULL != ai)
  {
    GNUNET_TRANSPORT_communicator_address_remove (ai);
    ai = NULL;
  }
  if (NULL != ch)
  {
    GNUNET_TRANSPORT_communicator_disconnect (ch);
    ch = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
}

References ai, ch, get_queue_delete_it(), GNUNET_break, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_TRANSPORT_communicator_disconnect(), queue_map, read_task, stats, unix_sock, and write_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

enc_notify_cb()

static void enc_notify_cb ( void *  cls, const struct GNUNET_PeerIdentity *  sender, const struct GNUNET_MessageHeader *  msg  )

static

Function called when the transport service has received an acknowledgement for this communicator (!) via a different return path.

Not applicable for UNIX.

Parameters

cls	closure
sender	which peer sent the notification
msg	payload

Definition at line 974 of file gnunet-communicator-unix.c.

{
  (void) cls;
  (void) sender;
  (void) msg;
  GNUNET_break_op (0);
}

References GNUNET_break_op, and msg.

Referenced by run().

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

Setup communicator and launch network interactions.

Parameters

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

Definition at line 994 of file gnunet-communicator-unix.c.

{
  char *unix_socket_path;
  struct sockaddr_un *un;
  socklen_t un_len;
  char *my_addr;
  struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 
  (void) cls;
  delivering_messages = 0;
 
  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
  if (NULL == my_private_key)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ (
        "UNIX communicator is lacking key configuration settings. Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               COMMUNICATOR_CONFIG_SECTION,
                                               "UNIXPATH",
                                               &unix_socket_path))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               COMMUNICATOR_CONFIG_SECTION,
                               "UNIXPATH");
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             COMMUNICATOR_CONFIG_SECTION,
                                             "MAX_QUEUE_LENGTH",
                                             &max_queue_length))
    max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
 
  un = unix_address_to_sockaddr (unix_socket_path, &un_len);
  if (NULL == un)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup UNIX domain socket address with path `%s'\n",
                unix_socket_path);
    GNUNET_free (unix_socket_path);
    return;
  }
  unix_sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
  if (NULL == unix_sock)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
    GNUNET_free (un);
    GNUNET_free (unix_socket_path);
    return;
  }
  if (('\0' != un->sun_path[0]) &&
      (GNUNET_OK != GNUNET_DISK_directory_create_for_file (un->sun_path)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Cannot create path to `%s'\n"),
                un->sun_path);
    GNUNET_NETWORK_socket_close (unix_sock);
    unix_sock = NULL;
    GNUNET_free (un);
    GNUNET_free (unix_socket_path);
    return;
  }
  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (unix_sock,
                                               (const struct sockaddr *) un,
                                               un_len))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", un->sun_path);
    GNUNET_NETWORK_socket_close (unix_sock);
    unix_sock = NULL;
    GNUNET_free (un);
    GNUNET_free (unix_socket_path);
    return;
  }
  GNUNET_free (un);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", unix_socket_path);
  stats = GNUNET_STATISTICS_create ("C-UNIX", cfg);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             unix_sock,
                                             &select_read_cb,
                                             NULL);
  queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
  ch = GNUNET_TRANSPORT_communicator_connect (cfg,
                                              COMMUNICATOR_CONFIG_SECTION,
                                              COMMUNICATOR_ADDRESS_PREFIX,
                                              GNUNET_TRANSPORT_CC_RELIABLE,
                                              &mq_init,
                                              NULL,
                                              &enc_notify_cb,
                                              NULL,
                                              NULL);
  if (NULL == ch)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (unix_socket_path);
    return;
  }
  GNUNET_asprintf (&my_addr,
                   "%s-%s",
                   COMMUNICATOR_ADDRESS_PREFIX,
                   unix_socket_path);
  GNUNET_free (unix_socket_path);
  ai = GNUNET_TRANSPORT_communicator_address_add (ch,
                                                  my_addr,
                                                  GNUNET_NT_LOOPBACK,
                                                  GNUNET_TIME_UNIT_FOREVER_REL);
  GNUNET_free (my_addr);
}

References _, ai, cfg, ch, COMMUNICATOR_ADDRESS_PREFIX, COMMUNICATOR_CONFIG_SECTION, DEFAULT_MAX_QUEUE_LENGTH, delivering_messages, do_shutdown(), enc_notify_cb(), GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_NT_LOOPBACK, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_connect(), max_queue_length, mq_init(), my_identity, my_private_key, GNUNET_PeerIdentity::public_key, queue_map, read_task, select_read_cb(), stats, unix_address_to_sockaddr(), and unix_sock.

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
	)

The main function for the UNIX communicator.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 1124 of file gnunet-communicator-unix.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int ret;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                             argc,
                             argv,
                             "gnunet-communicator-unix",
                             _ ("GNUnet UNIX domain socket communicator"),
                             options,
                             &run,
                             NULL))
        ? 0
        : 1;
  return ret;
}

References _, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), options, ret, and run().

Here is the call graph for this function:

Variable Documentation

my_identity

struct GNUNET_PeerIdentity my_identity

static

My Peer Identity.

Definition at line 150 of file gnunet-communicator-unix.c.

Referenced by mq_send(), and run().

read_task

struct GNUNET_SCHEDULER_Task* read_task

static

ID of read task.

Definition at line 155 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), receive_complete_cb(), run(), and select_read_cb().

write_task

struct GNUNET_SCHEDULER_Task* write_task

static

ID of write task.

Definition at line 160 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), mq_cancel(), mq_send(), and select_write_cb().

delivering_messages

unsigned long long delivering_messages

static

Number of messages we currently have in our queues towards the transport service.

Definition at line 165 of file gnunet-communicator-unix.c.

Referenced by receive_complete_cb(), run(), and select_read_cb().

max_queue_length

unsigned long long max_queue_length

static

Maximum queue length before we stop reading towards the transport service.

Definition at line 170 of file gnunet-communicator-unix.c.

Referenced by receive_complete_cb(), run(), and select_read_cb().

stats

struct GNUNET_STATISTICS_Handle* stats

static

For logging statistics.

Definition at line 175 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), queue_destroy(), receive_complete_cb(), run(), select_write_cb(), and setup_queue().

ch

struct GNUNET_TRANSPORT_CommunicatorHandle* ch

static

Our environment.

Definition at line 180 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), run(), select_read_cb(), and setup_queue().

queue_map

struct GNUNET_CONTAINER_MultiPeerMap* queue_map

static

Queues (map from peer identity to struct Queue)

Definition at line 185 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), lookup_queue(), queue_destroy(), run(), and setup_queue().

queue_head

struct Queue* queue_head

static

Head of queue of messages to transmit.

Definition at line 190 of file gnunet-communicator-unix.c.

Referenced by check_for_queue_with_higher_prio(), mq_cancel(), mq_send(), queue_destroy(), schedule_transmit_on_queue(), and select_write_cb().

queue_tail

struct Queue* queue_tail

static

Tail of queue of messages to transmit.

Definition at line 195 of file gnunet-communicator-unix.c.

Referenced by mq_cancel(), mq_send(), queue_destroy(), and select_write_cb().

unix_sock

struct GNUNET_NETWORK_Handle* unix_sock

static

socket that we transmit all data with

Definition at line 200 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), mq_send(), receive_complete_cb(), run(), select_read_cb(), and select_write_cb().

ai

struct GNUNET_TRANSPORT_AddressIdentifier* ai

static

Handle to the operation that publishes our address.

Definition at line 205 of file gnunet-communicator-unix.c.

Referenced by add_setter_action(), attr_iter_cb(), attr_iter_error(), attr_iter_finished(), cleanup_client(), cred_iter_cb(), cred_iter_error(), cred_iter_finished(), do_shutdown(), enc_notify_cb(), GNUNET_NETWORK_test_port_free(), GNUNET_RESOLVER_local_fqdn_get(), GNUNET_STATISTICS_get(), GNUNET_TESTBED_reserve_port(), GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_TRANSPORT_communicator_address_remove_all(), handle_ack_by_sender(), handle_credential_iteration_next(), handle_credential_iteration_start(), handle_credential_iteration_stop(), handle_iteration_next(), handle_iteration_start(), handle_iteration_stop(), nat_address_cb(), reconnect(), run(), schedule_watch_request(), send_add_address(), and send_del_address().