gnunet-transport.c File Reference

Print the virtual links transport currently has, with the flow control state CORE rides on. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_transport_monitor_service.h"

Include dependency graph for gnunet-transport.c:

Go to the source code of this file.

Functions
static void	shutdown_task (void *cls)
	Task run when the user aborts us or the listing finished.
static const char *	route_to_string (const struct GNUNET_TRANSPORT_LinkInformation *li, char *buf, size_t buf_size)
	Render how a link is routed into buf.
static void	print_link_verbose (const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TRANSPORT_LinkInformation *li)
	Print everything we know about li, one field per line.
static void	link_cb (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TRANSPORT_LinkInformation *li)
	Function called once per virtual link, and a final time with both arguments NULL.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run by the scheduler.
int	main (int argc, char *const *argv)
	The main function to list the virtual links of the transport service.

Variables
static int	ret
	Return code.
static int	include_unconfirmed
	Option -a: also show links that are not established yet.
static int	verbose
	Option -V: show the full flow control state of every link.
static char *	peer_id
	Option -p: restrict the listing to this peer.
static struct GNUNET_TRANSPORT_LinkListContext *	llc
	Handle to the running listing, NULL once it completed.
static unsigned int	num_links
	Number of links reported so far.

Detailed Description

Print the virtual links transport currently has, with the flow control state CORE rides on.

Author

Martin Schanzenbach

Definition in file gnunet-transport.c.

Function Documentation

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run when the user aborts us or the listing finished.

Parameters

cls

NULL

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

{
  (void) cls;
  if (NULL != llc)
  {
    GNUNET_TRANSPORT_links_list_cancel (llc);
    llc = NULL;
  }
}

References GNUNET_TRANSPORT_links_list_cancel(), and llc.

Here is the call graph for this function:

route_to_string()

static const char * route_to_string ( const struct GNUNET_TRANSPORT_LinkInformation *  li, char *  buf, size_t  buf_size  )

static

Render how a link is routed into buf.

Parameters

	li	link to describe
[out]	buf	where to write the description
	buf_size	number of bytes available in buf

Returns

buf

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

{
  if (GNUNET_TRANSPORT_LINK_ROUTE_DIRECT == li->route)
  {
    GNUNET_snprintf (buf, buf_size, "%s", _ ("direct"));
    return buf;
  }
  /* `distance' counts neither the next hop nor the target, so the number
     of hops a user would count is two more. */
  GNUNET_snprintf (buf, buf_size, _ ("dv (%u hops)"), li->distance + 2);
  return buf;
}

References _, GNUNET_TRANSPORT_LinkInformation::distance, GNUNET_snprintf(), GNUNET_TRANSPORT_LINK_ROUTE_DIRECT, and GNUNET_TRANSPORT_LinkInformation::route.

Referenced by link_cb(), and print_link_verbose().

Here is the call graph for this function:

Here is the caller graph for this function:

print_link_verbose()

static void print_link_verbose ( const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_TRANSPORT_LinkInformation *  li  )

static

Print everything we know about li, one field per line.

Parameters

peer	peer at the other end of the link
li	the link to print

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

