gnunet-transport.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_resolver_service.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_service.h"

Include dependency graph for gnunet-transport.c:

Go to the source code of this file.

Data Structures
struct	ValidationResolutionContext
	Context to store name resolutions for validation. More...
struct	MonitoredPeer
	Struct to store information about peers in monitor mode. More...
struct	PeerResolutionContext
	Context to store name resolutions for validation. More...
struct	PluginMonitorAddress
	Context for address resolution by plugin_monitoring_cb(). More...

Macros
#define	RESOLUTION_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
	Timeout for a name resolution.
#define	OP_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
	Timeout for an operation.
#define	BLOCKSIZE   4
	Benchmarking block size in KB.

Functions
static int	destroy_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Function called to release data stored in the monitored_peers map.
static void	shutdown_task (void *cls)
	Task run in monitor mode when the user presses CTRL-C to abort.
static void	operation_timeout (void *cls)
	We are done, shut down.
static void	do_send (void *cls)
	Function called to notify a client about the socket begin ready to queue more data.
static void *	notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Function called to notify transport users that another peer connected to us.
static void	notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Function called to notify transport users that another peer disconnected from us.
static void *	monitor_notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Function called to notify transport users that another peer connected to us.
static void	monitor_notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Function called to notify transport users that another peer disconnected from us.
static int	check_dummy (void *cls, const struct GNUNET_MessageHeader *message)
	Function called by the transport for each received message.
static void	handle_dummy (void *cls, const struct GNUNET_MessageHeader *message)
	Function called by the transport for each received message.
static void	resolve_peer_address (const struct GNUNET_HELLO_Address *address, int numeric, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout)
	Convert address to a printable format.
static void	print_info (const struct GNUNET_PeerIdentity *id, const char *transport, const char *addr, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout)
static void	process_peer_string (void *cls, const char *address, int res)
	Function called with a textual representation of an address.
static void	process_peer_iteration_cb (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout)
	Function called with information about a peers during a one shot iteration.
static void	print_plugin_event_info (struct PluginMonitorAddress *addr, const struct GNUNET_TRANSPORT_SessionInfo *info)
	Print information about a plugin monitoring event.
static void	address_cb (void *cls, const char *address, int res)
	Function called with a textual representation of an address.
static void	plugin_monitoring_cb (void *cls, struct GNUNET_TRANSPORT_PluginSession *session, void **session_ctx, const struct GNUNET_TRANSPORT_SessionInfo *info)
	Function called by the plugin with information about the current sessions managed by the plugin (for monitoring).
static void	process_peer_monitoring_cb (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout)
	Function called with information about a peers.
static int	blacklist_cb (void *cls, const struct GNUNET_PeerIdentity *cpid)
	Function called with the transport service checking if we want to blacklist a peer.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *mycfg)
	Main function that will be run by the scheduler.
int	main (int argc, char *const *argv)

Variables
static struct GNUNET_TRANSPORT_CoreHandle *	handle
	Handle to transport service.
static struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration handle.
struct GNUNET_TRANSPORT_Blacklist *	blacklist
	Blacklisting handle.
static int	benchmark_send
	Option -s.
static int	benchmark_receive
	Option -b.
static int	iterate_connections
	Option -i.
static int	iterate_all
	Option -a.
static int	monitor_connects
	Option -c.
static int	monitor_connections
	Option -m.
static int	monitor_plugins
	Option -P.
static int	do_disconnect
	Option -D.
static int	numeric
	Option -n.
static int	ret
	Global return value (0 success).
static int	monitor_connect_counter
	Current number of connections in monitor mode.
static unsigned long long	traffic_received
	Number of bytes of traffic we received so far.
static unsigned long long	traffic_sent
	Number of bytes of traffic we sent so far.
static struct GNUNET_TIME_Absolute	start_time
	Starting time of transmitting/receiving data.
static struct GNUNET_CONTAINER_MultiPeerMap *	monitored_peers
	Map storing information about monitored peers.
static struct GNUNET_CONTAINER_MultiPeerMap *	monitored_plugins
	Map storing information about monitored plugins's sessions.
static struct GNUNET_TRANSPORT_PeerMonitoringContext *	pic
	Handle if we are monitoring peers at the transport level.
static struct GNUNET_TRANSPORT_PluginMonitor *	pm
	Handle if we are monitoring plugin session activity.
static struct GNUNET_PeerIdentity	pid
	Identity of the peer we transmit to / connect to.
static struct GNUNET_SCHEDULER_Task *	op_timeout
	Task for operation timeout.
static unsigned int	verbosity
	Selected level of verbosity.
struct GNUNET_OS_Process *	resolver
	Resolver process handle.
static unsigned int	address_resolutions
	Number of address resolutions pending.
static struct ValidationResolutionContext *	vc_head
	DLL: head of validation resolution entries.
static struct ValidationResolutionContext *	vc_tail
	DLL: tail of validation resolution entries.
static struct PeerResolutionContext *	rc_head
	DLL: head of resolution entries.
static struct PeerResolutionContext *	rc_tail
	DLL: head of resolution entries.

Macro Definition Documentation

RESOLUTION_TIMEOUT

#define RESOLUTION_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

Timeout for a name resolution.

Definition at line 36 of file gnunet-transport.c.

{
  struct ValidationResolutionContext *next;
 
  struct ValidationResolutionContext *prev;
 
  struct GNUNET_HELLO_Address *addrcp;
 
  struct GNUNET_TIME_Absolute last_validation;
 
  struct GNUNET_TIME_Absolute valid_until;
 
  struct GNUNET_TIME_Absolute next_validation;
 
  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
 
  char *transport;
 
  int printed;
};
 
struct MonitoredPeer
{
  enum GNUNET_TRANSPORT_PeerState state;
 
  struct GNUNET_TIME_Absolute state_timeout;
 
  struct GNUNET_HELLO_Address *address;
};
 
struct PeerResolutionContext
{
  struct PeerResolutionContext *next;
 
  struct PeerResolutionContext *prev;
 
  struct GNUNET_HELLO_Address *addrcp;
 
  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
 
  enum GNUNET_TRANSPORT_PeerState state;
 
  struct GNUNET_TIME_Absolute state_timeout;
 
  char *transport;
 
  int printed;
};
 
 
#define BLOCKSIZE 4
 
static struct GNUNET_TRANSPORT_CoreHandle *handle;
 
static struct GNUNET_CONFIGURATION_Handle *cfg;
 
struct GNUNET_TRANSPORT_Blacklist *blacklist;
 
static int benchmark_send;
 
static int benchmark_receive;
 
static int benchmark_receive;
 
static int iterate_connections;
 
static int iterate_all;
 
static int monitor_connects;
 
static int monitor_connections;
 
static int monitor_plugins;
 
static int do_disconnect;
 
static int numeric;
 
static int ret;
 
static int monitor_connect_counter;
 
static unsigned long long traffic_received;
 
static unsigned long long traffic_sent;
 
static struct GNUNET_TIME_Absolute start_time;
 
static struct GNUNET_CONTAINER_MultiPeerMap *monitored_peers;
 
static struct GNUNET_CONTAINER_MultiPeerMap *monitored_plugins;
 
static struct GNUNET_TRANSPORT_PeerMonitoringContext *pic;
 
static struct GNUNET_TRANSPORT_PluginMonitor *pm;
 
static struct GNUNET_PeerIdentity pid;
 
static struct GNUNET_SCHEDULER_Task *op_timeout;
 
static unsigned int verbosity;
 
struct GNUNET_OS_Process *resolver;
 
static unsigned int address_resolutions;
 
static struct ValidationResolutionContext *vc_head;
 
static struct ValidationResolutionContext *vc_tail;
 
static struct PeerResolutionContext *rc_head;
 
