gnunet-ats.c File Reference

ATS command line tool. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_ats_service.h"
#include "gnunet_transport_service.h"

Include dependency graph for gnunet-ats.c:

Go to the source code of this file.

Data Structures
struct	PendingResolutions
	Structure used to remember all pending address resolutions. More...
struct	ATSAddress
	Information we keep for an address. More...
struct	AddressFindCtx
	Closure for find_address_it(). More...

Macros
#define	UNLIMITED_STRING   "unlimited"
	String to respresent unlimited. More...

Functions
static int	free_addr_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Free address corresponding to a given peer. More...
static void	end (void *cls)
	Task run on shutdown. More...
static void	transport_addr_to_str_cb (void *cls, const char *address, int res)
	Function to call with a textual representation of an address. More...
static int	find_address_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Find address corresponding to a given peer. More...
static void	ats_perf_mon_cb (void *cls, const struct GNUNET_HELLO_Address *address, int active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
	Signature of a function that is called with QoS information about an address. More...
static void	ats_perf_cb (void *cls, const struct GNUNET_HELLO_Address *address, int active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
	Signature of a function that is called with QoS information about an address. More...
static unsigned int	print_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Print information about the quotas configured for the various network scopes. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *my_cfg)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function. More...

Variables
static int	opt_resolve_addresses_numeric
	CLI Opt: More...
static int	opt_verbose
	CLI Opt: Print verbose ATS information. More...
static int	opt_list_used
	CLI Option: List only addresses currently used (active) More...
static int	opt_list_all
	CLI Option: List all addresses. More...
static int	opt_set_pref
	CLI Option: set preference. More...
static int	opt_print_quotas
	CLI Option: print quotas configured. More...
static int	opt_monitor
	CLI Option: Monitor addresses used. More...
static char *	opt_pid_str
	CLI Option: use specific peer. More...
static char *	opt_type_str
	CLI Option: preference type to set. More...
static unsigned int	opt_pref_value
	CLI Option: preference value to set. More...
static int	ret
	Final status code. More...
static int	stat_results
	Number of results returned from service. More...
static int	stat_receive_done
	State: all pending receive operations done? More...
static int	stat_pending
	State: number of pending operations. More...
static char *	cpid_str
	Which peer should we connect to? More...
static struct GNUNET_ATS_PerformanceHandle *	ph
	ATS performance handle used. More...
static struct GNUNET_ATS_ConnectivityHandle *	ats_ch
	Our connectivity handle. More...
static struct GNUNET_ATS_ConnectivitySuggestHandle *	ats_sh
	Handle for address suggestion request. More...
static struct GNUNET_ATS_AddressListHandle *	alh
	ATS address list handle used. More...
static struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration handle. More...
static struct GNUNET_SCHEDULER_Task *	shutdown_task
	Shutdown task. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	addresses
	Hashmap to store addresses. More...
static struct PendingResolutions *	head
	Head of list of pending resolution requests. More...
static struct PendingResolutions *	tail
	Tail of list of pending resolution requests. More...

Detailed Description

ATS command line tool.

Author

Matthias Wachs

Christian Grothoff

Definition in file gnunet-ats.c.

Macro Definition Documentation

UNLIMITED_STRING

#define UNLIMITED_STRING   "unlimited"

String to respresent unlimited.

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

Function Documentation

free_addr_it()

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

static

Free address corresponding to a given peer.

Parameters

cls	NULL
key	peer identity
value	the struct ATSAddress * to be freed

Returns

GNUNET_YES (always)

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

{
  struct ATSAddress *a = value;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_remove (addresses, key, value));
  GNUNET_HELLO_address_free (a->address);
  GNUNET_free (a);
  return GNUNET_OK;
}

References ATSAddress::address, addresses, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_HELLO_address_free, GNUNET_OK, key, and value.

Referenced by ats_perf_mon_cb(), and end().

Here is the call graph for this function:

Here is the caller graph for this function:

end()

static void end ( void *  cls )

static

Task run on shutdown.

Parameters

cls

NULL

Definition at line 265 of file gnunet-ats.c.