{
  char route[64];
  char *s1;
  char *s2;
 
  fprintf (stdout, "%s\n", GNUNET_i2s_full (peer));
  fprintf (stdout,
           _ ("  routed:                %s over %s (%u queue(s))\n"),
           route_to_string (li, route, sizeof (route)),
           ('\0' == li->communicators[0]) ? "-" : li->communicators,
           li->num_queues);
  fprintf (stdout,
           _ ("  established:           %s\n"),
           (GNUNET_YES == li->confirmed) ? _ ("yes") : _ ("no"));
  fprintf (stdout,
           _ ("  CORE receive window:   %d\n"),
           li->core_recv_window);
  fprintf (stdout,
           _ ("  stalled for CORE:      %u message(s)\n"),
           li->stalled);
  fprintf (stdout,
           _ ("  pending transmission:  %u message(s)\n"),
           li->pending);
  s1 = GNUNET_STRINGS_byte_size_fancy (li->incoming_fc_window_size_used);
  s2 = GNUNET_STRINGS_byte_size_fancy (li->incoming_fc_window_size);
  fprintf (stdout, _ ("  inbound window used:   %s of %s\n"), s1, s2);
  GNUNET_free (s1);
  GNUNET_free (s2);
  s1 = GNUNET_STRINGS_byte_size_fancy (li->outbound_fc_window_size_used);
  s2 = GNUNET_STRINGS_byte_size_fancy (li->outbound_fc_window_size);
  fprintf (stdout, _ ("  outbound window used:  %s of %s\n"), s1, s2);
  GNUNET_free (s1);
  GNUNET_free (s2);
  s1 = GNUNET_STRINGS_byte_size_fancy (li->incoming_fc_window_size_ram);
  s2 = GNUNET_STRINGS_byte_size_fancy (li->available_fc_window_size);
  fprintf (stdout, _ ("  buffer used:           %s of %s\n"), s1, s2);
  GNUNET_free (s1);
  GNUNET_free (s2);
  fprintf (stdout,
           _ ("  estimated loss:        %lld byte(s)\n"),
           (long long) li->incoming_fc_window_size_loss);
  fprintf (stdout,
           _ ("  flow control RTT:      %s (peer reports %s)\n"),
           GNUNET_STRINGS_relative_time_to_string (li->last_fc_rtt,
                                                   GNUNET_YES),
           GNUNET_STRINGS_relative_time_to_string (li->other_rtt,
                                                   GNUNET_YES));
  fprintf (stdout,
           _ ("  last flow control:     %s ago (%u retransmission(s))\n"),
           GNUNET_STRINGS_relative_time_to_string (
             GNUNET_TIME_absolute_get_duration (li->last_fc_transmission),
             GNUNET_YES),
           li->fc_retransmit_count);
  fprintf (stdout, "\n");
}

References _, GNUNET_TRANSPORT_LinkInformation::available_fc_window_size, GNUNET_TRANSPORT_LinkInformation::communicators, GNUNET_TRANSPORT_LinkInformation::confirmed, GNUNET_TRANSPORT_LinkInformation::core_recv_window, GNUNET_TRANSPORT_LinkInformation::fc_retransmit_count, GNUNET_free, GNUNET_i2s_full(), GNUNET_STRINGS_byte_size_fancy(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, GNUNET_TRANSPORT_LinkInformation::incoming_fc_window_size, GNUNET_TRANSPORT_LinkInformation::incoming_fc_window_size_loss, GNUNET_TRANSPORT_LinkInformation::incoming_fc_window_size_ram, GNUNET_TRANSPORT_LinkInformation::incoming_fc_window_size_used, GNUNET_TRANSPORT_LinkInformation::last_fc_rtt, GNUNET_TRANSPORT_LinkInformation::last_fc_transmission, GNUNET_TRANSPORT_LinkInformation::num_queues, GNUNET_TRANSPORT_LinkInformation::other_rtt, GNUNET_TRANSPORT_LinkInformation::outbound_fc_window_size, GNUNET_TRANSPORT_LinkInformation::outbound_fc_window_size_used, GNUNET_TRANSPORT_LinkInformation::pending, route_to_string(), and GNUNET_TRANSPORT_LinkInformation::stalled.

Referenced by link_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

link_cb()

static void link_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_TRANSPORT_LinkInformation *  li  )

static

Function called once per virtual link, and a final time with both arguments NULL.

Parameters

cls	NULL
peer	peer at the other end of the link, NULL when done
li	state of the link, NULL when done

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