static struct PeerResolutionContext *rc_tail;
 
 
static int
destroy_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
{
  struct MonitoredPeer *m = value;
 
  GNUNET_assert (
    GNUNET_OK ==
    GNUNET_CONTAINER_multipeermap_remove (monitored_peers, key, value));
  GNUNET_free (m->address);
  GNUNET_free (value);
  return GNUNET_OK;
}
 
 
static void
shutdown_task (void *cls)
{
  struct GNUNET_TIME_Relative duration;
  struct ValidationResolutionContext *cur;
  struct ValidationResolutionContext *next;
  struct PeerResolutionContext *rc;
 
  if (NULL != op_timeout)
  {
    GNUNET_SCHEDULER_cancel (op_timeout);
    op_timeout = NULL;
  }
  if (NULL != pic)
  {
    GNUNET_TRANSPORT_monitor_peers_cancel (pic);
    pic = NULL;
  }
  if (NULL != pm)
  {
    GNUNET_TRANSPORT_monitor_plugins_cancel (pm);
    pm = NULL;
  }
 
  next = vc_head;
  for (cur = next; NULL != cur; cur = next)
  {
    next = cur->next;
 
    GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
    GNUNET_CONTAINER_DLL_remove (vc_head, vc_tail, cur);
    GNUNET_free (cur->transport);
    GNUNET_HELLO_address_free (cur->addrcp);
    GNUNET_free (cur);
  }
  while (NULL != (rc = rc_head))
  {
    GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
    GNUNET_TRANSPORT_address_to_string_cancel (rc->asc);
    GNUNET_free (rc->transport);
    GNUNET_free (rc->addrcp);
    GNUNET_free (rc);
  }
  if (NULL != handle)
  {
    GNUNET_TRANSPORT_core_disconnect (handle);
    handle = NULL;
  }
  if (benchmark_send)
  {
    duration = GNUNET_TIME_absolute_get_duration (start_time);
    fprintf (stdout,
             _ ("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
             1000LL * 1000LL * traffic_sent / (1 + duration.rel_value_us),
             traffic_sent,
             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
  }
  if (benchmark_receive)
  {
    duration = GNUNET_TIME_absolute_get_duration (start_time);
    fprintf (stdout,
             _ ("Received %llu bytes/s (%llu bytes in %s)\n"),
             1000LL * 1000LL * traffic_received / (1 + duration.rel_value_us),
             traffic_received,
             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
  }
 
  if (NULL != monitored_peers)
  {
    GNUNET_CONTAINER_multipeermap_iterate (monitored_peers, &destroy_it, NULL);
    GNUNET_CONTAINER_multipeermap_destroy (monitored_peers);
    monitored_peers = NULL;
  }
  if (NULL != monitored_plugins)
  {
    GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (monitored_plugins));
    GNUNET_CONTAINER_multipeermap_destroy (monitored_plugins);
    monitored_plugins = NULL;
  }
  if (NULL != blacklist)
  {
    GNUNET_TRANSPORT_blacklist_cancel (blacklist);
    blacklist = NULL;
    ret = 0;
  }
}
 
 
static void
operation_timeout (void *cls)
{
  struct PeerResolutionContext *cur;
  struct PeerResolutionContext *next;
 
  op_timeout = NULL;
  if ((benchmark_send) || (benchmark_receive))
  {
    fprintf (stdout, _ ("Failed to connect to `%s'\n"), GNUNET_i2s_full (&pid));
    GNUNET_SCHEDULER_shutdown ();
    ret = 1;
    return;
  }
  if (iterate_connections)
  {
    next = rc_head;
    while (NULL != (cur = next))
    {
      next = cur->next;
      fprintf (stdout,
               _ ("Failed to resolve address for peer `%s'\n"),
               GNUNET_i2s (&cur->addrcp->peer));
 
      GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, cur);
      GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
      GNUNET_free (cur->transport);
      GNUNET_free (cur->addrcp);
      GNUNET_free (cur);
    }
    fprintf (stdout,
             "%s",
             _ ("Failed to list connections, timeout occurred\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret = 1;
    return;
  }
}
 
 
static void
do_send (void *cls)
{
  struct GNUNET_MQ_Handle *mq = cls;
  struct GNUNET_MessageHeader *m;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg_extra (m, BLOCKSIZE * 1024, GNUNET_MESSAGE_TYPE_DUMMY);
  memset (&m[1], 52, BLOCKSIZE * 1024 - sizeof(struct GNUNET_MessageHeader));
  traffic_sent += BLOCKSIZE * 1024;
  GNUNET_MQ_notify_sent (env, &do_send, mq);
  if (verbosity > 0)
    fprintf (stdout,
             _ ("Transmitting %u bytes\n"),
             (unsigned int) BLOCKSIZE * 1024);
  GNUNET_MQ_send (mq, env);
}
 
 
static void *
notify_connect (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                struct GNUNET_MQ_Handle *mq)
{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
    return NULL;
  ret = 0;
  if (! benchmark_send)
    return NULL;
  if (NULL != op_timeout)
  {
    GNUNET_SCHEDULER_cancel (op_timeout);
    op_timeout = NULL;
  }
  if (verbosity > 0)
    fprintf (
      stdout,
      _ (
        "Successfully connected to `%s', starting to send benchmark data in %u Kb blocks\n"),
      GNUNET_i2s (peer),
      BLOCKSIZE);
  start_time = GNUNET_TIME_absolute_get ();
  do_send (mq);
  return mq;
}
 
 
static void
notify_disconnect (void *cls,
                   const struct GNUNET_PeerIdentity *peer,
                   void *internal_cls)
{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
    return;
  if (NULL == internal_cls)
    return; /* not about target peer */
  if (! benchmark_send)
    return; /* not transmitting */
  fprintf (stdout,
           _ ("Disconnected from peer `%s' while benchmarking\n"),
           GNUNET_i2s (&pid));
}
 
 
static void *
monitor_notify_connect (void *cls,
                        const struct GNUNET_PeerIdentity *peer,
                        struct GNUNET_MQ_Handle *mq)
{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
 
  monitor_connect_counter++;
  fprintf (stdout,
           _ ("%24s: %-17s %4s   (%u connections in total)\n"),
           now_str,
           _ ("Connected to"),
           GNUNET_i2s (peer),
           monitor_connect_counter);
  return NULL;
}
 
 
static void
monitor_notify_disconnect (void *cls,
                           const struct GNUNET_PeerIdentity *peer,
                           void *internal_cls)
{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
 
  GNUNET_assert (monitor_connect_counter > 0);
  monitor_connect_counter--;
 
  fprintf (stdout,
           _ ("%24s: %-17s %4s   (%u connections in total)\n"),
           now_str,
           _ ("Disconnected from"),
           GNUNET_i2s (peer),
           monitor_connect_counter);
}
 
 
static int
check_dummy (void *cls, const struct GNUNET_MessageHeader *message)
{
  return GNUNET_OK; /* all messages are fine */
}
 
 
static void
handle_dummy (void *cls, const struct GNUNET_MessageHeader *message)
{
  if (! benchmark_receive)
    return;
  if (verbosity > 0)
    fprintf (stdout,
             _ ("Received %u bytes\n"),
             (unsigned int) ntohs (message->size));
  if (0 == traffic_received)
    start_time = GNUNET_TIME_absolute_get ();
  traffic_received += ntohs (message->size);
}
 
 
static void
resolve_peer_address (const struct GNUNET_HELLO_Address *address,
                      int numeric,
                      enum GNUNET_TRANSPORT_PeerState state,
                      struct GNUNET_TIME_Absolute state_timeout);
 
 
static void
print_info (const struct GNUNET_PeerIdentity *id,
            const char *transport,
            const char *addr,
            enum GNUNET_TRANSPORT_PeerState state,
            struct GNUNET_TIME_Absolute state_timeout)
{
  if (((GNUNET_YES == iterate_connections) && (GNUNET_YES == iterate_all)) ||
      (GNUNET_YES == monitor_connections))
  {
    fprintf (stdout,
             _ ("Peer `%s': %s %s in state `%s' until %s\n"),
             GNUNET_i2s (id),
             (NULL == transport) ? "<none>" : transport,
             (NULL == transport) ? "<none>" : addr,
             GNUNET_TRANSPORT_ps2s (state),
             GNUNET_STRINGS_absolute_time_to_string (state_timeout));
  }
  else if ((GNUNET_YES == iterate_connections) &&
           (GNUNET_TRANSPORT_is_connected (state)))
  {
    /* Only connected peers, skip state */
    fprintf (stdout,
             _ ("Peer `%s': %s %s\n"),
             GNUNET_i2s (id),
             transport,
             addr);
  }
}
 
 
static void
process_peer_string (void *cls, const char *address, int res)
{
  struct PeerResolutionContext *rc = cls;
 
  if (NULL != address)
  {
    if (GNUNET_SYSERR == res)
    {
      fprintf (
        stderr,
        "Failed to convert address for peer `%s' plugin `%s' length %u to string \n",
        GNUNET_i2s (&rc->addrcp->peer),
        rc->addrcp->transport_name,
        (unsigned int) rc->addrcp->address_length);
      print_info (&rc->addrcp->peer,
                  rc->transport,
                  NULL,
                  rc->state,
                  rc->state_timeout);
      rc->printed = GNUNET_YES;
      return;
    }
    if (GNUNET_OK == res)
    {
      print_info (&rc->addrcp->peer,
                  rc->transport,
                  address,
                  rc->state,
                  rc->state_timeout);
      rc->printed = GNUNET_YES;
      return;     /* Wait for done call */
    }
    /* GNUNET_NO == res: ignore, was simply not supported */
    return;
  }
  /* NULL == address, last call, we are done */
 
  rc->asc = NULL;
  GNUNET_assert (address_resolutions > 0);
  address_resolutions--;
  if (GNUNET_NO == rc->printed)
  {
    if (numeric == GNUNET_NO)
    {
      /* Failed to resolve address, try numeric lookup
         (note: this should not be needed, as transport
         should fallback to numeric conversion if DNS takes
         too long) */
      resolve_peer_address (rc->addrcp,
                            GNUNET_YES,
                            rc->state,
                            rc->state_timeout);
    }
    else
    {
      print_info (&rc->addrcp->peer,
                  rc->transport,
                  NULL,
                  rc->state,
                  rc->state_timeout);
    }
  }
  GNUNET_free (rc->transport);
  GNUNET_free (rc->addrcp);
  GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
  GNUNET_free (rc);
  if ((0 == address_resolutions) && (iterate_connections))
  {
    if (NULL != op_timeout)
    {
      GNUNET_SCHEDULER_cancel (op_timeout);
      op_timeout = NULL;
    }
    ret = 0;
    GNUNET_SCHEDULER_shutdown ();
  }
}
 
 
static void
resolve_peer_address (const struct GNUNET_HELLO_Address *address,
                      int numeric,
                      enum GNUNET_TRANSPORT_PeerState state,
                      struct GNUNET_TIME_Absolute state_timeout)
{
  struct PeerResolutionContext *rc;
 
  rc = GNUNET_new (struct PeerResolutionContext);
  GNUNET_CONTAINER_DLL_insert (rc_head, rc_tail, rc);
  address_resolutions++;
  rc->transport = GNUNET_strdup (address->transport_name);
  rc->addrcp = GNUNET_HELLO_address_copy (address);
  rc->printed = GNUNET_NO;
  rc->state = state;
  rc->state_timeout = state_timeout;
  /* Resolve address to string */
  rc->asc = GNUNET_TRANSPORT_address_to_string (cfg,
                                                address,
                                                numeric,
                                                RESOLUTION_TIMEOUT,
                                                &process_peer_string,
                                                rc);
}
 
 
static void
process_peer_iteration_cb (void *cls,
                           const struct GNUNET_PeerIdentity *peer,
                           const struct GNUNET_HELLO_Address *address,
                           enum GNUNET_TRANSPORT_PeerState state,
                           struct GNUNET_TIME_Absolute state_timeout)
{
  if (NULL == peer)
  {
    /* done */
    pic = NULL;
    return;
  }
 
  if ((GNUNET_NO == iterate_all) &&
      (GNUNET_NO == GNUNET_TRANSPORT_is_connected (state)))
    return; /* Display only connected peers */
 
  if (NULL != op_timeout)
    GNUNET_SCHEDULER_cancel (op_timeout);
  op_timeout =
    GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received address for peer `%s': %s\n",
              GNUNET_i2s (peer),
              address ? address->transport_name : "");
 
  if (NULL != address)
    resolve_peer_address (address, numeric, state, state_timeout);
  else
    print_info (peer, NULL, NULL, state, state_timeout);
}
 
 
struct PluginMonitorAddress
{
  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
 
  char *str;
 
  struct GNUNET_TRANSPORT_SessionInfo si;
};
 
 
static void
print_plugin_event_info (struct PluginMonitorAddress *addr,
                         const struct GNUNET_TRANSPORT_SessionInfo *info)
{
  const char *state;
 
  switch (info->state)
  {
  case GNUNET_TRANSPORT_SS_INIT:
    state = "INIT";
    break;
 
  case GNUNET_TRANSPORT_SS_HANDSHAKE:
    state = "HANDSHAKE";
    break;
 
  case GNUNET_TRANSPORT_SS_UP:
    state = "UP";
    break;
 
  case GNUNET_TRANSPORT_SS_UPDATE:
    state = "UPDATE";
    break;
 
  case GNUNET_TRANSPORT_SS_DONE:
    state = "DONE";
    break;
 
  default:
    state = "UNKNOWN";
    break;
  }
  fprintf (stdout,
           "%s: state %s timeout in %s @ %s%s\n",
           GNUNET_i2s (&info->address->peer),
           state,
           GNUNET_STRINGS_relative_time_to_string (
             GNUNET_TIME_absolute_get_remaining (info->session_timeout),
             GNUNET_YES),
           addr->str,
           (info->is_inbound == GNUNET_YES) ? " (INBOUND)" : "");
  fprintf (stdout,
           "%s: queue has %3u messages and %6u bytes\n",
           GNUNET_i2s (&info->address->peer),
           info->num_msg_pending,
           info->num_bytes_pending);
  if (0 !=
      GNUNET_TIME_absolute_get_remaining (info->receive_delay).rel_value_us)
    fprintf (stdout,
             "%s: receiving blocked until %s\n",
             GNUNET_i2s (&info->address->peer),
             GNUNET_STRINGS_absolute_time_to_string (info->receive_delay));
}
 
 
static void
address_cb (void *cls, const char *address, int res)
{
  struct PluginMonitorAddress *addr = cls;
 
  if (NULL == address)
  {
    addr->asc = NULL;
    return;
  }
  if (NULL != addr->str)
    return;
  addr->str = GNUNET_strdup (address);
  print_plugin_event_info (addr, &addr->si);
}
 
 
static void
plugin_monitoring_cb (void *cls,
                      struct GNUNET_TRANSPORT_PluginSession *session,
                      void **session_ctx,
                      const struct GNUNET_TRANSPORT_SessionInfo *info)
{
  struct PluginMonitorAddress *addr;
 
  if ((NULL == info) && (NULL == session))
    return; /* in sync with transport service */
  addr = *session_ctx;
  if (NULL == info)
  {
    if (NULL != addr)
    {
      if (NULL != addr->asc)
      {
        GNUNET_TRANSPORT_address_to_string_cancel (addr->asc);
        addr->asc = NULL;
      }
      GNUNET_free (addr->str);
      GNUNET_free (addr);
      *session_ctx = NULL;
    }
    return;   /* shutdown */
  }
  if (0 !=
      memcmp (&info->address->peer, &pid, sizeof(struct GNUNET_PeerIdentity)))
    return; /* filtered */
  if (NULL == addr)
  {
    addr = GNUNET_new (struct PluginMonitorAddress);
    addr->asc =
      GNUNET_TRANSPORT_address_to_string (cfg,
                                          info->address,
                                          numeric,
                                          GNUNET_TIME_UNIT_FOREVER_REL,
                                          &address_cb,
                                          addr);
    *session_ctx = addr;
  }
  if (NULL == addr->str)
    addr->si = *info;
  else
    print_plugin_event_info (addr, info);
  if (GNUNET_TRANSPORT_SS_DONE == info->state)
  {
    if (NULL != addr->asc)
    {
      GNUNET_TRANSPORT_address_to_string_cancel (addr->asc);
      addr->asc = NULL;
    }
    GNUNET_free (addr->str);
    GNUNET_free (addr);
    *session_ctx = NULL;
  }
}
 
 
static void
process_peer_monitoring_cb (void *cls,
                            const struct GNUNET_PeerIdentity *peer,
                            const struct GNUNET_HELLO_Address *address,
                            enum GNUNET_TRANSPORT_PeerState state,
                            struct GNUNET_TIME_Absolute state_timeout)
{
  struct MonitoredPeer *m;
 
  if (NULL == peer)
  {
    fprintf (stdout,
             "%s",
             _ (
               "Monitor disconnected from transport service. Reconnecting.\n"));
    return;
  }
 
  if (NULL != op_timeout)
    GNUNET_SCHEDULER_cancel (op_timeout);
  op_timeout =
    GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
 
  if (NULL == (m = GNUNET_CONTAINER_multipeermap_get (monitored_peers, peer)))
  {
    m = GNUNET_new (struct MonitoredPeer);
    GNUNET_CONTAINER_multipeermap_put (
      monitored_peers,
      peer,
      m,
      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
  }
  else
  {
    if ((m->state == state) &&
        (m->state_timeout.abs_value_us == state_timeout.abs_value_us) &&
        (NULL == address) && (NULL == m->address))
    {
      return;     /* No real change */
    }
    if ((m->state == state) && (NULL != address) && (NULL != m->address) &&
        (0 == GNUNET_HELLO_address_cmp (m->address, address)))
      return;   /* No real change */
  }
 
  if (NULL != m->address)
  {
    GNUNET_free (m->address);
    m->address = NULL;
  }
  if (NULL != address)
    m->address = GNUNET_HELLO_address_copy (address);
  m->state = state;
  m->state_timeout = state_timeout;
 
  if (NULL != address)
    resolve_peer_address (m->address, numeric, m->state, m->state_timeout);
  else
    print_info (peer, NULL, NULL, m->state, m->state_timeout);
}
 
 
static int
blacklist_cb (void *cls, const struct GNUNET_PeerIdentity *cpid)
{
  if (0 == memcmp (cpid, &pid, sizeof(struct GNUNET_PeerIdentity)))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *mycfg)
{
  static struct GNUNET_PeerIdentity zero_pid;
  int counter = 0;
 
  ret = 1;
 
  cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
 
  counter = benchmark_send + benchmark_receive + iterate_connections
            + monitor_connections + monitor_connects + do_disconnect
            + monitor_plugins;
 
  if (1 < counter)
  {
    fprintf (
      stderr,
      _ (
        "Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s %s\n"),
      "disconnect",
      "benchmark send",
      "benchmark receive",
      "information",
      "monitor",
      "events",
      "plugins");
    return;
  }
  if (0 == counter)
  {
    fprintf (
      stderr,
      _ (
        "No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s, %s\n"),
      "disconnect",
      "benchmark send",
      "benchmark receive",
      "information",
      "monitor",
      "events",
      "plugins");
    return;
  }
 
  if (do_disconnect) /* -D: Disconnect from peer */
  {
    if (0 == memcmp (&zero_pid, &pid, sizeof(pid)))
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense without option `%s'.\n"),
               "-D",
               "-p");
      ret = 1;
      return;
    }
    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_cb, NULL);
    if (NULL == blacklist)
    {
      fprintf (stderr,
               "%s",
               _ (
                 "Failed to connect to transport service for disconnection\n"));
      ret = 1;
      return;
    }
    fprintf (stdout,
             "%s",
             _ ("Blacklisting request in place, stop with CTRL-C\n"));
  }
  else if (benchmark_send) /* -s: Benchmark sending */
  {
    if (0 == memcmp (&zero_pid, &pid, sizeof(pid)))
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense without option `%s'.\n"),
               "-s",
               "-p");
      ret = 1;
      return;
    }
    handle = GNUNET_TRANSPORT_core_connect (cfg,
                                            NULL,
                                            NULL,
                                            NULL,
                                            &notify_connect,
                                            &notify_disconnect,
                                            NULL);
    if (NULL == handle)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
      ret = 1;
      return;
    }
    start_time = GNUNET_TIME_absolute_get ();
    op_timeout =
      GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
  }
  else if (benchmark_receive) /* -b: Benchmark receiving */
  {
    struct GNUNET_MQ_MessageHandler handlers[] =
    { GNUNET_MQ_hd_var_size (dummy,
                             GNUNET_MESSAGE_TYPE_DUMMY,
                             struct GNUNET_MessageHeader,
                             NULL),
      GNUNET_MQ_handler_end () };
 
    handle = GNUNET_TRANSPORT_core_connect (cfg,
                                            NULL,
                                            handlers,
                                            NULL,
                                            NULL,
                                            NULL,
                                            NULL);
    if (NULL == handle)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
      ret = 1;
      return;
    }
    if (verbosity > 0)
      fprintf (stdout, "%s", _ ("Starting to receive benchmark data\n"));
    start_time = GNUNET_TIME_absolute_get ();
  }
  else if (iterate_connections) /* -i: List information about peers once */
  {
    pic = GNUNET_TRANSPORT_monitor_peers (cfg,
                                          &pid,
                                          GNUNET_YES,
                                          &process_peer_iteration_cb,
                                          (void *) cfg);
    op_timeout =
      GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
  }
  else if (monitor_connections) /* -m: List information about peers continuously
                                 */
  {
    monitored_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
    pic = GNUNET_TRANSPORT_monitor_peers (cfg,
                                          &pid,
                                          GNUNET_NO,
                                          &process_peer_monitoring_cb,
                                          NULL);
  }
  else if (monitor_plugins) /* -P: List information about plugins continuously
                             */
  {
    monitored_plugins = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
    pm = GNUNET_TRANSPORT_monitor_plugins (cfg, &plugin_monitoring_cb, NULL);
  }
  else if (monitor_connects) /* -e : Monitor (dis)connect events continuously */
  {
    monitor_connect_counter = 0;
    handle = GNUNET_TRANSPORT_core_connect (cfg,
                                            NULL,
                                            NULL,
                                            NULL,
                                            &monitor_notify_connect,
                                            &monitor_notify_disconnect,
                                            NULL);
    if (NULL == handle)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
      ret = 1;
      return;
    }
    ret = 0;
  }
  else
  {
    GNUNET_break (0);
    return;
  }
 
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}
 
 
int
main (int argc, char *const *argv)
{
  int res;
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag (
      'a',
      "all",
      gettext_noop (
        "print information for all peers (instead of only connected peers)"),
      &iterate_all),
    GNUNET_GETOPT_option_flag (
      'b',
      "benchmark",
      gettext_noop (
        "measure how fast we are receiving data from all peers (until CTRL-C)"),
      &benchmark_receive),
    GNUNET_GETOPT_option_flag ('D',
                               "disconnect",
                               gettext_noop ("disconnect from a peer"),
                               &do_disconnect),
    GNUNET_GETOPT_option_flag (
      'i',
      "information",
      gettext_noop (
        "provide information about all current connections (once)"),
      &iterate_connections),
    GNUNET_GETOPT_option_flag (
      'm',
      "monitor",
      gettext_noop (
        "provide information about all current connections (continuously)"),
      &monitor_connections),
    GNUNET_GETOPT_option_flag (
      'e',
      "events",
      gettext_noop (
        "provide information about all connects and disconnect events (continuously)"),
      &monitor_connects),
    GNUNET_GETOPT_option_flag ('n',
                               "numeric",
                               gettext_noop ("do not resolve hostnames"),
                               &numeric),
    GNUNET_GETOPT_option_base32_auto ('p',
                                      "peer",
                                      "PEER",
                                      gettext_noop ("peer identity"),
                                      &pid),
    GNUNET_GETOPT_option_flag ('P',
                               "plugins",
                               gettext_noop ("monitor plugin sessions"),
                               &monitor_plugins),
    GNUNET_GETOPT_option_flag (
      's',
      "send",
      gettext_noop (
        "send data for benchmarking to the other peer (until CTRL-C)"),
      &benchmark_send),
    GNUNET_GETOPT_option_verbose (&verbosity),
    GNUNET_GETOPT_OPTION_END };
 
  res =
    GNUNET_PROGRAM_run (argc,
                        argv,
                        "gnunet-transport",
                        gettext_noop ("Direct access to transport service."),
                        options,
                        &run,
                        NULL);
  if (GNUNET_OK == res)
    return ret;
  return 1;
}
 
 
/* end of gnunet-transport.c */

OP_TIMEOUT

#define OP_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

Timeout for an operation.

Definition at line 42 of file gnunet-transport.c.

BLOCKSIZE

#define BLOCKSIZE   4

Benchmarking block size in KB.

Definition at line 167 of file gnunet-transport.c.

Function Documentation

destroy_it()

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

static

Function called to release data stored in the monitored_peers map.

Parameters

cls	unused
key	the peer identity
value	a struct MonitoredPeer to release

Returns

GNUNET_OK (continue to iterate)

Definition at line 335 of file gnunet-transport.c.

{
  struct MonitoredPeer *m = value;
 
  GNUNET_assert (
    GNUNET_OK ==
    GNUNET_CONTAINER_multipeermap_remove (monitored_peers, key, value));
  GNUNET_free (m->address);
  GNUNET_free (value);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, key, m, monitored_peers, and value.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run in monitor mode when the user presses CTRL-C to abort.

Stops monitoring activity.

Parameters

cls

NULL

Definition at line 355 of file gnunet-transport.c.

{
  struct GNUNET_TIME_Relative duration;
  struct ValidationResolutionContext *cur;
  struct ValidationResolutionContext *next;
  struct PeerResolutionContext *rc;
 
  if (NULL != op_timeout)
  {
    GNUNET_SCHEDULER_cancel (op_timeout);
    op_timeout = NULL;
  }
  if (NULL != pic)
  {
    GNUNET_TRANSPORT_monitor_peers_cancel (pic);
    pic = NULL;
  }
  if (NULL != pm)
  {
    GNUNET_TRANSPORT_monitor_plugins_cancel (pm);
    pm = NULL;
  }
 
  next = vc_head;
  for (cur = next; NULL != cur; cur = next)
  {
    next = cur->next;
 
    GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
    GNUNET_CONTAINER_DLL_remove (vc_head, vc_tail, cur);
    GNUNET_free (cur->transport);
    GNUNET_HELLO_address_free (cur->addrcp);
    GNUNET_free (cur);
  }
  while (NULL != (rc = rc_head))
  {
    GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
    GNUNET_TRANSPORT_address_to_string_cancel (rc->asc);
    GNUNET_free (rc->transport);
    GNUNET_free (rc->addrcp);
    GNUNET_free (rc);
  }
  if (NULL != handle)
  {
    GNUNET_TRANSPORT_core_disconnect (handle);
    handle = NULL;
  }
  if (benchmark_send)
  {
    duration = GNUNET_TIME_absolute_get_duration (start_time);
    fprintf (stdout,
             _ ("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
             1000LL * 1000LL * traffic_sent / (1 + duration.rel_value_us),
             traffic_sent,
             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
  }
  if (benchmark_receive)
  {
    duration = GNUNET_TIME_absolute_get_duration (start_time);
    fprintf (stdout,
             _ ("Received %llu bytes/s (%llu bytes in %s)\n"),
             1000LL * 1000LL * traffic_received / (1 + duration.rel_value_us),
             traffic_received,
             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
  }
 
  if (NULL != monitored_peers)
  {
    GNUNET_CONTAINER_multipeermap_iterate (monitored_peers, &destroy_it, NULL);
    GNUNET_CONTAINER_multipeermap_destroy (monitored_peers);
    monitored_peers = NULL;
  }
  if (NULL != monitored_plugins)
  {
    GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (monitored_plugins));
    GNUNET_CONTAINER_multipeermap_destroy (monitored_plugins);
    monitored_plugins = NULL;
  }
  if (NULL != blacklist)
  {
    GNUNET_TRANSPORT_blacklist_cancel (blacklist);
    blacklist = NULL;
    ret = 0;
  }
}

References _, ValidationResolutionContext::addrcp, PeerResolutionContext::addrcp, ValidationResolutionContext::asc, PeerResolutionContext::asc, benchmark_receive, benchmark_send, blacklist, destroy_it(), duration, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_YES, handle, monitored_peers, monitored_plugins, ValidationResolutionContext::next, PeerResolutionContext::next, op_timeout, pic, pm, rc_head, rc_tail, GNUNET_TIME_Relative::rel_value_us, ret, start_time, traffic_received, traffic_sent, ValidationResolutionContext::transport, PeerResolutionContext::transport, vc_head, and vc_tail.

Here is the call graph for this function:

operation_timeout()

static void operation_timeout ( void *  cls )

static

We are done, shut down.

Definition at line 446 of file gnunet-transport.c.

{
  struct PeerResolutionContext *cur;
  struct PeerResolutionContext *next;
 
  op_timeout = NULL;
  if ((benchmark_send) || (benchmark_receive))
  {
    fprintf (stdout, _ ("Failed to connect to `%s'\n"), GNUNET_i2s_full (&pid));
    GNUNET_SCHEDULER_shutdown ();
    ret = 1;
    return;
  }
  if (iterate_connections)
  {
    next = rc_head;
    while (NULL != (cur = next))
    {
      next = cur->next;
      fprintf (stdout,
               _ ("Failed to resolve address for peer `%s'\n"),
               GNUNET_i2s (&cur->addrcp->peer));
 
      GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, cur);
      GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
      GNUNET_free (cur->transport);
      GNUNET_free (cur->addrcp);
      GNUNET_free (cur);
    }
    fprintf (stdout,
             "%s",
             _ ("Failed to list connections, timeout occurred\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret = 1;
    return;
  }
}