{
  struct PendingResolutions *pr;
  struct PendingResolutions *next;
  unsigned int pending;
 
  if (NULL != alh)
  {
    GNUNET_ATS_performance_list_addresses_cancel (alh);
    alh = NULL;
  }
 
  if (NULL != ph)
  {
    GNUNET_ATS_performance_done (ph);
    ph = NULL;
  }
 
  pending = 0;
  next = head;
  while (NULL != (pr = next))
  {
    next = pr->next;
    GNUNET_CONTAINER_DLL_remove (head, tail, pr);
    GNUNET_TRANSPORT_address_to_string_cancel (pr->tats_ctx);
    GNUNET_free (pr->address);
    GNUNET_free (pr);
    pending++;
  }
  GNUNET_CONTAINER_multipeermap_iterate (addresses, &free_addr_it, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (addresses);
  addresses = NULL;
 
  if (0 < pending)
    fprintf (stdout, _ ("%u address resolutions had a timeout\n"), pending);
  if (opt_list_used || opt_list_all)
    fprintf (stdout,
             _ ("ATS returned stat_results for %u addresses\n"),
             stat_results);
 
  if (NULL != ats_sh)
  {
    GNUNET_ATS_connectivity_suggest_cancel (ats_sh);
    ats_sh = NULL;
  }
  if (NULL != ats_ch)
  {
    GNUNET_ATS_connectivity_done (ats_ch);
    ats_ch = NULL;
  }
  ret = 0;
}

References _, PendingResolutions::address, addresses, alh, ats_ch, ats_sh, free_addr_it(), GNUNET_ATS_connectivity_done(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_ATS_performance_done(), GNUNET_ATS_performance_list_addresses_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_TRANSPORT_address_to_string_cancel(), head, PendingResolutions::next, opt_list_all, opt_list_used, pending, ph, ret, stat_results, tail, and PendingResolutions::tats_ctx.

Referenced by ats_perf_cb(), run(), and transport_addr_to_str_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

transport_addr_to_str_cb()

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

static

Function to call 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, a struct PendingResolutions *
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 336 of file gnunet-ats.c.

{
  struct PendingResolutions *pr = cls;
 
  if (NULL == address)
  {
    /* We're done */
    GNUNET_CONTAINER_DLL_remove (head, tail, pr);
    GNUNET_free (pr->address);
    GNUNET_free (pr);
    stat_pending--;
 
    if ((GNUNET_YES == stat_receive_done) && (0 == stat_pending))
    {
      /* All messages received and no resolutions pending*/
      if (shutdown_task != NULL)
        GNUNET_SCHEDULER_cancel (shutdown_task);
      shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
    }
    return;
  }
  switch (res)
  {
  case GNUNET_SYSERR:
    fprintf (
      stderr,
      "Failed to convert address for peer `%s' plugin `%s' length %u to string (communication error)\n",
      GNUNET_i2s (&pr->address->peer),
      pr->address->transport_name,
      (unsigned int) pr->address->address_length);
    return;
 
  case GNUNET_NO:
    fprintf (
      stderr,
      "Failed to convert address for peer `%s' plugin `%s' length %u to string (address invalid or not supported)\n",
      GNUNET_i2s (&pr->address->peer),
      pr->address->transport_name,
      (unsigned int) pr->address->address_length);
    return;
 
  case GNUNET_OK:
    /* continues below */
    break;
 
  default:
    GNUNET_break (0);
    return;
  }
 
  fprintf (
    stdout,
    _ (
      "Peer `%s' plugin `%s', address `%s', `%s' bw out: %u Bytes/s, bw in %u Bytes/s, %s\n"),
    GNUNET_i2s (&pr->address->peer),
    pr->address->transport_name,
    address,
    GNUNET_NT_to_string (pr->properties.scope),
    ntohl (pr->bandwidth_out.value__),
    ntohl (pr->bandwidth_in.value__),
    pr->active ? _ ("active ") : _ ("inactive "));
}

References _, PendingResolutions::active, PendingResolutions::address, address, GNUNET_HELLO_Address::address_length, PendingResolutions::bandwidth_in, PendingResolutions::bandwidth_out, end(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_NT_to_string(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_YES, head, GNUNET_HELLO_Address::peer, PendingResolutions::properties, res, GNUNET_ATS_Properties::scope, shutdown_task, stat_pending, stat_receive_done, tail, GNUNET_HELLO_Address::transport_name, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by ats_perf_cb(), and ats_perf_mon_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

find_address_it()

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

static

Find address corresponding to a given peer.

Parameters

cls	the struct AddressFindCtx *
key	peer identity
value	the struct ATSAddress * for an existing address

Returns

GNUNET_NO if we found a match, GNUNET_YES if not

Definition at line 426 of file gnunet-ats.c.

{
  struct AddressFindCtx *actx = cls;
  struct ATSAddress *exist = value;
 
  if (0 == GNUNET_HELLO_address_cmp (actx->src, exist->address))
  {
    actx->res = exist;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References ATSAddress::address, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_YES, AddressFindCtx::res, AddressFindCtx::src, and value.

Referenced by ats_perf_mon_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

ats_perf_mon_cb()

static void ats_perf_mon_cb ( void *  cls, const struct GNUNET_HELLO_Address *  address, int  active, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_in, const struct GNUNET_ATS_Properties *  prop  )

static

Signature of a function that is called with QoS information about an address.

Parameters

cls	closure (NULL)
address	the address, NULL if ATS service was disconnected
active	GNUNET_YES if this address is actively used to maintain a connection to a peer; GNUNET_NO if the address is not actively used; GNUNET_SYSERR if this address is no longer available for ATS
bandwidth_out	assigned outbound bandwidth for the connection
bandwidth_in	assigned inbound bandwidth for the connection
prop	performance data for the address (as far as known)

Definition at line 454 of file gnunet-ats.c.

{
  struct PendingResolutions *pr;
  struct PendingResolutions *cur;
  struct PendingResolutions *next;
 
  if (NULL == address)
  {
    /* ATS service temporarily disconnected, remove current state */
    next = head;
    for (cur = next; NULL != cur; cur = next)
    {
      next = cur->next;
      GNUNET_CONTAINER_DLL_remove (head, tail, cur);
      GNUNET_TRANSPORT_address_to_string_cancel (cur->tats_ctx);
      GNUNET_HELLO_address_free (cur->address);
      GNUNET_free (cur);
    }
    GNUNET_CONTAINER_multipeermap_iterate (addresses, &free_addr_it, NULL);
    return;
  }
  if (GNUNET_SYSERR == active)
  {
    /* remove address */
    struct AddressFindCtx actx;
 
    actx.src = address;
    actx.res = NULL;
    GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
                                                &address->peer,
                                                &find_address_it,
                                                &actx);
    if (NULL == actx.res)
    {
      GNUNET_break (0);
      return;
    }
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONTAINER_multipeermap_remove (addresses,
                                                        &address->peer,
                                                        actx.res));
    fprintf (stdout,
             _ ("Removed address of peer `%s' with plugin `%s'\n"),
             GNUNET_i2s (&address->peer),
             actx.res->address->transport_name);
    GNUNET_HELLO_address_free (actx.res);
    return;
  }
 
  if (GNUNET_NO == opt_verbose)
  {
    struct AddressFindCtx actx;
    struct ATSAddress *a;
 
    actx.src = address;
    actx.res = NULL;
    GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
                                                &address->peer,
                                                &find_address_it,
                                                &actx);
    if ((NULL != actx.res))
    {
      if ((bandwidth_in.value__ == actx.res->bandwidth_in.value__) &&
          (bandwidth_out.value__ == actx.res->bandwidth_out.value__) &&
          (active == actx.res->active))
      {
        return;       /* Nothing to do here */
      }
      else
      {
        actx.res->bandwidth_in = bandwidth_in;
        actx.res->bandwidth_out = bandwidth_out;
      }
    }
    else
    {
      a = GNUNET_new (struct ATSAddress);
 
      a->address = GNUNET_HELLO_address_copy (address);
      a->bandwidth_in = bandwidth_in;
      a->bandwidth_out = bandwidth_out;
      a->active = active;
      GNUNET_CONTAINER_multipeermap_put (
        addresses,
        &address->peer,
        a,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    }
  }
 
  pr = GNUNET_new (struct PendingResolutions);
  pr->properties = *prop;
  pr->address = GNUNET_HELLO_address_copy (address);
  pr->bandwidth_in = bandwidth_in;
  pr->bandwidth_out = bandwidth_out;
  pr->active = active;
  pr->tats_ctx = GNUNET_TRANSPORT_address_to_string (
    cfg,
    address,
    opt_resolve_addresses_numeric,
    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
    &transport_addr_to_str_cb,
    pr);
  GNUNET_CONTAINER_DLL_insert (head, tail, pr);
  stat_results++;
  stat_pending++;
}

References _, PendingResolutions::active, ATSAddress::active, PendingResolutions::address, ATSAddress::address, address, addresses, PendingResolutions::bandwidth_in, ATSAddress::bandwidth_in, PendingResolutions::bandwidth_out, ATSAddress::bandwidth_out, cfg, find_address_it(), free_addr_it(), GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_HELLO_address_copy(), GNUNET_HELLO_address_free, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TRANSPORT_address_to_string(), GNUNET_TRANSPORT_address_to_string_cancel(), head, PendingResolutions::next, opt_resolve_addresses_numeric, opt_verbose, PendingResolutions::properties, AddressFindCtx::res, AddressFindCtx::src, stat_pending, stat_results, tail, PendingResolutions::tats_ctx, transport_addr_to_str_cb(), GNUNET_HELLO_Address::transport_name, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

ats_perf_cb()

static void ats_perf_cb ( void *  cls, const struct GNUNET_HELLO_Address *  address, int  active, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_in, const struct GNUNET_ATS_Properties *  prop  )

static

Signature of a function that is called with QoS information about an address.

Parameters

cls	closure (NULL)
address	the address, NULL if ATS service was disconnected
active	is this address actively used to maintain a connection to a peer
bandwidth_out	assigned outbound bandwidth for the connection
bandwidth_in	assigned inbound bandwidth for the connection
prop	performance data for the address (as far as known)

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

{
  struct PendingResolutions *pr;
 
  if (NULL == address)
  {
    /* All messages received */
    stat_receive_done = GNUNET_YES;
    alh = NULL;
    if (0 == stat_pending)
    {
      /* All messages received and no resolutions pending*/
      if (shutdown_task != NULL)
        GNUNET_SCHEDULER_cancel (shutdown_task);
      shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
    }
    return;
  }
 
  pr = GNUNET_new (struct PendingResolutions);
  pr->properties = *prop;
  pr->address = GNUNET_HELLO_address_copy (address);
  pr->bandwidth_in = bandwidth_in;
  pr->bandwidth_out = bandwidth_out;
  pr->active = active;
  pr->tats_ctx = GNUNET_TRANSPORT_address_to_string (
    cfg,
    address,
    opt_resolve_addresses_numeric,
    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
    &transport_addr_to_str_cb,
    pr);
  GNUNET_CONTAINER_DLL_insert (head, tail, pr);
  stat_results++;
  stat_pending++;
}

References PendingResolutions::active, PendingResolutions::address, address, alh, PendingResolutions::bandwidth_in, PendingResolutions::bandwidth_out, cfg, end(), GNUNET_CONTAINER_DLL_insert, GNUNET_HELLO_address_copy(), GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TRANSPORT_address_to_string(), GNUNET_YES, head, opt_resolve_addresses_numeric, PendingResolutions::properties, shutdown_task, stat_pending, stat_receive_done, stat_results, tail, PendingResolutions::tats_ctx, and transport_addr_to_str_cb().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

print_quotas()

static unsigned int print_quotas ( const struct GNUNET_CONFIGURATION_Handle *  cfg )

static

Print information about the quotas configured for the various network scopes.

Parameters

cfg	configuration to obtain quota information from

Returns

total number of ATS network types known

Definition at line 631 of file gnunet-ats.c.

{
  char *entry_in = NULL;
  char *entry_out = NULL;
  char *quota_out_str;
  char *quota_in_str;
  unsigned long long int quota_out;
  unsigned long long int quota_in;
  int c;
 
  for (c = 0; (c < GNUNET_NT_COUNT); c++)
  {
    GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", GNUNET_NT_to_string (c));
    GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", GNUNET_NT_to_string (c));
 
    /* quota out */
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg,
                                                            "ats",
                                                            entry_out,
                                                            &quota_out_str))
    {
      if ((0 == strcmp (quota_out_str, UNLIMITED_STRING)) ||
          (GNUNET_SYSERR ==
           GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, &quota_out)))
        quota_out = UINT32_MAX;
 
      GNUNET_free (quota_out_str);
      GNUNET_asprintf (&quota_out_str, "%llu", quota_out);
    }
    else
    {
      fprintf (stderr,
               "Outbound quota for network `%11s' not configured!\n",
               GNUNET_NT_to_string (c));
      GNUNET_asprintf (&quota_out_str, "-");
    }
    GNUNET_free (entry_out);
 
    /* quota in */
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg,
                                                            "ats",
                                                            entry_in,
                                                            &quota_in_str))
    {
      if ((0 == strcmp (quota_in_str, UNLIMITED_STRING)) ||
          (GNUNET_SYSERR ==
           GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &quota_in)))
        quota_in = UINT32_MAX;
      GNUNET_free (quota_in_str);
      GNUNET_asprintf (&quota_in_str, "%llu", quota_in);
    }
    else
    {
      fprintf (stderr,
               "Inbound quota for network `%11s' not configured!\n",
               GNUNET_NT_to_string (c));
      GNUNET_asprintf (&quota_in_str, "-");
    }
    GNUNET_free (entry_in);
 
    fprintf (stdout,
             _ ("Quota for network `%11s' (in/out): %10s / %10s\n"),
             GNUNET_NT_to_string (c),
             quota_in_str,
             quota_out_str);
    GNUNET_free (quota_out_str);
    GNUNET_free (quota_in_str);
  }
  return GNUNET_NT_COUNT;
}

