gnunet-core.c File Reference

Print information about other peers known to CORE. More...

#include "platform.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_core_service.h"

Include dependency graph for gnunet-core.c:

Go to the source code of this file.

Functions
static void	shutdown_task (void *cls)
	Task run in monitor mode when the user presses CTRL-C to abort.
static void	monitor_cb (void *cls, const struct GNUNET_PeerIdentity *peer, enum GNUNET_CORE_KxState state, struct GNUNET_TIME_Absolute timeout)
	Function called to notify core users that another peer changed its state with us.
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 obtain peer information from CORE.

Variables
static int	ret
	Return code.
static int	monitor_connections
	Option -m.
static int	show_conns
	Option -s.
static struct GNUNET_CORE_MonitorHandle *	mh
	Handle to the CORE monitor.

Detailed Description

Print information about other peers known to CORE.

Author

Nathan Evans

Martin Schanzenbach

Definition in file gnunet-core.c.

Function Documentation

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 59 of file gnunet-core.c.

{
  (void) cls;
  if (NULL != mh)
  {
    GNUNET_CORE_monitor_stop (mh);
    mh = NULL;
  }
}

References GNUNET_CORE_monitor_stop(), and mh.

Here is the call graph for this function:

monitor_cb()

static void monitor_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, enum GNUNET_CORE_KxState  state, struct GNUNET_TIME_Absolute  timeout  )

static

Function called to notify core users that another peer changed its state with us.

Parameters

cls	closure
peer	the peer that changed state
state	new state of the peer
timeout	timeout for the new state

Definition at line 80 of file gnunet-core.c.

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str;
  const char *state_str;
 
  (void) cls;
  if (((NULL == peer) || (GNUNET_CORE_KX_ITERATION_FINISHED == state)) &&
      (GNUNET_NO == monitor_connections))
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  switch (state)
  {
  case GNUNET_CORE_KX_STATE_INITIATOR_HELLO_SENT:
    state_str = _ ("Hello sent (I)");
    break;
 
  case GNUNET_CORE_KX_STATE_INITIATOR_DONE_SENT:
    state_str = _ ("Done sent (I)");
    break;
 
  case GNUNET_CORE_KX_STATE_AWAIT_INITIATION:
    state_str = _ ("Awaiting initiation (R)");
    break;
 
  case GNUNET_CORE_KX_STATE_INITIATOR_HELLO_RECEIVED:
    state_str = _ ("Hello received (R)");
    break;
 
  case GNUNET_CORE_KX_STATE_RESPONDER_HELLO_SENT:
    state_str = _ ("Hello sent (R)");
    break;
 
  case GNUNET_CORE_KX_STATE_RESPONDER_HELLO_RECEIVED:
    state_str = _ ("Hello received (I)");
    break;
 
  case GNUNET_CORE_KX_STATE_INITIATOR_CONNECTED:
    state_str = _ ("Connected (I)");
    break;
 
  case GNUNET_CORE_KX_STATE_RESPONDER_CONNECTED:
    state_str = _ ("Connected (R)");
    break;
 
  case GNUNET_CORE_KX_STATE_DOWN:
    /* should never happen, as we immediately send the key */
    state_str = _ ("idle");
    break;
 
  case GNUNET_CORE_KX_PEER_DISCONNECT:
    state_str = _ ("disconnected");
    break;
 
  case GNUNET_CORE_KX_ITERATION_FINISHED:
    return;
 
  case GNUNET_CORE_KX_CORE_DISCONNECT:
    fprintf (stderr,
             "%s\n",
             _ ("Connection to CORE service lost (reconnecting)"));
    return;
 
  default:
    state_str = _ ("unknown state");
    break;
  }
  now_str = GNUNET_STRINGS_absolute_time_to_string (now);
  fprintf (stdout,
           _ ("%24s: %-30s %4s (timeout in %6s)\n"),
           now_str,
           state_str,
           GNUNET_i2s (peer),
           GNUNET_STRINGS_relative_time_to_string (
             GNUNET_TIME_absolute_get_remaining (timeout),
             GNUNET_YES));
}

References _, GNUNET_CORE_KX_CORE_DISCONNECT, GNUNET_CORE_KX_ITERATION_FINISHED, GNUNET_CORE_KX_PEER_DISCONNECT, GNUNET_CORE_KX_STATE_AWAIT_INITIATION, GNUNET_CORE_KX_STATE_DOWN, GNUNET_CORE_KX_STATE_INITIATOR_CONNECTED, GNUNET_CORE_KX_STATE_INITIATOR_DONE_SENT, GNUNET_CORE_KX_STATE_INITIATOR_HELLO_RECEIVED, GNUNET_CORE_KX_STATE_INITIATOR_HELLO_SENT, GNUNET_CORE_KX_STATE_RESPONDER_CONNECTED, GNUNET_CORE_KX_STATE_RESPONDER_HELLO_RECEIVED, GNUNET_CORE_KX_STATE_RESPONDER_HELLO_SENT, GNUNET_i2s(), GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, monitor_connections, state, and timeout.

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

Definition at line 174 of file gnunet-core.c.

{
  (void) cls;
  (void) cfgfile;
 
  if (NULL != args[0])
  {
    fprintf (stderr, _ ("Invalid command line argument `%s'\n"), args[0]);
    return;
  }
  if (! show_conns && ! monitor_connections)
  {
    fprintf (stderr, "%s", _ ("No argument given.\n"));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (show_conns || monitor_connections)
  {
    if (monitor_connections)
    {
      fprintf (stdout,
               _ ("Monitoring connections. Press CTRL-C to quit.\n\n"));
    }
    mh = GNUNET_CORE_monitor_start (cfg, &monitor_cb, NULL);
    if (NULL == mh)
    {
      fprintf (stderr, "%s", _ ("Failed to connect to CORE service!\n"));
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
    }
    return;
  }
}

References _, cfg, GNUNET_CORE_monitor_start(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), mh, monitor_cb(), monitor_connections, ret, show_conns, 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 obtain peer information from CORE.

Parameters

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

Returns

0 ok, 1 on error

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

{
  int res;
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag (
      'm',
      "monitor",
      gettext_noop (
        "provide information about all current connections (continuously)"),
      &monitor_connections),
    GNUNET_GETOPT_option_flag (
      's',
      "connection-status",
      gettext_noop (
        "Show current connections"
        ),
      &show_conns),
    GNUNET_GETOPT_OPTION_END };
 
  res = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                            argc,
                            argv,
                            "gnunet-core",
                            gettext_noop (
                              "Print information about connected peers."),
                            options,
                            &run,
                            NULL);
 
  if (GNUNET_OK == res)
    return ret;
  return 1;
}

References gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), monitor_connections, options, res, ret, run(), and show_conns.

Here is the call graph for this function:

Variable Documentation

ret

int ret

static

Return code.

Definition at line 35 of file gnunet-core.c.

Referenced by main(), and run().

monitor_connections

int monitor_connections

static

Option -m.

Definition at line 40 of file gnunet-core.c.

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

show_conns

int show_conns

static

Option -s.

Definition at line 45 of file gnunet-core.c.

Referenced by main(), and run().

mh

struct GNUNET_CORE_MonitorHandle* mh

static

Handle to the CORE monitor.

Definition at line 50 of file gnunet-core.c.

Referenced by run(), and shutdown_task().