gnunet-transport.c

Go to the documentation of this file.

/*
   This file is part of GNUnet.
   Copyright (C) 2011-2014, 2016, 2017 GNUnet e.V.
 
   GNUnet is free software: you can redistribute it and/or modify it
   under the terms of the GNU Affero General Public License as published
   by the Free Software Foundation, either version 3 of the License,
   or (at your option) any later version.
 
   GNUnet is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_resolver_service.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_service.h"
 
#define RESOLUTION_TIMEOUT \
  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
#define OP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 
struct ValidationResolutionContext
{
  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 */