References _, cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_NT_COUNT, GNUNET_NT_to_string(), GNUNET_OK, GNUNET_STRINGS_fancy_size_to_bytes(), GNUNET_SYSERR, and UNLIMITED_STRING.

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 *  my_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!)
my_cfg	configuration

Definition at line 712 of file gnunet-ats.c.

{
  struct GNUNET_PeerIdentity pid;
  struct GNUNET_PeerIdentity cpid;
  unsigned int c;
  unsigned int type;
 
  cfg = (struct GNUNET_CONFIGURATION_Handle *) my_cfg;
  addresses = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
  stat_results = 0;
 
  c = 0;
  if (NULL != opt_pid_str)
  {
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_public_key_from_string (opt_pid_str,
                                                    strlen (opt_pid_str),
                                                    &pid.public_key))
    {
      fprintf (stderr, _ ("Failed to parse peer identity `%s'\n"), opt_pid_str);
      return;
    }
  }
  if (NULL != cpid_str)
  {
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_public_key_from_string (cpid_str,
                                                    strlen (cpid_str),
                                                    &cpid.public_key))
    {
      fprintf (stderr, _ ("Failed to parse peer identity `%s'\n"), cpid_str);
      return;
    }
    c++;
  }
 
  c += opt_list_all + opt_list_used + opt_monitor + opt_set_pref;
 
  if (1 < c)
  {
    fprintf (stderr,
             _ ("Please select one operation: %s or %s or %s or %s or %s\n"),
             "--used",
             "--all",
             "--monitor",
             "--preference",
             "--quotas");
    return;
  }
  if (0 == c)
    opt_list_used = GNUNET_YES; /* set default */
  if (opt_print_quotas)
  {
    ret = print_quotas (cfg);
    return;
  }
  if (opt_list_all)
  {
    ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
    if (NULL == ph)
    {
      fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
      return;
    }
    alh = GNUNET_ATS_performance_list_addresses (ph,
                                                 (NULL == opt_pid_str) ? NULL
                                                 : &pid,
                                                 GNUNET_YES,
                                                 &ats_perf_cb,
                                                 NULL);
    if (NULL == alh)
    {
      fprintf (stderr,
               "%s",
               _ ("Cannot issue request to ATS service, exiting...\n"));
      shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
      return;
    }
    shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end, NULL);
    return;
  }
  if (opt_list_used)
  {
    ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
    if (NULL == ph)
      fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
 
    alh = GNUNET_ATS_performance_list_addresses (ph,
                                                 (NULL == opt_pid_str) ? NULL
                                                 : &pid,
                                                 GNUNET_NO,
                                                 &ats_perf_cb,
                                                 NULL);
    if (NULL == alh)
    {
      fprintf (stderr,
               "%s",
               _ ("Cannot issue request to ATS service, exiting...\n"));
      shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
      return;
    }
    shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end, NULL);
    return;
  }
  if (opt_monitor)
  {
    ph = GNUNET_ATS_performance_init (cfg, &ats_perf_mon_cb, NULL);
    shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end, NULL);
    if (NULL == ph)
    {
      fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
      GNUNET_SCHEDULER_shutdown ();
    }
    return;
  }
  if (opt_set_pref)
  {
    if (NULL == opt_type_str)
    {
      fprintf (stderr, "%s", _ ("No preference type given!\n"));
      return;
    }
    if (NULL == opt_pid_str)
    {
      fprintf (stderr, "%s", _ ("No peer given!\n"));
      return;
    }
 
    for (c = 0; c < strlen (opt_type_str); c++)
    {
      if (isupper ((unsigned char) opt_type_str[c]))
        opt_type_str[c] = tolower ((unsigned char) opt_type_str[c]);
    }
 
    if (0 == strcasecmp ("latency", opt_type_str))
      type = GNUNET_ATS_PREFERENCE_LATENCY;
    else if (0 == strcasecmp ("bandwidth", opt_type_str))
      type = GNUNET_ATS_PREFERENCE_BANDWIDTH;
    else
    {
      fprintf (stderr, "%s", _ ("Valid type required\n"));
      return;
    }
 
    /* set */
    ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
    if (NULL == ph)
      fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
 
    GNUNET_ATS_performance_change_preference (ph,
                                              &pid,
                                              type,
                                              (double) opt_pref_value,
                                              GNUNET_ATS_PREFERENCE_END);
 
    shutdown_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &end, NULL);
    return;
  }
  if (NULL != cpid_str)
  {
    ats_ch = GNUNET_ATS_connectivity_init (cfg);
    ats_sh = GNUNET_ATS_connectivity_suggest (ats_ch, &cpid, 1000);
    shutdown_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &end, NULL);
    return;
  }
  ret = 1;
}