References _, PeerResolutionContext::addrcp, PeerResolutionContext::asc, benchmark_receive, benchmark_send, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_i2s(), GNUNET_i2s_full(), GNUNET_SCHEDULER_shutdown(), iterate_connections, PeerResolutionContext::next, op_timeout, pid, rc_head, rc_tail, ret, and PeerResolutionContext::transport.

Referenced by process_peer_iteration_cb(), process_peer_monitoring_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

do_send()

static void do_send ( void *  cls )

static

Function called to notify a client about the socket begin ready to queue more data.

Sends another message.

Parameters

cls	closure with the message queue

Definition at line 492 of file gnunet-transport.c.

{
  struct GNUNET_MQ_Handle *mq = cls;
  struct GNUNET_MessageHeader *m;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg_extra (m, BLOCKSIZE * 1024, GNUNET_MESSAGE_TYPE_DUMMY);
  memset (&m[1], 52, BLOCKSIZE * 1024 - sizeof(struct GNUNET_MessageHeader));
  traffic_sent += BLOCKSIZE * 1024;
  GNUNET_MQ_notify_sent (env, &do_send, mq);
  if (verbosity > 0)
    fprintf (stdout,
             _ ("Transmitting %u bytes\n"),
             (unsigned int) BLOCKSIZE * 1024);
  GNUNET_MQ_send (mq, env);
}

