/*
This file is part of GNUnet.
- (C) 2009--2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009--2015 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* @file ats-tool/gnunet-ats.c
* @brief ATS command line tool
* @author Matthias Wachs
+ * @author Christian Grothoff
*/
#include "platform.h"
#include "gnunet_util_lib.h"
*/
static unsigned int opt_pref_value;
-
-
/**
* Final status code.
*/
*/
static int stat_pending;
+/**
+ * Which peer should we connect to?
+ */
+static char *cpid_str;
+
/**
* ATS performance handle used
*/
static struct GNUNET_ATS_PerformanceHandle *ph;
+/**
+ * Our connectivity handle.
+ */
+static struct GNUNET_ATS_ConnectivityHandle *ats_ch;
+
+/**
+ * Handle for address suggestion request.
+ */
+static struct GNUNET_ATS_ConnectivitySuggestHandle *ats_sh;
+
/**
* ATS address list handle used
*/
/**
* Shutdown task
*/
-static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
+static struct GNUNET_SCHEDULER_Task *shutdown_task;
/**
* Hashmap to store addresses
struct GNUNET_TRANSPORT_AddressToStringContext *tats_ctx;
/**
- * Array of performance data.
- */
- struct GNUNET_ATS_Information *ats;
-
- /**
- * Length of the @e ats array.
+ * Performance data.
*/
- uint32_t ats_count;
+ struct GNUNET_ATS_Properties properties;
/**
* Amount of outbound bandwidth assigned by ATS.
void *value)
{
struct ATSAddress *a = value;
- GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (addresses, key, value));
+
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_multipeermap_remove (addresses,
+ key,
+ value));
GNUNET_HELLO_address_free (a->address);
GNUNET_free (a);
return GNUNET_OK;
* Task run on shutdown.
*
* @param cls NULL
- * @param tc scheduler context
*/
static void
-end (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+end (void *cls)
{
struct PendingResolutions * pr;
struct PendingResolutions * next;
addresses = NULL;
if (0 < pending)
- FPRINTF (stderr,
+ FPRINTF (stdout,
_("%u address resolutions had a timeout\n"),
pending);
if (opt_list_used || opt_list_all)
- FPRINTF (stderr,
+ 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;
}
int res)
{
struct PendingResolutions *pr = cls;
- char *ats_str;
- char *ats_tmp;
- char *ats_prop_arr[GNUNET_ATS_PropertyCount] = GNUNET_ATS_PropertyStrings;
- char *ats_prop_value;
- unsigned int c;
- uint32_t ats_type;
- uint32_t ats_value;
- uint32_t network;
if (NULL == address)
{
/* We're done */
- GNUNET_CONTAINER_DLL_remove(head, tail, pr);
- GNUNET_free(pr->address);
- GNUNET_free(pr);
+ 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 != GNUNET_SCHEDULER_NO_TASK)
+ if (shutdown_task != NULL)
GNUNET_SCHEDULER_cancel (shutdown_task);
- shutdown_task = GNUNET_SCHEDULER_add_now (end, NULL);
+ shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
}
return;
}
return;
}
- ats_str = GNUNET_strdup (pr->active ? _("active ") : _("inactive "));
- network = GNUNET_ATS_NET_UNSPECIFIED;
- for (c = 0; c < pr->ats_count; c++)
- {
- ats_tmp = ats_str;
-
- ats_type = ntohl (pr->ats[c].type);
- ats_value = ntohl (pr->ats[c].value);
-
- if (ats_type > GNUNET_ATS_PropertyCount)
- {
- FPRINTF (stderr,
- "Invalid ATS property type %u %u for address %s\n",
- ats_type,
- pr->ats[c].type,
- address);
- continue;
- }
-
- switch (ats_type)
- {
- case GNUNET_ATS_NETWORK_TYPE:
- if (ats_value > GNUNET_ATS_NetworkTypeCount)
- {
- GNUNET_break(0);
- continue;
- }
- network = ats_value;
- GNUNET_asprintf (&ats_prop_value,
- "%s",
- GNUNET_ATS_print_network_type (ats_value));
- break;
- default:
- GNUNET_asprintf (&ats_prop_value, "%u", ats_value);
- break;
- }
- if ((opt_verbose) && (ats_type < GNUNET_ATS_PropertyCount))
- {
- GNUNET_asprintf (&ats_str,
- "%s%s=%s, ",
- ats_tmp,
- ats_prop_arr[ats_type],
- ats_prop_value);
- GNUNET_free(ats_tmp);
- }
- GNUNET_free(ats_prop_value);
- }
-
- FPRINTF (stderr,
+ 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_ATS_print_network_type (network),
+ GNUNET_ATS_print_network_type (pr->properties.scope),
ntohl (pr->bandwidth_out.value__),
ntohl (pr->bandwidth_in.value__),
- ats_str);
- GNUNET_free (ats_str);
+ pr->active ? _("active ") : _("inactive "));
}
* #GNUNET_SYSERR if this address is no longer available for ATS
* @param bandwidth_out assigned outbound bandwidth for the connection
* @param bandwidth_in assigned inbound bandwidth for the connection
- * @param ats performance data for the address (as far as known)
- * @param ats_count number of performance records in @a ats
+ * @param prop performance data for the address (as far as known)
*/
static void
ats_perf_mon_cb (void *cls,
int active,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ const struct GNUNET_ATS_Properties *prop)
{
struct PendingResolutions *pr;
struct PendingResolutions *cur;
GNUNET_HELLO_address_free (cur->address);
GNUNET_free (cur);
}
-
GNUNET_CONTAINER_multipeermap_iterate (addresses,
&free_addr_it,
NULL);
actx.src = address;
actx.res = NULL;
- GNUNET_CONTAINER_multipeermap_get_multiple (addresses, &address->peer,
- &find_address_it, &actx);
+ 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 (stderr,
+ 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);
actx.src = address;
actx.res = NULL;
- GNUNET_CONTAINER_multipeermap_get_multiple (addresses, &address->peer,
- &find_address_it, &actx);
+ 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__) &&
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);
+ GNUNET_CONTAINER_multipeermap_put (addresses,
+ &address->peer,
+ a,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
}
}
- pr = GNUNET_malloc (sizeof (struct PendingResolutions) +
- ats_count * sizeof (struct GNUNET_ATS_Information));
-
- pr->ats_count = ats_count;
- pr->ats = (struct GNUNET_ATS_Information *) &pr[1];
- if (ats_count > 0)
- memcpy (pr->ats, ats, ats_count * sizeof(struct GNUNET_ATS_Information));
+ 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;
to a peer
* @param bandwidth_out assigned outbound bandwidth for the connection
* @param bandwidth_in assigned inbound bandwidth for the connection
- * @param ats performance data for the address (as far as known)
- * @param ats_count number of performance records in @a ats
+ * @param prop performance data for the address (as far as known)
*/
static void
ats_perf_cb (void *cls,
int active,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ const struct GNUNET_ATS_Properties *prop)
{
struct PendingResolutions *pr;
if (0 == stat_pending)
{
/* All messages received and no resolutions pending*/
- if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
+ if (shutdown_task != NULL)
GNUNET_SCHEDULER_cancel (shutdown_task);
- shutdown_task = GNUNET_SCHEDULER_add_now (end, NULL);
+ shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
}
return;
}
- pr = GNUNET_malloc (sizeof (struct PendingResolutions) +
- ats_count * sizeof (struct GNUNET_ATS_Information));
-
- pr->ats_count = ats_count;
- pr->ats = (struct GNUNET_ATS_Information *) &pr[1];
- if (ats_count > 0)
- memcpy (pr->ats, ats, ats_count * sizeof(struct GNUNET_ATS_Information));
+ 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;
static unsigned int
print_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- char *network_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
char * entry_in = NULL;
char * entry_out = NULL;
char * quota_out_str;
GNUNET_asprintf (&entry_out,
"%s_QUOTA_OUT",
- network_str[c]);
+ GNUNET_ATS_print_network_type (c));
GNUNET_asprintf (&entry_in,
"%s_QUOTA_IN",
- network_str[c]);
+ GNUNET_ATS_print_network_type (c));
/* quota out */
if (GNUNET_OK ==
{
FPRINTF (stderr,
"Outbound quota for network `%11s' not configured!\n",
- network_str[c]);
+ GNUNET_ATS_print_network_type (c));
GNUNET_asprintf ("a_out_str, "-");
}
- GNUNET_free(entry_out);
+ GNUNET_free (entry_out);
/* quota in */
if (GNUNET_OK ==
|| (GNUNET_SYSERR ==
GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, "a_in)))
quota_in = UINT32_MAX;
- GNUNET_free(quota_in_str);
+ GNUNET_free (quota_in_str);
GNUNET_asprintf ("a_in_str, "%llu", quota_in);
}
else
{
FPRINTF (stderr,
"Inbound quota for network `%11s' not configured!\n",
- network_str[c]);
+ GNUNET_ATS_print_network_type (c));
GNUNET_asprintf ("a_in_str, "-");
}
GNUNET_free(entry_in);
- FPRINTF (stderr,
+ FPRINTF (stdout,
_("Quota for network `%11s' (in/out): %10s / %10s\n"),
- network_str[c],
+ GNUNET_ATS_print_network_type (c),
quota_in_str,
quota_out_str);
GNUNET_free(quota_out_str);
/**
- * Function called with the result from the test if ATS is
- * running. Runs the actual main logic.
+ * Main function that will be run by the scheduler.
*
- * @param cls the `struct GNUNET_CONFIGURATION_Handle *`
- * @param result result of the test, #GNUNET_YES if ATS is running
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param my_cfg configuration
*/
static void
-testservice_ats (void *cls,
- int result)
+run (void *cls,
+ char * const *args,
+ const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *my_cfg)
{
- struct GNUNET_CONFIGURATION_Handle *cfg = cls;
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);
-
- if (GNUNET_YES != result)
- {
- FPRINTF (stderr,
- _("Service `%s' is not running\n"),
- "ats");
- return;
- }
-
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))
+ 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"),
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;
- c = opt_list_all + opt_list_used + opt_monitor + opt_set_pref;
- if ((1 < c))
+ if (1 < c)
{
FPRINTF (stderr,
- _("Please select one operation : %s or %s or %s or %s or %s\n"),
+ _("Please select one operation: %s or %s or %s or %s or %s\n"),
"--used",
"--all",
"--monitor",
"--quotas");
return;
}
- if ((0 == c))
+ if (0 == c)
opt_list_used = GNUNET_YES; /* set default */
if (opt_print_quotas)
{
_("Cannot connect to ATS service, exiting...\n"));
return;
}
-
alh = GNUNET_ATS_performance_list_addresses (ph,
(NULL == opt_pid_str) ? NULL : &pid,
GNUNET_YES,
shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
return;
}
- shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &end,
- NULL);
+ shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end,
+ NULL);
+ return;
}
- else if (opt_list_used)
+ if (opt_list_used)
{
ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (NULL == ph)
shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
return;
}
- shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &end,
- NULL);
+ shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end,
+ NULL);
+ return;
}
- else if (opt_monitor)
+ 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"));
- shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &end,
- NULL);
-
+ GNUNET_SCHEDULER_shutdown ();
+ }
+ return;
}
- else if (opt_set_pref)
+ if (opt_set_pref)
{
if (NULL == opt_type_str)
{
"%s",
_("Cannot connect to ATS service, exiting...\n"));
- GNUNET_ATS_performance_change_preference (ph, &pid, type, (double) opt_pref_value,
+ 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);
+ &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;
}
-/**
- * Main function that will be run by the scheduler.
- *
- * @param cls closure
- * @param args remaining command-line arguments
- * @param cfgfile name of the configuration file used (for saving, can be NULL!)
- * @param my_cfg configuration
- */
-static void
-run (void *cls,
- char * const *args,
- const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *my_cfg)
-{
- cfg = (struct GNUNET_CONFIGURATION_Handle *) my_cfg;
- GNUNET_CLIENT_service_test ("ats", cfg,
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
- &testservice_ats, (void *) cfg);
-}
-
-
/**
* The main function.
*
stat_receive_done = GNUNET_NO;
opt_type_str = NULL;
- static const struct GNUNET_GETOPT_CommandLineOption options[] =
- {
- { 'u', "used", NULL,
- gettext_noop ("get list of active addresses currently used"), 0,
- &GNUNET_GETOPT_set_one, &opt_list_used },
- { 'a', "all", NULL, gettext_noop ("get list of all active addresses"), 0,
- &GNUNET_GETOPT_set_one, &opt_list_all },
- { 'n', "numeric", NULL,
- gettext_noop ("do not resolve IP addresses to hostnames"), 0,
- &GNUNET_GETOPT_set_one, &opt_resolve_addresses_numeric },
- { 'm', "monitor", NULL, gettext_noop ("monitor mode"), 0,
- &GNUNET_GETOPT_set_one, &opt_monitor },
- { 'p', "preference", NULL, gettext_noop ("set preference for the given peer"),
- 0, &GNUNET_GETOPT_set_one, &opt_set_pref },
- { 'q', "quotas", NULL, gettext_noop ("print all configured quotas"), 0,
- &GNUNET_GETOPT_set_one, &opt_print_quotas },
- { 'i', "id", "TYPE", gettext_noop ("peer id"), 1, &GNUNET_GETOPT_set_string,
- &opt_pid_str },
- { 't', "type", "TYPE",
- gettext_noop ("preference type to set: latency | bandwidth"), 1,
- &GNUNET_GETOPT_set_string, &opt_type_str },
- { 'k', "value", "VALUE", gettext_noop ("preference value"), 1,
- &GNUNET_GETOPT_set_uint, &opt_pref_value },
- { 'V', "verbose", NULL,
- gettext_noop ("verbose output (include ATS address properties)"), 0,
- &GNUNET_GETOPT_set_one, &opt_verbose }, GNUNET_GETOPT_OPTION_END };
+ 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",
+ res = GNUNET_PROGRAM_run (argc, argv,
+ "gnunet-ats",
gettext_noop ("Print information about ATS state"),
options,
&run, NULL);
return ret;
else
return 1;
-
}
/* end of gnunet-ats.c */
projects / oweals / gnunet.git / blobdiff