References _, addresses, alh, ats_ch, ats_perf_cb(), ats_perf_mon_cb(), ats_sh, cfg, cpid, cpid_str, end(), GNUNET_ATS_connectivity_init(), GNUNET_ATS_connectivity_suggest(), GNUNET_ATS_performance_change_preference(), GNUNET_ATS_performance_init(), GNUNET_ATS_performance_list_addresses(), GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_ATS_PREFERENCE_END, GNUNET_ATS_PREFERENCE_LATENCY, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, my_cfg, opt_list_all, opt_list_used, opt_monitor, opt_pid_str, opt_pref_value, opt_print_quotas, opt_set_pref, opt_type_str, ph, pid, print_quotas(), GNUNET_PeerIdentity::public_key, ret, shutdown_task, stat_results, and type.

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.

Parameters

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

Returns

0 ok, 1 on error

Definition at line 894 of file gnunet-ats.c.

{
  int res;
 
  opt_resolve_addresses_numeric = GNUNET_NO;
  opt_monitor = GNUNET_NO;
  opt_list_all = GNUNET_NO;
  opt_list_used = GNUNET_NO;
  opt_set_pref = GNUNET_NO;
  stat_pending = 0;
  stat_receive_done = GNUNET_NO;
  opt_type_str = NULL;
 
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag ('u',
                               "used",
                               gettext_noop (
                                 "get list of active addresses currently used"),
                               &opt_list_used),
    GNUNET_GETOPT_option_flag ('a',
                               "all",
                               gettext_noop (
                                 "get list of all active addresses"),
                               &opt_list_all),
 
    GNUNET_GETOPT_option_string ('C',
                                 "connect",
                                 NULL,
                                 gettext_noop ("connect to PEER"),
                                 &cpid_str),
    GNUNET_GETOPT_option_flag ('n',
                               "numeric",
                               gettext_noop (
                                 "do not resolve IP addresses to hostnames"),
                               &opt_resolve_addresses_numeric),
 
    GNUNET_GETOPT_option_flag ('m',
                               "monitor",
                               gettext_noop ("monitor mode"),
                               &opt_monitor),
 
    GNUNET_GETOPT_option_flag ('p',
                               "preference",
                               gettext_noop (
                                 "set preference for the given peer"),
                               &opt_set_pref),
 
    GNUNET_GETOPT_option_flag ('q',
                               "quotas",
                               gettext_noop ("print all configured quotas"),
                               &opt_print_quotas),
    GNUNET_GETOPT_option_string ('i',
                                 "id",
                                 "TYPE",
                                 gettext_noop ("peer id"),
                                 &opt_pid_str),
 
    GNUNET_GETOPT_option_string ('t',
                                 "type",
                                 "TYPE",
                                 gettext_noop (
                                   "preference type to set: latency | bandwidth"),
                                 &opt_type_str),
 
    GNUNET_GETOPT_option_uint ('k',
                               "value",
                               "VALUE",
                               gettext_noop ("preference value"),
                               &opt_pref_value),
 
    GNUNET_GETOPT_option_flag (
      'V',
      "verbose",
      gettext_noop ("verbose output (include ATS address properties)"),
      &opt_verbose),
    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-ats",
                            gettext_noop ("Print information about ATS state"),
                            options,
                            &run,
                            NULL);
  GNUNET_free (opt_pid_str);
  GNUNET_free (opt_type_str);
  GNUNET_free_nz ((void *) argv);
 
  if (GNUNET_OK == res)
    return ret;
  else
    return 1;
}