References _, BLOCKSIZE, do_send(), env, GNUNET_MESSAGE_TYPE_DUMMY, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), m, mq, traffic_sent, and verbosity.

Referenced by do_send(), and notify_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_connect()

static void * notify_connect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Function called to notify transport users that another peer connected to us.

Parameters

cls	closure
peer	the peer that connected
mq	message queue for sending to peer

Definition at line 519 of file gnunet-transport.c.

{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
    return NULL;
  ret = 0;
  if (! benchmark_send)
    return NULL;
  if (NULL != op_timeout)
  {
    GNUNET_SCHEDULER_cancel (op_timeout);
    op_timeout = NULL;
  }
  if (verbosity > 0)
    fprintf (
      stdout,
      _ (
        "Successfully connected to `%s', starting to send benchmark data in %u Kb blocks\n"),
      GNUNET_i2s (peer),
      BLOCKSIZE);
  start_time = GNUNET_TIME_absolute_get ();
  do_send (mq);
  return mq;
}

References _, benchmark_send, BLOCKSIZE, do_send(), GNUNET_i2s(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), mq, op_timeout, pid, ret, start_time, and verbosity.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_disconnect()

static void notify_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  internal_cls  )

static

Function called to notify transport users that another peer disconnected from us.

Parameters

cls	closure
peer	the peer that disconnected
internal_cls	what we returned from notify_connect()

