gnunet-cadet.c File Reference

Print information about cadet tunnels and peers. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "cadet.h"

Include dependency graph for gnunet-cadet.c:

Go to the source code of this file.

Macros
#define	STREAM_BUFFER_SIZE   1024

Functions
static void	listen_stdio (void)
	Wait for input on STDIO and send it out over the ch. More...
static const char *	enc_2s (uint16_t status)
	Convert encryption status to human readable string. More...
static const char *	conn_2s (uint16_t status)
	Convert connection status to human readable string. More...
static void	shutdown_task (void *cls)
	Task to shut down this application. More...
void	mq_cb (void *cls)
static void	read_stdio (void *cls)
	Task run in stdio mode, after some data is available at stdin. More...
static void	channel_ended (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called whenever a channel is destroyed. More...
static void *	channel_incoming (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
	Method called whenever another peer has added us to a channel the other peer initiated. More...
static void	send_echo (void *cls)
	Send an echo request to the remote peer. More...
static int	check_data (void *cls, const struct GNUNET_MessageHeader *message)
	Check data message sanity. More...
static void	handle_data (void *cls, const struct GNUNET_MessageHeader *message)
	Function called whenever a message is received. More...
static void	peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
	Method called to retrieve information about all peers in CADET, called once per peer. More...
static void	path_callback (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
	Method called to retrieve information about paths to a specific peer known to the service. More...
static void	tunnels_callback (void *cls, const struct GNUNET_CADET_TunnelDetails *td)
	Method called to retrieve information about all tunnels in CADET. More...
static void	get_peers (void *cls)
	Call CADET's meta API, get all peers known to a peer. More...
static void	show_peer (void *cls)
	Call CADET's monitor API, get info of one peer. More...
static void	get_tunnels (void *cls)
	Call CADET's meta API, get all tunnels known to a peer. More...
static void	show_channel (void *cls)
	Call CADET's monitor API, get info of one channel. More...
static void	show_connection (void *cls)
	Call CADET's monitor API, get info of one connection. More...
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. More...
int	main (int argc, char *const *argv)
	The main function to obtain peer information. More...

Variables
static int	request_peers
	Option -P. More...
static char *	peer_id
	Option –peer. More...
static int	request_tunnels
	Option -T. More...
static char *	conn_id
	Option –connection. More...
static char *	channel_id
	Option –channel. More...
static char *	listen_port
	Port to listen on (-o). More...
static int	echo
	Request echo service. More...
static struct GNUNET_TIME_Absolute	echo_time
	Time of last echo request. More...
static struct GNUNET_SCHEDULER_Task *	echo_task
	Task for next echo request. More...
static char *	target_id
	Peer to connect to. More...
static char *	target_port = "default"
	Port to connect to. More...
static struct GNUNET_CADET_Handle *	mh
	Cadet handle. More...
static const struct GNUNET_CONFIGURATION_Handle *	my_cfg
	Our configuration. More...
static struct GNUNET_CADET_GetPath *	gpo
	Active get path operation. More...
static struct GNUNET_CADET_PeersLister *	plo
	Active peer listing operation. More...
static struct GNUNET_CADET_ListTunnels *	tio
	Active tunnel listing operation. More...
static struct GNUNET_CADET_Channel *	ch
	Channel handle. More...
static struct GNUNET_HashCode	porthash
	HashCode of the given port string. More...
struct GNUNET_CADET_Port *	lp
	Data structure for ongoing reception of incoming virtual circuits. More...
static struct GNUNET_SCHEDULER_Task *	rd_task
	Task for reading from stdin. More...
static struct GNUNET_SCHEDULER_Task *	job
	Task for main job. More...
static unsigned int	sent_pkt

Detailed Description

Print information about cadet tunnels and peers.

Author

Bartlomiej Polot

Christian Grothoff

Definition in file gnunet-cadet.c.

Macro Definition Documentation

STREAM_BUFFER_SIZE

#define STREAM_BUFFER_SIZE   1024

Definition at line 32 of file gnunet-cadet.c.

Referenced by read_stdio().

Function Documentation

listen_stdio()

static void listen_stdio ( void  )

static

Wait for input on STDIO and send it out over the ch.

Definition at line 330 of file gnunet-cadet.c.

References GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set_native(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_FOREVER_REL, and read_stdio().

Referenced by channel_incoming(), mq_cb(), read_stdio(), and run().

{
  struct GNUNET_NETWORK_FDSet *rs;

  /* FIXME: why use 'rs' here, seems overly complicated... */
  rs = GNUNET_NETWORK_fdset_create ();
  GNUNET_NETWORK_fdset_set_native (rs,
                                   0); /* STDIN */
  rd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                         GNUNET_TIME_UNIT_FOREVER_REL,
                                         rs,
                                         NULL,
                                         &read_stdio,
                                         NULL);
  GNUNET_NETWORK_fdset_destroy (rs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

enc_2s()

static const char* enc_2s ( uint16_t  status )

static

Convert encryption status to human readable string.

Parameters

status

Encryption status.

Returns

Human readable string.

Definition at line 157 of file gnunet-cadet.c.

Referenced by tunnels_callback().

{
  switch (status)
  {
    case 0:
      return "NULL ";
    case 1:
      return "KSENT";
    case 2:
      return "KRECV";
    case 3:
      return "READY";
    default:
      return "";
  }
}

Here is the caller graph for this function:

conn_2s()

static const char* conn_2s ( uint16_t  status )

static

Convert connection status to human readable string.

Parameters

status

Connection status.

Returns

Human readable string.

Definition at line 183 of file gnunet-cadet.c.

Referenced by tunnels_callback().

{
  switch (status)
  {
    case 0:
      return "NEW  ";
    case 1:
      return "SRCH ";
    case 2:
      return "WAIT ";
    case 3:
      return "READY";
    case 4:
      return "SHUTD";
    default:
      return "";
  }
}

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task to shut down this application.

Parameters

cls	Closure (unused).

Definition at line 210 of file gnunet-cadet.c.

References GNUNET_CADET_channel_destroy(), GNUNET_CADET_close_port(), GNUNET_CADET_disconnect(), GNUNET_CADET_get_path_cancel(), GNUNET_CADET_list_peers_cancel(), GNUNET_CADET_list_tunnels_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and GNUNET_SCHEDULER_cancel().

Referenced by run().

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Shutdown\n");
  if (NULL != lp)
  {
    GNUNET_CADET_close_port (lp);
    lp = NULL;
  }
  if (NULL != ch)
  {
    GNUNET_CADET_channel_destroy (ch);
    ch = NULL;
  }
  if (NULL != gpo)
  {
    GNUNET_CADET_get_path_cancel (gpo);
    gpo = NULL;
  }
  if (NULL != plo)
  {
    GNUNET_CADET_list_peers_cancel (plo);
    plo = NULL;
  }
  if (NULL != tio)
  {
    GNUNET_CADET_list_tunnels_cancel (tio);
    tio = NULL;
  }
  if (NULL != mh)
  {
    GNUNET_CADET_disconnect (mh);
    mh = NULL;
  }
  if (NULL != rd_task)
  {
    GNUNET_SCHEDULER_cancel (rd_task);
    rd_task = NULL;
  }
  if (NULL != echo_task)
  {
    GNUNET_SCHEDULER_cancel (echo_task);
    echo_task = NULL;
  }
  if (NULL != job)
  {
    GNUNET_SCHEDULER_cancel (job);
    job = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mq_cb()

void mq_cb

(

void *

cls

)

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

References listen_stdio().

Referenced by read_stdio().

{
  listen_stdio ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_stdio()

static void read_stdio ( void *  cls )

static

Task run in stdio mode, after some data is available at stdin.

Parameters

cls	Closure (unused).

Definition at line 274 of file gnunet-cadet.c.

References buf, data_size, echo, echo_time, env, GNUNET_CADET_get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_get(), listen_stdio(), mq_cb(), msg, sent_pkt, and STREAM_BUFFER_SIZE.

Referenced by listen_stdio().

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
  char buf[60000];
  ssize_t data_size;

  rd_task = NULL;
  data_size = read (0,
                    buf,
                    60000);
  if (data_size < 1)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "read() returned  %s\n", strerror(errno));
    GNUNET_SCHEDULER_shutdown();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Read %u bytes from stdio\n",
              (unsigned int) data_size);
  env = GNUNET_MQ_msg_extra (msg,
                             data_size,
                             GNUNET_MESSAGE_TYPE_CADET_CLI);
  GNUNET_memcpy (&msg[1],
                 buf,
                 data_size);
  GNUNET_MQ_send (GNUNET_CADET_get_mq (ch),
                  env);

  sent_pkt++;

  if (GNUNET_NO == echo)
  {
    // Use MQ's notification if too much data of stdin is pooring in too fast.
    if (STREAM_BUFFER_SIZE < sent_pkt)
    {
      GNUNET_MQ_notify_sent (env, mq_cb, cls);
      sent_pkt = 0;
    }
    else
    {
      listen_stdio ();
    }
  }
  else
  {
    echo_time = GNUNET_TIME_absolute_get ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

channel_ended()

static void channel_ended ( void *  cls, const struct GNUNET_CADET_Channel *  channel  )

static

Function called whenever a channel is destroyed.

Should clean up any associated state.

It must NOT call GNUNET_CADET_channel_destroy on the channel.

Parameters

cls	closure
channel	connection to the other end (henceforth invalid)

Definition at line 358 of file gnunet-cadet.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and GNUNET_SCHEDULER_shutdown().

Referenced by run().

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Channel ended!\n");
  GNUNET_assert (channel == ch);
  ch = NULL;
  GNUNET_SCHEDULER_shutdown ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

channel_incoming()

static void* channel_incoming ( void *  cls, struct GNUNET_CADET_Channel *  channel, const struct GNUNET_PeerIdentity *  initiator  )

static

Method called whenever another peer has added us to a channel the other peer initiated.

Only called (once) upon reception of data with a message type which was subscribed to in GNUNET_CADET_connect.

A call to GNUNET_CADET_channel_destroy causes the channel to be ignored. In this case the handler MUST return NULL.

Parameters

cls	closure
channel	new handle to the channel
initiator	peer that started the channel

Returns

initial channel context for the channel, we use channel

Definition at line 384 of file gnunet-cadet.c.

References echo, GNUNET_assert, GNUNET_CADET_close_port(), GNUNET_ERROR_TYPE_MESSAGE, GNUNET_i2s_full(), GNUNET_log, GNUNET_NO, and listen_stdio().

Referenced by run().

{
  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
              "Incoming connection from %s\n",
              GNUNET_i2s_full (initiator));
  GNUNET_assert (NULL == ch);
  GNUNET_assert (NULL != lp);
  GNUNET_CADET_close_port (lp);
  lp = NULL;
  ch = channel;
  if (GNUNET_NO == echo)
    listen_stdio ();
  return channel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_echo()

static void send_echo ( void *  cls )

static

Send an echo request to the remote peer.

Parameters

cls	Closure (NULL).

Definition at line 408 of file gnunet-cadet.c.

References env, GNUNET_CADET_get_mq(), GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_msg, GNUNET_MQ_send(), and msg.

Referenced by handle_data(), and run().

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;

  echo_task = NULL;
  if (NULL == ch)
    return;
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_CADET_CLI);
  GNUNET_MQ_send (GNUNET_CADET_get_mq (ch),
                  env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_data()

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

static

Check data message sanity.

Does nothing so far (all messages are OK).

Parameters

cls	Closure (unused).
message	The message to check.

Returns

GNUNET_OK to keep the channel open, GNUNET_SYSERR to close it (signal serious error).

Definition at line 432 of file gnunet-cadet.c.

References GNUNET_OK.

{
  return GNUNET_OK; /* all is well-formed */
}

handle_data()

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

static

Function called whenever a message is received.

Each time the function must call GNUNET_CADET_receive_done on the channel in order to receive the next message. This doesn't need to be immediate: can be delayed if some processing is done on the message.

Parameters

cls	NULL
message	The actual message.

Definition at line 450 of file gnunet-cadet.c.

References buf, done(), echo, echo_time, env, GNUNET_CADET_get_mq(), GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, len, listen_port, msg, send_echo(), and GNUNET_MessageHeader::size.

{
  size_t payload_size = ntohs (message->size) - sizeof (*message);
  uint16_t len;
  ssize_t done;
  uint16_t off;
  const char *buf;

  GNUNET_CADET_receive_done (ch);
  if (GNUNET_YES == echo)
  {
    if (NULL != listen_port)
    {
      struct GNUNET_MQ_Envelope *env;
      struct GNUNET_MessageHeader *msg;

      env = GNUNET_MQ_msg_extra (msg,
                                 payload_size,
                                 GNUNET_MESSAGE_TYPE_CADET_CLI);
      GNUNET_memcpy (&msg[1],
                     &message[1],
                     payload_size);
      GNUNET_MQ_send (GNUNET_CADET_get_mq (ch),
                      env);
      return;
    }
    else
    {
      struct GNUNET_TIME_Relative latency;

      latency = GNUNET_TIME_absolute_get_duration (echo_time);
      echo_time = GNUNET_TIME_UNIT_FOREVER_ABS;
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "time: %s\n",
                  GNUNET_STRINGS_relative_time_to_string (latency,
                                                          GNUNET_NO));
      echo_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                &send_echo,
                                                NULL);
    }
  }

  len = ntohs (message->size) - sizeof (*message);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got %u bytes\n",
              len);
  buf = (const char *) &message[1];
  off = 0;
  while (off < len)
  {
    done = write (1,
                  &buf[off],
                  len - off);
    if (done <= 0)
    {
      if (-1 == done)
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                             "write");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    off += done;
  }
}

Here is the call graph for this function:

peers_callback()

static void peers_callback ( void *  cls, const struct GNUNET_CADET_PeerListEntry *  ple  )

static

Method called to retrieve information about all peers in CADET, called once per peer.

After last peer has been reported, an additional call with NULL is done.

Parameters

cls	Closure.
ple	information about peer, or NULL on "EOF".

Definition at line 527 of file gnunet-cadet.c.

References FPRINTF, GNUNET_i2s_full(), GNUNET_SCHEDULER_shutdown(), GNUNET_CADET_PeerListEntry::have_tunnel, GNUNET_CADET_PeerListEntry::n_paths, and GNUNET_CADET_PeerListEntry::peer.

Referenced by get_peers().

{
  if (NULL == ple)
  {
    plo = NULL;
    GNUNET_SCHEDULER_shutdown();
    return;
  }
  FPRINTF (stdout,
           "%s tunnel: %c, paths: %u\n",
           GNUNET_i2s_full (&ple->peer),
           ple->have_tunnel ? 'Y' : 'N',
           ple->n_paths);
}

Here is the call graph for this function:

Here is the caller graph for this function:

path_callback()

static void path_callback ( void *  cls, const struct GNUNET_CADET_PeerPathDetail *  ppd  )

static

Method called to retrieve information about paths to a specific peer known to the service.

Parameters

cls	Closure.
ppd	path detail

Definition at line 552 of file gnunet-cadet.c.

References FPRINTF, GNUNET_i2s(), GNUNET_SCHEDULER_shutdown(), GNUNET_CADET_PeerPathDetail::path, GNUNET_CADET_PeerPathDetail::path_length, and GNUNET_CADET_PeerPathDetail::target_offset.

Referenced by show_peer().

{
  if (NULL == ppd)
  {
    gpo = NULL;
    GNUNET_SCHEDULER_shutdown();
    return;
  }
  FPRINTF (stdout,
           "Path of length %u: ",
           ppd->path_length);
  for (unsigned int i = 0; i < ppd->path_length; i++)
    FPRINTF (stdout,
             (i == ppd->target_offset) ? "*%s* " : "%s ",
             GNUNET_i2s (&ppd->path[i]));
  FPRINTF (stdout,
           "\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

tunnels_callback()

static void tunnels_callback ( void *  cls, const struct GNUNET_CADET_TunnelDetails *  td  )

static

Method called to retrieve information about all tunnels in CADET.

Parameters

cls	Closure.
td	tunnel details

Definition at line 580 of file gnunet-cadet.c.

References GNUNET_CADET_TunnelDetails::channels, conn_2s(), GNUNET_CADET_TunnelDetails::connections, GNUNET_CADET_TunnelDetails::cstate, enc_2s(), GNUNET_CADET_TunnelDetails::estate, FPRINTF, GNUNET_i2s_full(), GNUNET_SCHEDULER_shutdown(), and GNUNET_CADET_TunnelDetails::peer.

Referenced by get_tunnels().

{
  if (NULL == td)
  {
    tio = NULL;
    GNUNET_SCHEDULER_shutdown();
    return;
  }
  FPRINTF (stdout,
           "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
           GNUNET_i2s_full (&td->peer),
           enc_2s (td->estate),
           conn_2s (td->cstate),
           td->channels,
           td->connections);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_peers()

static void get_peers ( void *  cls )

static

Call CADET's meta API, get all peers known to a peer.

Parameters

cls	Closure (unused).

Definition at line 605 of file gnunet-cadet.c.

References GNUNET_CADET_list_peers(), and peers_callback().

Referenced by reconnect(), and run().

{
  job = NULL;
  plo = GNUNET_CADET_list_peers (my_cfg,
                                 &peers_callback,
                                 NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_peer()

static void show_peer ( void *  cls )

static

Call CADET's monitor API, get info of one peer.

Parameters

cls	Closure (unused).

Definition at line 620 of file gnunet-cadet.c.

References _, GNUNET_CADET_get_path(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_OK, GNUNET_SCHEDULER_shutdown(), path_callback(), peer_id, and GNUNET_PeerIdentity::public_key.

Referenced by run().

{
  struct GNUNET_PeerIdentity pid;

  job = NULL;
  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);
    GNUNET_SCHEDULER_shutdown();
    return;
  }
  gpo = GNUNET_CADET_get_path (my_cfg,
                               &pid,
                               &path_callback,
                               NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_tunnels()

static void get_tunnels ( void *  cls )

static

Call CADET's meta API, get all tunnels known to a peer.

Parameters

cls	Closure (unused).

Definition at line 649 of file gnunet-cadet.c.

References GNUNET_CADET_list_tunnels(), and tunnels_callback().

Referenced by reconnect(), and run().

{
  job = NULL;
  tio = GNUNET_CADET_list_tunnels (my_cfg,
                                   &tunnels_callback,
                                   NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_channel()

static void show_channel ( void *  cls )

static

Call CADET's monitor API, get info of one channel.

Parameters

cls	Closure (unused).

Definition at line 664 of file gnunet-cadet.c.

References GNUNET_break.

Referenced by run().

{
  job = NULL;
  GNUNET_break (0);
}

Here is the caller graph for this function:

show_connection()

static void show_connection ( void *  cls )

static

Call CADET's monitor API, get info of one connection.

Parameters

cls	Closure (unused).

Definition at line 677 of file gnunet-cadet.c.

References GNUNET_break.

Referenced by run().

{
  job = NULL;
  GNUNET_break (0);
}

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 (for saving, can be NULL!)
cfg	configuration

Definition at line 693 of file gnunet-cadet.c.

References _, cfg, channel_ended(), channel_id, channel_incoming(), conn_id, data, echo, FPRINTF, get_peers(), get_tunnels(), GNUNET_CADET_channel_create(), GNUNET_CADET_connect(), GNUNET_CADET_open_port(), GNUNET_CADET_OPTION_DEFAULT, GNUNET_CADET_OPTION_RELIABLE, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_YES, listen_port, listen_stdio(), peer_id, porthash, GNUNET_PeerIdentity::public_key, request_peers, request_tunnels, send_echo(), show_channel(), show_connection(), show_peer(), shutdown_task(), target_id, and target_port.

Referenced by main().

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (data,
                           GNUNET_MESSAGE_TYPE_CADET_CLI,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_handler_end ()
  };

  /* FIXME add option to monitor apps */
  my_cfg = cfg;
  target_id = args[0];
  if (target_id && args[1])
    target_port = args[1];

  if ( (0 != (request_peers | request_tunnels)
        || NULL != conn_id
        || NULL != channel_id)
       && target_id != NULL)
  {
    FPRINTF (stderr,
             _("Extra arguments are not applicable "
               "in combination with this option.\n"));
    return;
  }

  if (NULL != peer_id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Show peer\n");
    job = GNUNET_SCHEDULER_add_now (&show_peer,
                                    NULL);
  }
  else if (NULL != channel_id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Show channel\n");
    job = GNUNET_SCHEDULER_add_now (&show_channel,
                                    NULL);
  }
  else if (NULL != conn_id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Show connection\n");
    job = GNUNET_SCHEDULER_add_now (&show_connection,
                                    NULL);
  }
  else if (GNUNET_YES == request_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Show all peers\n");
    job = GNUNET_SCHEDULER_add_now (&get_peers,
                                    NULL);
  }
  else if (GNUNET_YES == request_tunnels)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Show all tunnels\n");
    job = GNUNET_SCHEDULER_add_now (&get_tunnels,
                                    NULL);
  }

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Connecting to CADET service\n");
  mh = GNUNET_CADET_connect (cfg);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  if (NULL == mh)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL != listen_port)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Opening CADET listen port\n");
    GNUNET_CRYPTO_hash (listen_port,
                        strlen (listen_port),
                        &porthash);
    lp = GNUNET_CADET_open_port (mh,
                                 &porthash,
                                 &channel_incoming,
                                 NULL,
                                 NULL /* window changes */,
                                 &channel_ended,
                                 handlers);
  }
  if (NULL != target_id)
  {
    struct GNUNET_PeerIdentity pid;
    enum GNUNET_CADET_ChannelOption opt;

    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_public_key_from_string (target_id,
                                                    strlen (target_id),
                                                    &pid.public_key))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  _("Invalid target `%s'\n"),
                  target_id);
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Connecting to `%s:%s'\n",
                target_id,
                target_port);
    opt = GNUNET_CADET_OPTION_DEFAULT | GNUNET_CADET_OPTION_RELIABLE;
    GNUNET_CRYPTO_hash (target_port,
                        strlen(target_port),
                        &porthash);
    ch = GNUNET_CADET_channel_create (mh,
                                      NULL,
                                      &pid,
                                      &porthash,
                                      opt,
                                      NULL /* window changes */,
                                      &channel_ended,
                                      handlers);
    if (GNUNET_YES == echo)
    {
      echo_task = GNUNET_SCHEDULER_add_now (&send_echo,
                                            NULL);
    }
    else
    {
      listen_stdio ();
    }
  }

  if ( (NULL == lp) &&
       (NULL == job) &&
       (NULL == ch) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                _("No action requested\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

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 obtain peer information.

Parameters

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

Returns

0 ok, 1 on error

Definition at line 847 of file gnunet-cadet.c.

References conn_id, echo, gettext_noop, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), listen_port, peer_id, request_peers, request_tunnels, res, and run().

{
  int res;
  const char helpstr[] = "Create tunnels and retrieve info about CADET's status.";
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    /* I would use the terminology 'circuit' here...  --lynX */
    GNUNET_GETOPT_option_string ('C',
                                 "connection",
                                 "CONNECTION_ID",
                                 gettext_noop ("Provide information about a particular connection"),
                                 &conn_id),
    GNUNET_GETOPT_option_flag ('e',
                               "echo",
                               gettext_noop ("Activate echo mode"),
                               &echo),
    GNUNET_GETOPT_option_string ('o',
                                 "open-port",
                                 "SHARED_SECRET",
                                 gettext_noop ("Listen for connections using a shared secret among sender and recipient"),
                                 &listen_port),
    GNUNET_GETOPT_option_string ('p',
                                 "peer",
                                 "PEER_ID",
                                 gettext_noop ("Provide information about a patricular peer"),
                                 &peer_id),
    GNUNET_GETOPT_option_flag ('P',
                               "peers",
                               gettext_noop ("Provide information about all peers"),
                               &request_peers),
    GNUNET_GETOPT_option_flag ('T',
                               "tunnels",
                               gettext_noop ("Provide information about all tunnels"),
                               &request_tunnels),
    GNUNET_GETOPT_OPTION_END
  };

  if (GNUNET_OK !=
      GNUNET_STRINGS_get_utf8_args (argc, argv,
                                    &argc, &argv))
    return 2;

  res = GNUNET_PROGRAM_run (argc, argv,
                            "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
                            gettext_noop (helpstr),
                            options, &run, NULL);

  GNUNET_free ((void *) argv);

  if (GNUNET_OK == res)
    return 0;
  return 1;
}

Here is the call graph for this function:

Variable Documentation

request_peers

int request_peers

static

Option -P.

Definition at line 37 of file gnunet-cadet.c.

Referenced by main(), and run().

peer_id

char* peer_id

static

Option –peer.

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

Referenced by ats_performance_info_cb(), check_remote_overlay_connect(), compute_diversity(), count_peer_in_views(), count_peer_in_views_2(), database_setup(), evaluate(), GCP_get(), gen_topo_from_file(), get_idx_of_pid(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_remote_overlay_connect(), is_in_view(), main(), manage_service_wrapper(), peerstore_flat_store_record(), print_view_sizes(), run(), show_peer(), uri_loc_to_string(), and write_final_stats().

request_tunnels

int request_tunnels

static

Option -T.

Definition at line 47 of file gnunet-cadet.c.

Referenced by main(), and run().

conn_id

char* conn_id

static

Option –connection.

Definition at line 52 of file gnunet-cadet.c.

Referenced by main(), and run().

channel_id

char* channel_id

static

Option –channel.

Definition at line 57 of file gnunet-cadet.c.

Referenced by run().

listen_port

char* listen_port

static

Port to listen on (-o).

Definition at line 62 of file gnunet-cadet.c.

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

echo

int echo

static

Request echo service.

Definition at line 67 of file gnunet-cadet.c.

Referenced by channel_incoming(), GNUNET_TESTBED_barrier_init_(), handle_data(), main(), read_stdio(), render_row(), and run().

echo_time

struct GNUNET_TIME_Absolute echo_time

static

Time of last echo request.

Definition at line 72 of file gnunet-cadet.c.

Referenced by handle_data(), and read_stdio().

echo_task

struct GNUNET_SCHEDULER_Task* echo_task

static

Task for next echo request.

Definition at line 77 of file gnunet-cadet.c.

target_id

char* target_id

static

Peer to connect to.

Definition at line 82 of file gnunet-cadet.c.

Referenced by run().

target_port

char* target_port = "default"

static

Port to connect to.

Definition at line 87 of file gnunet-cadet.c.

Referenced by run().

mh

struct GNUNET_CADET_Handle* mh

static

Cadet handle.

Definition at line 92 of file gnunet-cadet.c.

Referenced by database_setup(), GNUNET_CORE_monitor_start(), GNUNET_DHT_monitor_start(), GNUNET_SERVER_inject(), GNUNET_TRANSPORT_TESTING_transport_communicator_send(), handle_dv_box(), handle_monitor_get(), handle_monitor_get_resp(), handle_monitor_put(), handle_mq_error(), handle_receive_info(), handle_send_msg(), load_etc_hosts(), lookup_dns_servers(), mqm_execute(), send_offers_iterator(), and try_reconnect().

my_cfg

const struct GNUNET_CONFIGURATION_Handle* my_cfg

static

Our configuration.

Definition at line 97 of file gnunet-cadet.c.

gpo

struct GNUNET_CADET_GetPath* gpo

static

Active get path operation.

Definition at line 102 of file gnunet-cadet.c.

plo

struct GNUNET_CADET_PeersLister* plo

static

Active peer listing operation.

Definition at line 107 of file gnunet-cadet.c.

tio

struct GNUNET_CADET_ListTunnels* tio

static

Active tunnel listing operation.

Definition at line 112 of file gnunet-cadet.c.

Referenced by handle_issue_ticket_message(), and issue_ticket_result_cb().

ch

struct GNUNET_CADET_Channel* ch

static

Channel handle.

Definition at line 117 of file gnunet-cadet.c.

Referenced by adjust_running_peers(), cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_error_handler(), cadet_mq_send_impl(), cadet_mq_send_now(), channel_audio_sent_notify(), client_connect_cb(), client_disconnect_cb(), client_schedule(), conclude_autoconfig_request(), create_channel(), debug_channel(), destroy_channel_cb(), destroy_remaining_channels(), disconnect_cadet_peers(), dyndns_lookup(), error_handler(), find_channel_by_line(), GCT_add_channel(), GNUNET_CADET_channel_create(), GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_TRANSPORT_communicator_connect(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_communicator_mq_del(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_TRANSPORT_core_get_mq(), handle_autoconfig_request(), handle_backchannel_incoming(), handle_cadet_audio_message(), handle_cadet_hangup_message(), handle_cadet_pickup_message(), handle_cadet_resume_message(), handle_cadet_ring_message(), handle_cadet_suspend_message(), handle_channel_create(), handle_channel_created(), handle_channel_destroy(), handle_client_audio_message(), handle_client_call_message(), handle_client_hangup_message(), handle_client_pickup_message(), handle_client_resume_message(), handle_client_suspend_message(), handle_create_queue(), handle_incoming_ack(), handle_local_ack(), handle_local_data(), handle_plaintext_channel_destroy(), handle_plaintext_channel_open(), handle_plaintext_channel_open_ack(), handle_plaintext_data(), handle_plaintext_data_ack(), handle_register(), handle_request_connection_reversal(), handle_send_msg(), handle_stun(), inbound_channel(), inbound_end(), iterate_channels_cb(), mq_done_finish_caller_shutdown(), notify_client_external_ipv4_change(), notify_clients(), notify_clients_stun_change(), notify_tunnel_up_cb(), process_external_ip(), reversal_callback(), send_ack_cb(), start_test(), and upnp_addr_change_cb().

porthash

struct GNUNET_HashCode porthash

static

HashCode of the given port string.

Definition at line 122 of file gnunet-cadet.c.

Referenced by run().

lp

struct GNUNET_CADET_Port* lp

Data structure for ongoing reception of incoming virtual circuits.

Definition at line 127 of file gnunet-cadet.c.

rd_task

struct GNUNET_SCHEDULER_Task* rd_task

static

Task for reading from stdin.

Definition at line 132 of file gnunet-cadet.c.

job

struct GNUNET_SCHEDULER_Task* job

static

Task for main job.

Definition at line 137 of file gnunet-cadet.c.

Referenced by GNUNET_CURL_job_add(), GNUNET_CURL_job_add2(), GNUNET_CURL_perform2(), and main().

sent_pkt

unsigned int sent_pkt

static

Definition at line 139 of file gnunet-cadet.c.

Referenced by read_stdio().