References cpid_str, gettext_noop, GNUNET_free, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_NO, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), opt_list_all, opt_list_used, opt_monitor, opt_pid_str, opt_pref_value, opt_print_quotas, opt_resolve_addresses_numeric, opt_set_pref, opt_type_str, opt_verbose, options, res, ret, run(), stat_pending, and stat_receive_done.

Here is the call graph for this function:

Variable Documentation

opt_resolve_addresses_numeric

int opt_resolve_addresses_numeric

static

CLI Opt:

Definition at line 41 of file gnunet-ats.c.

Referenced by ats_perf_cb(), ats_perf_mon_cb(), and main().

opt_verbose

int opt_verbose

static

CLI Opt: Print verbose ATS information.

Definition at line 46 of file gnunet-ats.c.

Referenced by ats_perf_mon_cb(), and main().

opt_list_used

int opt_list_used

static

CLI Option: List only addresses currently used (active)

Definition at line 51 of file gnunet-ats.c.

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

opt_list_all

int opt_list_all

static

CLI Option: List all addresses.

Definition at line 56 of file gnunet-ats.c.

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

opt_set_pref

int opt_set_pref

static

CLI Option: set preference.

Definition at line 61 of file gnunet-ats.c.

Referenced by main(), and run().

opt_print_quotas