Definition at line 555 of file gnunet-transport.c.

{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
    return;
  if (NULL == internal_cls)
    return; /* not about target peer */
  if (! benchmark_send)
    return; /* not transmitting */
  fprintf (stdout,
           _ ("Disconnected from peer `%s' while benchmarking\n"),
           GNUNET_i2s (&pid));
}

References _, benchmark_send, GNUNET_i2s(), and pid.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

monitor_notify_connect()

static void * monitor_notify_connect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Function called to notify transport users that another peer connected to us.

Parameters

cls	closure
peer	the peer that connected
mq	for sending messages to peer

Returns

NULL

Definition at line 581 of file gnunet-transport.c.

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
 
  monitor_connect_counter++;
  fprintf (stdout,
           _ ("%24s: %-17s %4s   (%u connections in total)\n"),
           now_str,
           _ ("Connected to"),
           GNUNET_i2s (peer),
           monitor_connect_counter);
  return NULL;
}

References _, GNUNET_i2s(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), and monitor_connect_counter.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

monitor_notify_disconnect()

static void monitor_notify_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  internal_cls  )

static

Function called to notify transport users that another peer disconnected from us.

Parameters

cls	closure
peer	the peer that disconnected
internal_cls	what we returned from monitor_notify_connect()

Definition at line 608 of file gnunet-transport.c.

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
 
  GNUNET_assert (monitor_connect_counter > 0);
  monitor_connect_counter--;
 
  fprintf (stdout,
           _ ("%24s: %-17s %4s   (%u connections in total)\n"),
           now_str,
           _ ("Disconnected from"),
           GNUNET_i2s (peer),
           monitor_connect_counter);
}

References _, GNUNET_assert, GNUNET_i2s(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), and monitor_connect_counter.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

check_dummy()

static int check_dummy ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Function called by the transport for each received message.

Parameters

cls	closure
message	the message

Returns

GNUNET_OK

Definition at line 635 of file gnunet-transport.c.

{
  return GNUNET_OK; /* all messages are fine */
}

References GNUNET_OK.

handle_dummy()

static void handle_dummy ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Function called by the transport for each received message.

Parameters

cls	closure
message	the message

Definition at line 648 of file gnunet-transport.c.

{
  if (! benchmark_receive)
    return;
  if (verbosity > 0)
    fprintf (stdout,
             _ ("Received %u bytes\n"),
             (unsigned int) ntohs (message->size));
  if (0 == traffic_received)
    start_time = GNUNET_TIME_absolute_get ();
  traffic_received += ntohs (message->size);
}

References _, benchmark_receive, GNUNET_TIME_absolute_get(), GNUNET_MessageHeader::size, start_time, traffic_received, and verbosity.

Here is the call graph for this function:

resolve_peer_address()

static void resolve_peer_address ( const struct GNUNET_HELLO_Address *  address, int  numeric, enum GNUNET_TRANSPORT_PeerState  state, struct GNUNET_TIME_Absolute  state_timeout  )

static

Convert address to a printable format.

Convert address to a printable format and print it together with the given state data.

Parameters

address	the address
numeric	GNUNET_YES to convert to numeric format, GNUNET_NO to try to use reverse DNS
state	state the peer is in
state_timeout	when will the peer's state expire

Definition at line 816 of file gnunet-transport.c.

{
  struct PeerResolutionContext *rc;
 
  rc = GNUNET_new (struct PeerResolutionContext);
  GNUNET_CONTAINER_DLL_insert (rc_head, rc_tail, rc);
  address_resolutions++;
  rc->transport = GNUNET_strdup (address->transport_name);
  rc->addrcp = GNUNET_HELLO_address_copy (address);
  rc->printed = GNUNET_NO;
  rc->state = state;
  rc->state_timeout = state_timeout;
  /* Resolve address to string */
  rc->asc = GNUNET_TRANSPORT_address_to_string (cfg,
                                                address,
                                                numeric,
                                                RESOLUTION_TIMEOUT,
                                                &process_peer_string,
                                                rc);
}

References PeerResolutionContext::addrcp, address, address_resolutions, PeerResolutionContext::asc, cfg, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_NO, GNUNET_strdup, numeric, PeerResolutionContext::printed, process_peer_string(), rc_head, rc_tail, RESOLUTION_TIMEOUT, state, PeerResolutionContext::state, PeerResolutionContext::state_timeout, and PeerResolutionContext::transport.

Referenced by process_peer_iteration_cb(), process_peer_monitoring_cb(), and process_peer_string().

Here is the call graph for this function:

Here is the caller graph for this function:

print_info()

static void print_info ( const struct GNUNET_PeerIdentity *  id, const char *  transport, const char *  addr, enum GNUNET_TRANSPORT_PeerState  state, struct GNUNET_TIME_Absolute  state_timeout  )

static

Definition at line 679 of file gnunet-transport.c.

{
  if (((GNUNET_YES == iterate_connections) && (GNUNET_YES == iterate_all)) ||
      (GNUNET_YES == monitor_connections))
  {
    fprintf (stdout,
             _ ("Peer `%s': %s %s in state `%s' until %s\n"),
             GNUNET_i2s (id),
             (NULL == transport) ? "<none>" : transport,
             (NULL == transport) ? "<none>" : addr,
             GNUNET_TRANSPORT_ps2s (state),
             GNUNET_STRINGS_absolute_time_to_string (state_timeout));
  }
  else if ((GNUNET_YES == iterate_connections) &&
           (GNUNET_TRANSPORT_is_connected (state)))
  {
    /* Only connected peers, skip state */
    fprintf (stdout,
             _ ("Peer `%s': %s %s\n"),
             GNUNET_i2s (id),
             transport,
             addr);
  }
}

References _, GNUNET_i2s(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_YES, iterate_all, iterate_connections, monitor_connections, state, and transport.

Referenced by process_peer_iteration_cb(), process_peer_monitoring_cb(), and process_peer_string().

Here is the call graph for this function:

Here is the caller graph for this function:

process_peer_string()

static void process_peer_string ( void *  cls, const char *  address, int  res  )

static

Function called with a textual representation of an address.

This function will be called several times with different possible textual representations, and a last time with address being NULL to signal the end of the iteration. Note that address NULL always is the last call, regardless of the value in res.

Parameters

cls	closure
address	NULL on end of iteration, otherwise 0-terminated printable UTF-8 string, in particular an empty string if res is GNUNET_NO
res	result of the address to string conversion: if GNUNET_OK: conversion successful if GNUNET_NO: address was invalid (or not supported) if GNUNET_SYSERR: communication error (IPC error)

Definition at line 726 of file gnunet-transport.c.

{
  struct PeerResolutionContext *rc = cls;
 
  if (NULL != address)
  {
    if (GNUNET_SYSERR == res)
    {
      fprintf (
        stderr,
        "Failed to convert address for peer `%s' plugin `%s' length %u to string \n",
        GNUNET_i2s (&rc->addrcp->peer),
        rc->addrcp->transport_name,
        (unsigned int) rc->addrcp->address_length);
      print_info (&rc->addrcp->peer,
                  rc->transport,
                  NULL,
                  rc->state,
                  rc->state_timeout);
      rc->printed = GNUNET_YES;
      return;
    }
    if (GNUNET_OK == res)
    {
      print_info (&rc->addrcp->peer,
                  rc->transport,
                  address,
                  rc->state,
                  rc->state_timeout);
      rc->printed = GNUNET_YES;
      return;     /* Wait for done call */
    }
    /* GNUNET_NO == res: ignore, was simply not supported */
    return;
  }
  /* NULL == address, last call, we are done */
 
  rc->asc = NULL;
  GNUNET_assert (address_resolutions > 0);
  address_resolutions--;
  if (GNUNET_NO == rc->printed)
  {
    if (numeric == GNUNET_NO)
    {
      /* Failed to resolve address, try numeric lookup
         (note: this should not be needed, as transport
         should fallback to numeric conversion if DNS takes
         too long) */
      resolve_peer_address (rc->addrcp,
                            GNUNET_YES,
                            rc->state,
                            rc->state_timeout);
    }
    else
    {
      print_info (&rc->addrcp->peer,
                  rc->transport,
                  NULL,
                  rc->state,
                  rc->state_timeout);
    }
  }
  GNUNET_free (rc->transport);
  GNUNET_free (rc->addrcp);
  GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
  GNUNET_free (rc);
  if ((0 == address_resolutions) && (iterate_connections))
  {
    if (NULL != op_timeout)
    {
      GNUNET_SCHEDULER_cancel (op_timeout);
      op_timeout = NULL;
    }
    ret = 0;
    GNUNET_SCHEDULER_shutdown ();
  }
}

References PeerResolutionContext::addrcp, address, address_resolutions, PeerResolutionContext::asc, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_YES, iterate_connections, numeric, op_timeout, print_info(), PeerResolutionContext::printed, rc_head, rc_tail, res, resolve_peer_address(), ret, PeerResolutionContext::state, PeerResolutionContext::state_timeout, and PeerResolutionContext::transport.

Referenced by resolve_peer_address().

Here is the call graph for this function:

Here is the caller graph for this function:

process_peer_iteration_cb()

static void process_peer_iteration_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Address *  address, enum GNUNET_TRANSPORT_PeerState  state, struct GNUNET_TIME_Absolute  state_timeout  )