{
  char route[64];
 
  (void) cls;
  if (NULL == peer)
  {
    /* The listing completed; the handle released itself. */
    llc = NULL;
    if (0 == num_links)
      fprintf (stdout, "%s\n", _ ("No virtual links."));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (verbose)
  {
    print_link_verbose (peer, li);
    num_links++;
    return;
  }
  if (0 == num_links)
    fprintf (stdout,
             "%-10s %-14s %-12s %9s %8s %8s %10s\n",
             _ ("PEER"),
             _ ("ROUTE"),
             _ ("VIA"),
             _ ("CORE-WIN"),
             _ ("STALLED"),
             _ ("PENDING"),
             _ ("RTT"));
  num_links++;
  fprintf (stdout,
           "%-10s %-14s %-12s %9d %8u %8u %10s\n",
           GNUNET_i2s (peer),
           route_to_string (li, route, sizeof (route)),
           ('\0' == li->communicators[0]) ? "-" : li->communicators,
           li->core_recv_window,
           li->stalled,
           li->pending,
           GNUNET_STRINGS_relative_time_to_string (li->last_fc_rtt,
                                                   GNUNET_YES));
}

References _, GNUNET_TRANSPORT_LinkInformation::communicators, GNUNET_TRANSPORT_LinkInformation::core_recv_window, GNUNET_i2s(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, GNUNET_TRANSPORT_LinkInformation::last_fc_rtt, llc, num_links, GNUNET_TRANSPORT_LinkInformation::pending, print_link_verbose(), route_to_string(), GNUNET_TRANSPORT_LinkInformation::stalled, and verbose.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Main function that will be run by the scheduler.

Parameters

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

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

{
  struct GNUNET_PeerIdentity pid;
  const struct GNUNET_PeerIdentity *pidp = NULL;
 
  (void) cls;
  (void) cfgfile;
  if (NULL != args[0])
  {
    fprintf (stderr, _ ("Invalid command line argument `%s'\n"), args[0]);
    ret = 1;
    return;
  }
  if (NULL != peer_id)
  {
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id,
                                                    strlen (peer_id),
                                                    &pid.public_key))
    {
      fprintf (stderr, _ ("Invalid peer ID `%s'\n"), peer_id);
      ret = 1;
      return;
    }
    pidp = &pid;
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  llc = GNUNET_TRANSPORT_links_list (cfg,
                                     pidp,
                                     include_unconfirmed ? GNUNET_YES
                                     : GNUNET_NO,
                                     &link_cb,
                                     NULL);
  if (NULL == llc)
  {
    fprintf (stderr, "%s", _ ("Failed to connect to transport service!\n"));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
  }
}

References _, cfg, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_TRANSPORT_links_list(), GNUNET_YES, include_unconfirmed, link_cb(), llc, peer_id, GNUNET_PeerIdentity::public_key, ret, and shutdown_task.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function to list the virtual links of the transport service.

Parameters

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

Returns

0 ok, 1 on error

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

{
  int res;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag (
      'a',
      "all",
      gettext_noop ("also show links that are not established yet"),
      &include_unconfirmed),
    GNUNET_GETOPT_option_string (
      'p',
      "peer",
      "PEERID",
      gettext_noop ("only show the link to this peer"),
      &peer_id),
    GNUNET_GETOPT_option_flag (
      'V',
      "verbose",
      gettext_noop ("show the full flow control state of every link"),
      &verbose),
    GNUNET_GETOPT_OPTION_END
  };
 
  res = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                            argc,
                            argv,
                            "gnunet-transport",
                            gettext_noop (
                              "Print information about the virtual links of "
                              "the transport service."),
                            options,
                            &run,
                            NULL);
  if (GNUNET_OK == res)
    return ret;
  return 1;
}

References gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), include_unconfirmed, options, peer_id, res, ret, run(), and verbose.

Here is the call graph for this function:

Variable Documentation

ret

int ret

static

Return code.

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

Referenced by main(), and run().

include_unconfirmed

int include_unconfirmed

static

Option -a: also show links that are not established yet.

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

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

verbose

int verbose

static

Option -V: show the full flow control state of every link.

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

Referenced by link_cb(), and main().

peer_id

char* peer_id

static

Option -p: restrict the listing to this peer.

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

Referenced by main(), and run().

llc

struct GNUNET_TRANSPORT_LinkListContext* llc

static

Handle to the running listing, NULL once it completed.

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

Referenced by GNUNET_TRANSPORT_links_list(), GNUNET_TRANSPORT_links_list_cancel(), handle_link_list_request(), handle_link_list_response(), handle_link_list_response_end(), link_cb(), link_list_done(), link_list_error_handler(), report_link(), run(), and shutdown_task().

num_links

unsigned int num_links

static

Number of links reported so far.

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

Referenced by link_cb().