int opt_print_quotas

static

CLI Option: print quotas configured.

Definition at line 66 of file gnunet-ats.c.

Referenced by main(), and run().

opt_monitor

int opt_monitor

static

CLI Option: Monitor addresses used.

Definition at line 71 of file gnunet-ats.c.

Referenced by main(), and run().

opt_pid_str

char* opt_pid_str

static

CLI Option: use specific peer.

Definition at line 76 of file gnunet-ats.c.

Referenced by main(), and run().

opt_type_str

char* opt_type_str

static

CLI Option: preference type to set.

Definition at line 81 of file gnunet-ats.c.

Referenced by main(), and run().

opt_pref_value

unsigned int opt_pref_value

static

CLI Option: preference value to set.

Definition at line 86 of file gnunet-ats.c.

Referenced by main(), and run().

ret

int ret

static

Final status code.

Definition at line 91 of file gnunet-ats.c.

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

stat_results

int stat_results

static

Number of results returned from service.

Definition at line 96 of file gnunet-ats.c.

Referenced by ats_perf_cb(), ats_perf_mon_cb(), end(), and run().

stat_receive_done

int stat_receive_done

static

State: all pending receive operations done?

Definition at line 101 of file gnunet-ats.c.

Referenced by ats_perf_cb(), main(), and transport_addr_to_str_cb().