static

Function called with information about a peers during a one shot iteration.

Parameters

cls	closure
peer	identity of the peer, NULL for final callback when operation done
address	binary address used to communicate with this peer, NULL on disconnect or when done
state	current state this peer is in
state_timeout	time out for the current state

Definition at line 852 of file gnunet-transport.c.

{
  if (NULL == peer)
  {
    /* done */
    pic = NULL;
    return;
  }
 
  if ((GNUNET_NO == iterate_all) &&
      (GNUNET_NO == GNUNET_TRANSPORT_is_connected (state)))
    return; /* Display only connected peers */
 
  if (NULL != op_timeout)
    GNUNET_SCHEDULER_cancel (op_timeout);
  op_timeout =
    GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received address for peer `%s': %s\n",
              GNUNET_i2s (peer),
              address ? address->transport_name : "");
 
  if (NULL != address)
    resolve_peer_address (address, numeric, state, state_timeout);
  else
    print_info (peer, NULL, NULL, state, state_timeout);
}

References address, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), iterate_all, numeric, OP_TIMEOUT, op_timeout, operation_timeout(), pic, print_info(), resolve_peer_address(), state, and PeerResolutionContext::state_timeout.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

print_plugin_event_info()

static void print_plugin_event_info ( struct PluginMonitorAddress *  addr, const struct GNUNET_TRANSPORT_SessionInfo *  info  )

static

Print information about a plugin monitoring event.

Parameters

addr	out internal context
info	the monitoring information

Definition at line 916 of file gnunet-transport.c.

{
  const char *state;
 
  switch (info->state)
  {
  case GNUNET_TRANSPORT_SS_INIT:
    state = "INIT";
    break;
 
  case GNUNET_TRANSPORT_SS_HANDSHAKE:
    state = "HANDSHAKE";
    break;
 
  case GNUNET_TRANSPORT_SS_UP:
    state = "UP";
    break;
 
  case GNUNET_TRANSPORT_SS_UPDATE:
    state = "UPDATE";
    break;
 
  case GNUNET_TRANSPORT_SS_DONE:
    state = "DONE";
    break;
 
  default:
    state = "UNKNOWN";
    break;
  }
  fprintf (stdout,
           "%s: state %s timeout in %s @ %s%s\n",
           GNUNET_i2s (&info->address->peer),
           state,
           GNUNET_STRINGS_relative_time_to_string (
             GNUNET_TIME_absolute_get_remaining (info->session_timeout),
             GNUNET_YES),
           addr->str,
           (info->is_inbound == GNUNET_YES) ? " (INBOUND)" : "");
  fprintf (stdout,
           "%s: queue has %3u messages and %6u bytes\n",
           GNUNET_i2s (&info->address->peer),
           info->num_msg_pending,
           info->num_bytes_pending);
  if (0 !=
      GNUNET_TIME_absolute_get_remaining (info->receive_delay).rel_value_us)
    fprintf (stdout,
             "%s: receiving blocked until %s\n",
             GNUNET_i2s (&info->address->peer),
             GNUNET_STRINGS_absolute_time_to_string (info->receive_delay));
}

References GNUNET_i2s(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, info, GNUNET_TIME_Relative::rel_value_us, state, and PluginMonitorAddress::str.

Referenced by address_cb(), and plugin_monitoring_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

address_cb()

static void address_cb ( void *  cls, const char *  address, int  res  )

static

Function called with a textual representation of an address.

This function will be called several times with different possible textual representations, and a last time with address being NULL to signal the end of the iteration. Note that address NULL always is the last call, regardless of the value in res.

Parameters

cls	closure
address	NULL on end of iteration, otherwise 0-terminated printable UTF-8 string, in particular an empty string if res is GNUNET_NO
res	result of the address to string conversion: if GNUNET_OK: conversion successful if GNUNET_NO: address was invalid (or not supported) if GNUNET_SYSERR: communication error (IPC error)

Definition at line 987 of file gnunet-transport.c.

{
  struct PluginMonitorAddress *addr = cls;
 
  if (NULL == address)
  {
    addr->asc = NULL;
    return;
  }
  if (NULL != addr->str)
    return;
  addr->str = GNUNET_strdup (address);
  print_plugin_event_info (addr, &addr->si);
}

References address, PluginMonitorAddress::asc, GNUNET_strdup, print_plugin_event_info(), PluginMonitorAddress::si, and PluginMonitorAddress::str.

Referenced by plugin_monitoring_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_monitoring_cb()

static void plugin_monitoring_cb ( void *  cls, struct GNUNET_TRANSPORT_PluginSession *  session, void **  session_ctx, const struct GNUNET_TRANSPORT_SessionInfo *  info  )

static

Function called by the plugin with information about the current sessions managed by the plugin (for monitoring).

Parameters

cls	closure (NULL)
session	session handle this information is about, NULL to indicate that we are "in sync" (initial iteration complete)
session_ctx	storage location where the application can store data; will point to NULL on #GNUNET_TRANSPORT_SS_INIT, and must be reset to NULL on #GNUNET_TRANSPORT_SS_DONE
info	information about the state of the session, NULL if session is also NULL and we are merely signalling that the initial iteration is over; NULL with session being non-NULL if the monitor was being cancelled while sessions were active

Definition at line 1021 of file gnunet-transport.c.

{
  struct PluginMonitorAddress *addr;
 
  if ((NULL == info) && (NULL == session))
    return; /* in sync with transport service */
  addr = *session_ctx;
  if (NULL == info)
  {
    if (NULL != addr)
    {
      if (NULL != addr->asc)
      {
        GNUNET_TRANSPORT_address_to_string_cancel (addr->asc);
        addr->asc = NULL;
      }
      GNUNET_free (addr->str);
      GNUNET_free (addr);
      *session_ctx = NULL;
    }
    return;   /* shutdown */
  }
  if (0 !=
      memcmp (&info->address->peer, &pid, sizeof(struct GNUNET_PeerIdentity)))
    return; /* filtered */
  if (NULL == addr)
  {
    addr = GNUNET_new (struct PluginMonitorAddress);
    addr->asc =
      GNUNET_TRANSPORT_address_to_string (cfg,
                                          info->address,
                                          numeric,
                                          GNUNET_TIME_UNIT_FOREVER_REL,
                                          &address_cb,
                                          addr);
    *session_ctx = addr;
  }
  if (NULL == addr->str)
    addr->si = *info;
  else
    print_plugin_event_info (addr, info);
  if (GNUNET_TRANSPORT_SS_DONE == info->state)
  {
    if (NULL != addr->asc)
    {
      GNUNET_TRANSPORT_address_to_string_cancel (addr->asc);
      addr->asc = NULL;
    }
    GNUNET_free (addr->str);
    GNUNET_free (addr);
    *session_ctx = NULL;
  }
}

References address_cb(), PluginMonitorAddress::asc, cfg, GNUNET_free, GNUNET_new, GNUNET_TIME_UNIT_FOREVER_REL, info, numeric, pid, print_plugin_event_info(), PluginMonitorAddress::si, and PluginMonitorAddress::str.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

process_peer_monitoring_cb()

static void process_peer_monitoring_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Address *  address, enum GNUNET_TRANSPORT_PeerState  state, struct GNUNET_TIME_Absolute  state_timeout  )

static

Function called with information about a peers.

Parameters

cls	closure, NULL
peer	identity of the peer, NULL for final callback when operation done
address	binary address used to communicate with this peer, NULL on disconnect or when done
state	current state this peer is in
state_timeout	time out for the current state

Definition at line 1090 of file gnunet-transport.c.

{
  struct MonitoredPeer *m;
 
  if (NULL == peer)
  {
    fprintf (stdout,
             "%s",
             _ (
               "Monitor disconnected from transport service. Reconnecting.\n"));
    return;
  }
 
  if (NULL != op_timeout)
    GNUNET_SCHEDULER_cancel (op_timeout);
  op_timeout =
    GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
 
  if (NULL == (m = GNUNET_CONTAINER_multipeermap_get (monitored_peers, peer)))
  {
    m = GNUNET_new (struct MonitoredPeer);
    GNUNET_CONTAINER_multipeermap_put (
      monitored_peers,
      peer,
      m,
      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
  }
  else
  {
    if ((m->state == state) &&
        (m->state_timeout.abs_value_us == state_timeout.abs_value_us) &&
        (NULL == address) && (NULL == m->address))
    {
      return;     /* No real change */
    }
    if ((m->state == state) && (NULL != address) && (NULL != m->address) &&
        (0 == GNUNET_HELLO_address_cmp (m->address, address)))
      return;   /* No real change */
  }
 
  if (NULL != m->address)
  {
    GNUNET_free (m->address);
    m->address = NULL;
  }
  if (NULL != address)
    m->address = GNUNET_HELLO_address_copy (address);
  m->state = state;
  m->state_timeout = state_timeout;
 
  if (NULL != address)
    resolve_peer_address (m->address, numeric, m->state, m->state_timeout);
  else
    print_info (peer, NULL, NULL, m->state, m->state_timeout);
}

References _, GNUNET_TIME_Absolute::abs_value_us, address, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_free, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), m, monitored_peers, numeric, OP_TIMEOUT, op_timeout, operation_timeout(), print_info(), resolve_peer_address(), state, and MonitoredPeer::state_timeout.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

blacklist_cb()

static int blacklist_cb ( void *  cls, const struct GNUNET_PeerIdentity *  cpid  )

static

Function called with the transport service checking if we want to blacklist a peer.

Return GNUNET_SYSERR for the peer that we should disconnect from.

Parameters

cls	NULL
cpid	peer to check blacklisting for

Returns

GNUNET_OK if the connection is allowed, GNUNET_SYSERR if not

Definition at line 1161 of file gnunet-transport.c.

{
  if (0 == memcmp (cpid, &pid, sizeof(struct GNUNET_PeerIdentity)))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SYSERR, and pid.

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

static

Main function that will be run by the scheduler.

Parameters

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

Definition at line 1178 of file gnunet-transport.c.

{
  static struct GNUNET_PeerIdentity zero_pid;
  int counter = 0;
 
  ret = 1;
 
  cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
 
  counter = benchmark_send + benchmark_receive + iterate_connections
            + monitor_connections + monitor_connects + do_disconnect
            + monitor_plugins;
 
  if (1 < counter)
  {
    fprintf (
      stderr,
      _ (
        "Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s %s\n"),
      "disconnect",
      "benchmark send",
      "benchmark receive",
      "information",
      "monitor",
      "events",
      "plugins");
    return;
  }
  if (0 == counter)
  {
    fprintf (
      stderr,
      _ (
        "No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s, %s\n"),
      "disconnect",
      "benchmark send",
      "benchmark receive",
      "information",
      "monitor",
      "events",
      "plugins");
    return;
  }
 
  if (do_disconnect) /* -D: Disconnect from peer */
  {
    if (0 == memcmp (&zero_pid, &pid, sizeof(pid)))
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense without option `%s'.\n"),
               "-D",
               "-p");
      ret = 1;
      return;
    }
    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_cb, NULL);
    if (NULL == blacklist)
    {
      fprintf (stderr,
               "%s",
               _ (
                 "Failed to connect to transport service for disconnection\n"));
      ret = 1;
      return;
    }
    fprintf (stdout,
             "%s",
             _ ("Blacklisting request in place, stop with CTRL-C\n"));
  }
  else if (benchmark_send) /* -s: Benchmark sending */
  {
    if (0 == memcmp (&zero_pid, &pid, sizeof(pid)))
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense without option `%s'.\n"),
               "-s",
               "-p");
      ret = 1;
      return;
    }
    handle = GNUNET_TRANSPORT_core_connect (cfg,
                                            NULL,
                                            NULL,
                                            NULL,
                                            &notify_connect,
                                            &notify_disconnect,
                                            NULL);
    if (NULL == handle)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
      ret = 1;
      return;
    }
    start_time = GNUNET_TIME_absolute_get ();
    op_timeout =
      GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
  }
  else if (benchmark_receive) /* -b: Benchmark receiving */
  {
    struct GNUNET_MQ_MessageHandler handlers[] =
    { GNUNET_MQ_hd_var_size (dummy,
                             GNUNET_MESSAGE_TYPE_DUMMY,
                             struct GNUNET_MessageHeader,
                             NULL),
      GNUNET_MQ_handler_end () };
 
    handle = GNUNET_TRANSPORT_core_connect (cfg,
                                            NULL,
                                            handlers,
                                            NULL,
                                            NULL,
                                            NULL,
                                            NULL);
    if (NULL == handle)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
      ret = 1;
      return;
    }
    if (verbosity > 0)
      fprintf (stdout, "%s", _ ("Starting to receive benchmark data\n"));
    start_time = GNUNET_TIME_absolute_get ();
  }
  else if (iterate_connections) /* -i: List information about peers once */
  {
    pic = GNUNET_TRANSPORT_monitor_peers (cfg,
                                          &pid,
                                          GNUNET_YES,
                                          &process_peer_iteration_cb,
                                          (void *) cfg);
    op_timeout =
      GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
  }
  else if (monitor_connections) /* -m: List information about peers continuously
                                 */
  {
    monitored_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
    pic = GNUNET_TRANSPORT_monitor_peers (cfg,
                                          &pid,
                                          GNUNET_NO,
                                          &process_peer_monitoring_cb,
                                          NULL);
  }
  else if (monitor_plugins) /* -P: List information about plugins continuously
                             */
  {
    monitored_plugins = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
    pm = GNUNET_TRANSPORT_monitor_plugins (cfg, &plugin_monitoring_cb, NULL);
  }
  else if (monitor_connects) /* -e : Monitor (dis)connect events continuously */
  {
    monitor_connect_counter = 0;
    handle = GNUNET_TRANSPORT_core_connect (cfg,
                                            NULL,
                                            NULL,
                                            NULL,
                                            &monitor_notify_connect,
                                            &monitor_notify_disconnect,
                                            NULL);
    if (NULL == handle)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
      ret = 1;
      return;
    }
    ret = 0;
  }
  else
  {
    GNUNET_break (0);
    return;
  }
 
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

References _, benchmark_receive, benchmark_send, blacklist, blacklist_cb(), cfg, do_disconnect, dummy, GNUNET_break, GNUNET_CONTAINER_multipeermap_create(), GNUNET_MESSAGE_TYPE_DUMMY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_TIME_absolute_get(), GNUNET_TRANSPORT_core_connect(), GNUNET_YES, handle, handlers, iterate_connections, monitor_connect_counter, monitor_connections, monitor_connects, monitor_notify_connect(), monitor_notify_disconnect(), monitor_plugins, monitored_peers, monitored_plugins, notify_connect(), notify_disconnect(), OP_TIMEOUT, op_timeout, operation_timeout(), pic, pid, plugin_monitoring_cb(), pm, process_peer_iteration_cb(), process_peer_monitoring_cb(), ret, shutdown_task, start_time, and verbosity.

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
	)

Definition at line 1359 of file gnunet-transport.c.

{
  int res;
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag (
      'a',
      "all",
      gettext_noop (
        "print information for all peers (instead of only connected peers)"),
      &iterate_all),
    GNUNET_GETOPT_option_flag (
      'b',
      "benchmark",
      gettext_noop (
        "measure how fast we are receiving data from all peers (until CTRL-C)"),
      &benchmark_receive),
    GNUNET_GETOPT_option_flag ('D',
                               "disconnect",
                               gettext_noop ("disconnect from a peer"),
                               &do_disconnect),
    GNUNET_GETOPT_option_flag (
      'i',
      "information",
      gettext_noop (
        "provide information about all current connections (once)"),
      &iterate_connections),
    GNUNET_GETOPT_option_flag (
      'm',
      "monitor",
      gettext_noop (
        "provide information about all current connections (continuously)"),
      &monitor_connections),
    GNUNET_GETOPT_option_flag (
      'e',
      "events",
      gettext_noop (
        "provide information about all connects and disconnect events (continuously)"),
      &monitor_connects),
    GNUNET_GETOPT_option_flag ('n',
                               "numeric",
                               gettext_noop ("do not resolve hostnames"),
                               &numeric),
    GNUNET_GETOPT_option_base32_auto ('p',
                                      "peer",
                                      "PEER",
                                      gettext_noop ("peer identity"),
                                      &pid),
    GNUNET_GETOPT_option_flag ('P',
                               "plugins",
                               gettext_noop ("monitor plugin sessions"),
                               &monitor_plugins),
    GNUNET_GETOPT_option_flag (
      's',
      "send",
      gettext_noop (
        "send data for benchmarking to the other peer (until CTRL-C)"),
      &benchmark_send),
    GNUNET_GETOPT_option_verbose (&verbosity),
    GNUNET_GETOPT_OPTION_END };
 
  res =
    GNUNET_PROGRAM_run (argc,
                        argv,
                        "gnunet-transport",
                        gettext_noop ("Direct access to transport service."),
                        options,
                        &run,
                        NULL);
  if (GNUNET_OK == res)
    return ret;
  return 1;
}

References benchmark_receive, benchmark_send, do_disconnect, gettext_noop, GNUNET_GETOPT_option_base32_auto, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_verbose(), GNUNET_OK, GNUNET_PROGRAM_run(), iterate_all, iterate_connections, monitor_connections, monitor_connects, monitor_plugins, numeric, options, pid, res, ret, run(), and verbosity.

Here is the call graph for this function:

Variable Documentation

handle

struct GNUNET_TRANSPORT_CoreHandle* handle

static

Handle to transport service.

Definition at line 172 of file gnunet-transport.c.

Referenced by run(), and shutdown_task().

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration handle.

Definition at line 177 of file gnunet-transport.c.

Referenced by plugin_monitoring_cb(), resolve_peer_address(), and run().

blacklist

struct GNUNET_TRANSPORT_Blacklist* blacklist

Blacklisting handle.

Definition at line 182 of file gnunet-transport.c.

Referenced by run(), and shutdown_task().

benchmark_send

int benchmark_send

static

Option -s.

Definition at line 187 of file gnunet-transport.c.

Referenced by main(), notify_connect(), notify_disconnect(), operation_timeout(), run(), and shutdown_task().

benchmark_receive

static int benchmark_receive

static

Option -b.

Option -l.

Definition at line 192 of file gnunet-transport.c.

Referenced by handle_dummy(), main(), operation_timeout(), run(), and shutdown_task().

iterate_connections

int iterate_connections

static

Option -i.

Definition at line 202 of file gnunet-transport.c.

Referenced by main(), operation_timeout(), print_info(), process_peer_string(), and run().

iterate_all

int iterate_all

static

Option -a.

Definition at line 207 of file gnunet-transport.c.

Referenced by main(), print_info(), and process_peer_iteration_cb().

monitor_connects

int monitor_connects

static

Option -c.

Definition at line 212 of file gnunet-transport.c.

Referenced by main(), and run().

monitor_connections

int monitor_connections

static

Option -m.

Definition at line 217 of file gnunet-transport.c.

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

monitor_plugins

int monitor_plugins

static

Option -P.

Definition at line 222 of file gnunet-transport.c.

Referenced by main(), and run().

do_disconnect

int do_disconnect

static

Option -D.

Definition at line 227 of file gnunet-transport.c.

Referenced by get_queue_head(), GNUNET_STATISTICS_destroy(), handle_disconnect_confirm(), handle_statistics_end(), handle_statistics_watch_value(), main(), mq_error_handler(), mq_error_handler(), mq_error_handler(), run(), run(), run(), and run().

numeric

int numeric

static

Option -n.

Definition at line 232 of file gnunet-transport.c.

Referenced by main(), plugin_monitoring_cb(), process_peer_iteration_cb(), process_peer_monitoring_cb(), process_peer_string(), and resolve_peer_address().

ret

int ret

static

Global return value (0 success).

Definition at line 237 of file gnunet-transport.c.

Referenced by main(), notify_connect(), operation_timeout(), process_peer_string(), run(), and shutdown_task().

monitor_connect_counter

int monitor_connect_counter

static

Current number of connections in monitor mode.

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

Referenced by monitor_notify_connect(), monitor_notify_disconnect(), and run().

traffic_received

unsigned long long traffic_received

static

Number of bytes of traffic we received so far.

Definition at line 247 of file gnunet-transport.c.

Referenced by handle_dummy(), and shutdown_task().

traffic_sent

unsigned long long traffic_sent

static

Number of bytes of traffic we sent so far.

Definition at line 252 of file gnunet-transport.c.

Referenced by do_send(), and shutdown_task().

start_time

struct GNUNET_TIME_Absolute start_time

static

Starting time of transmitting/receiving data.

Definition at line 257 of file gnunet-transport.c.

Referenced by handle_dummy(), notify_connect(), run(), and shutdown_task().

monitored_peers

struct GNUNET_CONTAINER_MultiPeerMap* monitored_peers

static

Map storing information about monitored peers.

Definition at line 262 of file gnunet-transport.c.

Referenced by destroy_it(), process_peer_monitoring_cb(), run(), and shutdown_task().

monitored_plugins

struct GNUNET_CONTAINER_MultiPeerMap* monitored_plugins

static

Map storing information about monitored plugins's sessions.

Definition at line 267 of file gnunet-transport.c.

Referenced by run(), and shutdown_task().

pic

struct GNUNET_TRANSPORT_PeerMonitoringContext* pic

static

Handle if we are monitoring peers at the transport level.

Definition at line 272 of file gnunet-transport.c.

Referenced by process_peer_iteration_cb(), run(), and shutdown_task().

pm

struct GNUNET_TRANSPORT_PluginMonitor* pm

static

Handle if we are monitoring plugin session activity.

Definition at line 277 of file gnunet-transport.c.

Referenced by check_next_attempt_tree(), check_vl_transmission(), client_disconnect_cb(), client_disconnect_cb(), client_response_handler(), client_send_response(), completed_pending_message(), execute_delayed_mutations(), extract_box_cb(), forward_dv_box(), fragment_message(), free_fragment_tree(), free_pending_acknowledgement(), free_pending_message(), free_queue_entry(), free_virtual_link(), handle_client_mutation(), handle_client_send(), handle_p2p_reply(), harmonize_flight_round(), prepare_pending_acknowledgement(), proto_read_kx(), proto_read_kx(), queue_send_msg(), reliability_box_message(), reorder_root_pm(), run(), send_msg_from_cache(), set_pending_message_uuid(), shutdown_task(), transmit_on_queue(), try_connection_reversal(), and update_pm_next_attempt().

pid

struct GNUNET_PeerIdentity pid

static

Identity of the peer we transmit to / connect to.

('-p' command-line option).

Definition at line 283 of file gnunet-transport.c.

Referenced by address_iterator(), blacklist_cb(), block_plugin_dht_check_block(), block_plugin_dht_check_reply(), block_plugin_dht_get_key(), check_connection_quality(), check_hello(), check_known_address(), check_known_challenge(), check_validation_request_pending(), consider_for_advertising(), consider_peer_for_forwarding(), core_send_connect_info(), cores_send_connect_info(), cores_send_disconnect_info(), create_target(), cummulative_ack(), detach_terminal(), dv_neighbour_selection(), dv_neighbour_transmission(), env_resign_cb(), find_list_tunnels(), find_list_tunnels_alternate(), find_queue(), find_target(), flush_respect(), fork_and_exec(), fork_and_exec(), free_ack_cummulator_cb(), free_backtalker_cb(), free_dv_routes_cb(), free_neighbour_cb(), free_peer(), free_validation_state_cb(), GCPP_try_path_from_dht(), GDS_try_connect(), GDS_u_connect(), GDS_u_try_connect(), gns_resolve_name(), GNUNET_CORE_get_mq(), GNUNET_HELLO_build_url(), GNUNET_HELLO_builder_from_parser(), GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_builder_to_dht_hello_msg(), GNUNET_HELLO_builder_to_env(), GNUNET_HELLO_builder_to_url(), GNUNET_HELLO_builder_to_url2(), GNUNET_HELLO_dht_msg_to_block(), GNUNET_HELLO_parser_from_url(), GNUNET_i2s(), GNUNET_i2s2(), GNUNET_i2s_full(), GNUNET_OS_process_wait(), GNUNET_PEER_intern(), GNUNET_PEER_resolve(), GNUNET_PEER_search(), GNUNET_PEERSTORE_hello_add(), GNUNET_TRANSPORT_communicator_notify(), gnunet_try_connect(), GSC_SESSIONS_end(), GSC_SESSIONS_solicit(), handle_p2p_put(), handle_search_response(), handshake_ack_monotime_cb(), handshake_ack_monotime_cb(), handshake_monotime_cb(), handshake_monotime_cb(), hello_for_client_cb(), hello_for_incoming_cb(), hello_iter(), hosts_directory_scan_callback(), http_recv_data_cb(), ip_try_connect(), lookup_neighbour(), lookup_virtual_link(), main(), maint_child_death(), netjail_start_run(), notify_client_connect_info(), notify_client_queues(), notify_connect(), notify_disconnect(), operation_timeout(), parser_new(), pils_sign_hello_cb(), plugin_monitoring_cb(), read_cb(), recv_from_streams(), rekey_monotime_cb(), rekey_monotime_cb(), run(), run(), save_list_tunnels(), show_peer(), start_address_validation(), start_burst(), stop_peer_request(), suggest_to_connect(), update_ax_by_kx(), url_resign_cb(), verify_list_tunnels_flag_token(), and write_benchmark_data().

op_timeout

struct GNUNET_SCHEDULER_Task* op_timeout

static

Task for operation timeout.

Definition at line 288 of file gnunet-transport.c.

Referenced by notify_connect(), operation_timeout(), process_peer_iteration_cb(), process_peer_monitoring_cb(), process_peer_string(), run(), and shutdown_task().

verbosity

unsigned int verbosity

static

Selected level of verbosity.

Definition at line 293 of file gnunet-transport.c.

Referenced by do_send(), handle_dummy(), main(), notify_connect(), and run().

resolver

struct GNUNET_OS_Process* resolver

Resolver process handle.

Definition at line 298 of file gnunet-transport.c.

address_resolutions

unsigned int address_resolutions

static

Number of address resolutions pending.

Definition at line 303 of file gnunet-transport.c.

Referenced by process_peer_string(), and resolve_peer_address().

vc_head

struct ValidationResolutionContext* vc_head

static

DLL: head of validation resolution entries.

Definition at line 308 of file gnunet-transport.c.

Referenced by shutdown_task().

vc_tail

struct ValidationResolutionContext* vc_tail

static

DLL: tail of validation resolution entries.

Definition at line 313 of file gnunet-transport.c.

Referenced by shutdown_task().

rc_head

struct PeerResolutionContext* rc_head

static

DLL: head of resolution entries.

Definition at line 318 of file gnunet-transport.c.

Referenced by operation_timeout(), process_peer_string(), resolve_peer_address(), and shutdown_task().

rc_tail

struct PeerResolutionContext* rc_tail

static

DLL: head of resolution entries.

Definition at line 323 of file gnunet-transport.c.

Referenced by operation_timeout(), process_peer_string(), resolve_peer_address(), and shutdown_task().