stat_pending

int stat_pending

static

State: number of pending operations.

Definition at line 106 of file gnunet-ats.c.

Referenced by ats_perf_cb(), ats_perf_mon_cb(), main(), and transport_addr_to_str_cb().

cpid_str

char* cpid_str

static

Which peer should we connect to?

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

Referenced by main(), and run().

ph

struct GNUNET_ATS_PerformanceHandle* ph

static

ATS performance handle used.

Definition at line 116 of file gnunet-ats.c.

Referenced by calculate_pow(), calculate_pow_shutdown(), calculate_score(), do_disconnect(), do_reconnect(), ego_callback(), end(), GDS_u_drop(), GNUNET_ATS_performance_change_preference(), GNUNET_ATS_performance_done(), GNUNET_ATS_performance_give_feedback(), GNUNET_ATS_performance_init(), GNUNET_ATS_performance_list_addresses(), GNUNET_ATS_performance_list_addresses_cancel(), GNUNET_ATS_reserve_bandwidth(), GNUNET_DHT_disconnect(), GNUNET_DHT_put(), GNUNET_DHT_put_cancel(), gnunet_drop(), gnunet_hold(), GSC_KX_encrypt_and_transmit(), handle_address_list(), handle_encrypted(), handle_peer_information(), handle_put_cont(), handle_reservation_result(), ip_drop(), ip_hold(), linux_read(), mq_error_handler(), reconnect(), reconnect_task(), run(), and run_with_key().

ats_ch

struct GNUNET_ATS_ConnectivityHandle* ats_ch

static

Our connectivity handle.

Definition at line 121 of file gnunet-ats.c.

Referenced by consider_peer_activate(), end(), and run().

ats_sh

struct GNUNET_ATS_ConnectivitySuggestHandle* ats_sh

static

Handle for address suggestion request.

Definition at line 126 of file gnunet-ats.c.

Referenced by end(), and run().

alh

struct GNUNET_ATS_AddressListHandle* alh

static

ATS address list handle used.

Definition at line 131 of file gnunet-ats.c.

Referenced by ats_perf_cb(), do_reconnect(), end(), GNUNET_ATS_performance_done(), GNUNET_ATS_performance_list_addresses(), GNUNET_ATS_performance_list_addresses_cancel(), handle_address_list(), and run().

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration handle.

Definition at line 136 of file gnunet-ats.c.

Referenced by ats_perf_cb(), ats_perf_mon_cb(), print_quotas(), and run().

shutdown_task

struct GNUNET_SCHEDULER_Task* shutdown_task

static

Shutdown task.

Definition at line 141 of file gnunet-ats.c.

Referenced by ats_perf_cb(), run(), and transport_addr_to_str_cb().

addresses

struct GNUNET_CONTAINER_MultiPeerMap* addresses

static

Hashmap to store addresses.

Definition at line 146 of file gnunet-ats.c.

Referenced by ats_perf_mon_cb(), end(), free_addr_it(), get_best_address(), plugin_env_address_change_notification(), and run().

head

struct PendingResolutions* head

static

Head of list of pending resolution requests.

Definition at line 230 of file gnunet-ats.c.

Referenced by ats_perf_cb(), ats_perf_mon_cb(), end(), GPI_plugins_find(), meminfo(), parse_pattern(), parse_recordline(), search_waiting(), select_peer(), send_msg_from_cache(), and transport_addr_to_str_cb().

tail

struct PendingResolutions* tail

static

Tail of list of pending resolution requests.

Definition at line 235 of file gnunet-ats.c.

Referenced by ats_perf_cb(), ats_perf_mon_cb(), discard_all_from_rung_tail(), end(), meminfo(), parse_pattern(), send_msg_from_cache(), sql_prepare(), and transport_addr_to_str_cb().