src/ats-tool/gnunet-ats.c

   1 /*
   2  This file is part of GNUnet.
   3  (C) 2009--2013 Christian Grothoff (and other contributing authors)
   4
   5  GNUnet is free software; you can redistribute it and/or modify
   6  it under the terms of the GNU General Public License as published
   7  by the Free Software Foundation; either version 3, or (at your
   8  option) any later version.
   9
  10  GNUnet is distributed in the hope that it will be useful, but
  11  WITHOUT ANY WARRANTY; without even the implied warranty of
  12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  General Public License for more details.
  14
  15  You should have received a copy of the GNU General Public License
  16  along with GNUnet; see the file COPYING.  If not, write to the
  17  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * @file ats-tool/gnunet-ats.c
  23  * @brief ATS command line tool
  24  * @author Matthias Wachs
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_ats_service.h"
  29 #include "gnunet_transport_service.h"
  30
  31 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
  32
  33 #define BIG_M_STRING "unlimited"
  34
  35 /**
  36  * Final status code.
  37  */
  38 static int ret;
  39 static int results;
  40 static int resolve_addresses_numeric;
  41 static int receive_done;
  42
  43 /**
  44  * For which peer should we change preference values?
  45  */
  46 static char *pid_str;
  47
  48 static char *type_str;
  49 static unsigned int value;
  50 static int pending;
  51
  52 /**
  53  * Print verbose ATS information
  54  */
  55 static int verbose;
  56
  57 /**
  58  * List only addresses currently used (active)
  59  */
  60 static int op_list_used;
  61
  62 /**
  63  * List all addresses
  64  */
  65 static int op_list_all;
  66
  67 /**
  68  * List all addresses
  69  */
  70 static int op_set_pref;
  71
  72 /**
  73  * Print quotas configured
  74  */
  75 static int op_print_quotas;
  76
  77 /**
  78  * Monitor addresses used
  79  */
  80 static int op_monitor;
  81
  82 static struct GNUNET_ATS_PerformanceHandle *ph;
  83
  84 static struct GNUNET_ATS_AddressListHandle *alh;
  85
  86 static struct GNUNET_CONFIGURATION_Handle *cfg;
  87
  88 static GNUNET_SCHEDULER_TaskIdentifier end_task;
  89
  90 static struct GNUNET_CONTAINER_MultiPeerMap *addresses;
  91
  92
  93 struct PendingResolutions
  94 {
  95   struct PendingResolutions *next;
  96   struct PendingResolutions *prev;
  97
  98   struct GNUNET_HELLO_Address *address;
  99   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out;
 100   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in;
 101
 102   struct GNUNET_ATS_Information *ats;
 103   uint32_t ats_count;
 104
 105   struct GNUNET_TRANSPORT_AddressToStringContext * tats_ctx;
 106 };
 107
 108 struct ATSAddress
 109 {
 110   struct GNUNET_HELLO_Address *address;
 111   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out;
 112   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in;
 113 };
 114
 115
 116
 117 static struct PendingResolutions *head;
 118
 119 static struct PendingResolutions *tail;
 120
 121 static int
 122 free_addr_it (void *cls,
 123     const struct GNUNET_PeerIdentity *key,
 124     void *value)
 125 {
 126   struct ATSAddress *a = value;
 127   GNUNET_CONTAINER_multipeermap_remove (addresses, key, a);
 128   GNUNET_HELLO_address_free (a->address);
 129   GNUNET_free (a);
 130   return GNUNET_OK;
 131 }
 132
 133 static void
 134 end(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 135 {
 136   struct PendingResolutions * pr;
 137   struct PendingResolutions * next;
 138   unsigned int pending;
 139
 140   if (NULL != alh)
 141   {
 142     GNUNET_ATS_performance_list_addresses_cancel (alh);
 143     alh = NULL;
 144   }
 145
 146   if (NULL != ph)
 147   {
 148     GNUNET_ATS_performance_done (ph);
 149     ph = NULL;
 150   }
 151
 152   pending = 0;
 153   next = head;
 154   while (NULL != (pr = next))
 155   {
 156     next = pr->next;
 157     GNUNET_CONTAINER_DLL_remove(head, tail, pr);
 158     GNUNET_TRANSPORT_address_to_string_cancel (pr->tats_ctx);
 159     GNUNET_free(pr->address);
 160     GNUNET_free(pr);
 161     pending++;
 162   }
 163
 164   GNUNET_CONTAINER_multipeermap_iterate(addresses, &free_addr_it, NULL);
 165   GNUNET_CONTAINER_multipeermap_destroy(addresses);
 166
 167   if (0 < pending)
 168     fprintf (stderr, _("%u address resolutions had a timeout\n"), pending);
 169   if (op_list_used || op_list_all)
 170     fprintf (stderr, _("ATS returned results for %u addresses\n"), results);
 171   ret = 0;
 172 }
 173
 174 static void
 175 transport_addr_to_str_cb(void *cls, const char *address)
 176 {
 177   struct PendingResolutions * pr = cls;
 178   char *ats_str;
 179   char *ats_tmp;
 180   char *ats_prop_arr[GNUNET_ATS_PropertyCount] = GNUNET_ATS_PropertyStrings;
 181   char *ats_prop_value;
 182   unsigned int c;
 183   uint32_t ats_type;
 184   uint32_t ats_value;
 185   uint32_t network;
 186
 187   if (NULL != address)
 188   {
 189     ats_str = GNUNET_strdup("");
 190     network = GNUNET_ATS_NET_UNSPECIFIED;
 191     for (c = 0; c < pr->ats_count; c++)
 192     {
 193       ats_tmp = ats_str;
 194
 195       ats_type = ntohl (pr->ats[c].type);
 196       ats_value = ntohl (pr->ats[c].value);
 197
 198       if (ats_type > GNUNET_ATS_PropertyCount)
 199       {
 200         fprintf (stderr, "Invalid ATS property type %u %u for address %s\n", ats_type, pr->ats[c].type,
 201             address);
 202         continue;
 203       }
 204
 205       switch (ats_type)
 206       {
 207       case GNUNET_ATS_NETWORK_TYPE:
 208         if (ats_value > GNUNET_ATS_NetworkTypeCount)
 209         {
 210           GNUNET_break(0);
 211           continue;
 212         }
 213         network = ats_value;
 214         GNUNET_asprintf (&ats_prop_value, "%s",
 215             GNUNET_ATS_print_network_type (ats_value));
 216         break;
 217       default:
 218         GNUNET_asprintf (&ats_prop_value, "%u", ats_value);
 219         break;
 220       }
 221       if ((verbose) && (ats_type < GNUNET_ATS_PropertyCount))
 222       {
 223         GNUNET_asprintf (&ats_str, "%s%s=%s, ", ats_tmp, ats_prop_arr[ats_type],
 224             ats_prop_value);
 225         GNUNET_free(ats_tmp);
 226       }
 227       GNUNET_free(ats_prop_value);
 228     }
 229
 230     fprintf (stderr,
 231         _("Peer `%s' plugin `%s', address `%s', `%s' bw out: %u Bytes/s, bw in %u Bytes/s, %s\n"),
 232         GNUNET_i2s (&pr->address->peer), pr->address->transport_name, address,
 233         GNUNET_ATS_print_network_type (network),
 234         ntohl (pr->bandwidth_out.value__), ntohl (pr->bandwidth_in.value__),
 235         ats_str);
 236     GNUNET_free(ats_str);
 237   }
 238   else
 239   {
 240     /* We're done */
 241     GNUNET_CONTAINER_DLL_remove(head, tail, pr);
 242     GNUNET_free(pr->address);
 243     GNUNET_free(pr);
 244     pending--;
 245
 246     if ((GNUNET_YES == receive_done) && (0 == pending))
 247     {
 248       /* All messages received and no resolutions pending*/
 249       if (end_task != GNUNET_SCHEDULER_NO_TASK )
 250         GNUNET_SCHEDULER_cancel (end_task);
 251       end_task = GNUNET_SCHEDULER_add_now (end, NULL );
 252     }
 253   }
 254 }
 255
 256
 257 struct AddressFindCtx
 258 {
 259   const struct GNUNET_HELLO_Address *src;
 260   struct ATSAddress *res;
 261 };
 262
 263 static int
 264 find_address_it (void *cls,
 265     const struct GNUNET_PeerIdentity *key,
 266     void *value)
 267 {
 268   struct AddressFindCtx *actx = cls;
 269   struct ATSAddress *exist = value;
 270
 271   if (0 == GNUNET_HELLO_address_cmp (actx->src, exist->address))
 272   {
 273     actx->res = exist;
 274     return GNUNET_NO;
 275   }
 276
 277   return GNUNET_YES;
 278 }
 279
 280 static void
 281 ats_perf_cb(void *cls, const struct GNUNET_HELLO_Address *address, int active,
 282     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 283     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
 284     const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 285 {
 286   struct PendingResolutions * pr;
 287
 288   if ((GNUNET_YES == op_monitor) && (GNUNET_NO == verbose))
 289   {
 290     struct AddressFindCtx actx;
 291
 292     actx.src = address;
 293     actx.res = NULL;
 294
 295     GNUNET_CONTAINER_multipeermap_iterate (addresses, find_address_it, &actx);
 296     if ((actx.res != NULL))
 297     {
 298       if ((bandwidth_in.value__ == actx.res->bandwidth_in.value__) &&
 299           (bandwidth_out.value__ == actx.res->bandwidth_out.value__) )
 300       {
 301         return; /* Nothing to do here */
 302       }
 303       else
 304       {
 305         actx.res->bandwidth_in = bandwidth_in;
 306         actx.res->bandwidth_out = bandwidth_out;
 307       }
 308     }
 309
 310     struct ATSAddress *a = GNUNET_new (struct ATSAddress);
 311     a->address = GNUNET_HELLO_address_copy(address);
 312     a->bandwidth_in = bandwidth_in;
 313     a->bandwidth_out = bandwidth_out;
 314     GNUNET_CONTAINER_multipeermap_put (addresses, &address->peer, a,
 315         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 316   }
 317
 318   if (NULL != address)
 319   {
 320     pr = GNUNET_malloc (sizeof (struct PendingResolutions) +
 321         ats_count * sizeof (struct GNUNET_ATS_Information));
 322
 323     pr->ats_count = ats_count;
 324     pr->ats = (struct GNUNET_ATS_Information *) &pr[1];
 325     if (ats_count > 0)
 326       memcpy (pr->ats, ats, ats_count * sizeof(struct GNUNET_ATS_Information));
 327     pr->address = GNUNET_HELLO_address_copy (address);
 328     pr->bandwidth_in = bandwidth_in;
 329     pr->bandwidth_out = bandwidth_out;
 330     pr->tats_ctx = GNUNET_TRANSPORT_address_to_string (cfg, address,
 331         resolve_addresses_numeric,
 332         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
 333         transport_addr_to_str_cb, pr);
 334     GNUNET_CONTAINER_DLL_insert(head, tail, pr);
 335     results++;
 336     pending++;
 337   }
 338   else
 339   {
 340     /* All messages received */
 341     receive_done = GNUNET_YES;
 342     alh = NULL;
 343     if (0 == pending)
 344     {
 345       /* All messages received and no resolutions pending*/
 346       if (end_task != GNUNET_SCHEDULER_NO_TASK )
 347         GNUNET_SCHEDULER_cancel (end_task);
 348       end_task = GNUNET_SCHEDULER_add_now (end, NULL );
 349     }
 350   }
 351 }
 352
 353 static unsigned int
 354 print_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg)
 355 {
 356   char *network_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
 357   char * entry_in = NULL;
 358   char * entry_out = NULL;
 359   char * quota_out_str;
 360   char * quota_in_str;
 361   unsigned long long int quota_out;
 362   unsigned long long int quota_in;
 363   int c;
 364
 365   for (c = 0; (c < GNUNET_ATS_NetworkTypeCount); c++)
 366   {
 367
 368     GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", network_str[c]);
 369     GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", network_str[c]);
 370
 371     /* quota out */
 372     if (GNUNET_OK
 373         == GNUNET_CONFIGURATION_get_value_string (cfg, "ats", entry_out,
 374             &quota_out_str))
 375     {
 376       if (0 == strcmp (quota_out_str, BIG_M_STRING)
 377           || (GNUNET_SYSERR
 378               == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, &quota_out)))
 379         quota_out = UINT32_MAX;
 380
 381       GNUNET_free(quota_out_str);
 382       GNUNET_asprintf (&quota_out_str, "%llu", quota_out);
 383     }
 384     else
 385     {
 386       fprintf (stderr, "Outbound quota for network `%11s' not configured!\n",
 387           network_str[c]);
 388       GNUNET_asprintf (&quota_out_str, "-");
 389     }
 390     GNUNET_free(entry_out);
 391
 392     /* quota in */
 393     if (GNUNET_OK
 394         == GNUNET_CONFIGURATION_get_value_string (cfg, "ats", entry_in,
 395             &quota_in_str))
 396     {
 397       if (0 == strcmp (quota_in_str, BIG_M_STRING)
 398           || (GNUNET_SYSERR
 399               == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &quota_in)))
 400         quota_in = UINT32_MAX;
 401       GNUNET_free(quota_in_str);
 402       GNUNET_asprintf (&quota_in_str, "%llu", quota_in);
 403     }
 404     else
 405     {
 406       fprintf (stderr, "Inbound quota for network `%11s' not configured!\n",
 407           network_str[c]);
 408       GNUNET_asprintf (&quota_in_str, "-");
 409     }
 410     GNUNET_free(entry_in);
 411
 412     fprintf (stderr, _("Quota for network `%11s' (in/out): %10s / %10s\n"),
 413         network_str[c], quota_in_str, quota_out_str);
 414     GNUNET_free(quota_out_str);
 415     GNUNET_free(quota_in_str);
 416   }
 417   return GNUNET_ATS_NetworkTypeCount;
 418 }
 419
 420 static void
 421 testservice_ats(void *cls, int result)
 422 {
 423   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 424   struct GNUNET_PeerIdentity pid;
 425   unsigned int c;
 426   unsigned int type;
 427
 428   addresses = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_YES);
 429
 430   if (GNUNET_YES != result)
 431   {
 432     FPRINTF (stderr, _("Service `%s' is not running\n"), "ats");
 433     return;
 434   }
 435
 436   results = 0;
 437
 438   if (NULL != pid_str)
 439   {
 440     if (GNUNET_OK
 441         != GNUNET_CRYPTO_eddsa_public_key_from_string (pid_str,
 442             strlen (pid_str), &pid.public_key))
 443     {
 444       FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), pid_str);
 445       return;
 446     }
 447   }
 448
 449   c = op_list_all + op_list_used + op_monitor + op_set_pref;
 450   if ((1 < c))
 451   {
 452     FPRINTF (stderr,
 453         _("Please select one operation : %s or %s or %s or %s or %s\n"),
 454         "--used", "--all", "--monitor", "--preference", "--quotas");
 455     return;
 456   }
 457   if ((0 == c))
 458     op_list_used = GNUNET_YES; /* set default */
 459   if (op_print_quotas)
 460   {
 461     ret = print_quotas (cfg);
 462     return;
 463   }
 464   if (op_list_all)
 465   {
 466     ph = GNUNET_ATS_performance_init (cfg, NULL, NULL );
 467     if (NULL == ph)
 468     {
 469       fprintf (stderr, _("Cannot connect to ATS service, exiting...\n") );
 470       return;
 471     }
 472
 473     alh = GNUNET_ATS_performance_list_addresses (ph,
 474         (NULL == pid_str) ? NULL : &pid, GNUNET_YES, ats_perf_cb, NULL );
 475     if (NULL == alh)
 476     {
 477       fprintf (stderr, _("Cannot issue request to ATS service, exiting...\n") );
 478       end_task = GNUNET_SCHEDULER_add_now (&end, NULL );
 479       return;
 480     }
 481     end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end,
 482         NULL );
 483   }
 484   else if (op_list_used)
 485   {
 486     ph = GNUNET_ATS_performance_init (cfg, NULL, NULL );
 487     if (NULL == ph)
 488       fprintf (stderr, _("Cannot connect to ATS service, exiting...\n") );
 489
 490     alh = GNUNET_ATS_performance_list_addresses (ph,
 491         (NULL == pid_str) ? NULL : &pid, GNUNET_NO, ats_perf_cb, NULL );
 492     if (NULL == alh)
 493     {
 494       fprintf (stderr, _("Cannot issue request to ATS service, exiting...\n") );
 495       end_task = GNUNET_SCHEDULER_add_now (&end, NULL );
 496       return;
 497     }
 498     end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end,
 499         NULL );
 500   }
 501   else if (op_monitor)
 502   {
 503     ph = GNUNET_ATS_performance_init (cfg, &ats_perf_cb, NULL );
 504     if (NULL == ph)
 505       fprintf (stderr, _("Cannot connect to ATS service, exiting...\n") );
 506     end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end,
 507         NULL );
 508
 509   }
 510   else if (op_set_pref)
 511   {
 512     if (NULL == type_str)
 513     {
 514       fprintf (stderr, _("No preference type given!\n") );
 515       return;
 516     }
 517     if (NULL == pid_str)
 518     {
 519       fprintf (stderr, _("No peer given!\n") );
 520       return;
 521     }
 522
 523     for (c = 0; c < strlen (type_str); c++)
 524     {
 525       if (isupper (type_str[c]))
 526         type_str[c] = tolower (type_str[c]);
 527     }
 528
 529     if (0 == strcasecmp ("latency", type_str))
 530       type = GNUNET_ATS_PREFERENCE_LATENCY;
 531     else if (0 == strcasecmp ("bandwidth", type_str))
 532       type = GNUNET_ATS_PREFERENCE_BANDWIDTH;
 533     else
 534     {
 535       FPRINTF (stderr, "%s", _("Valid type required\n") );
 536       return;
 537     }
 538
 539     /* set */
 540     ph = GNUNET_ATS_performance_init (cfg, NULL, NULL );
 541     if (NULL == ph)
 542       fprintf (stderr, _("Cannot connect to ATS service, exiting...\n") );
 543
 544     GNUNET_ATS_performance_change_preference (ph, &pid, type, (double) value,
 545         GNUNET_ATS_PREFERENCE_END);
 546
 547     end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &end,
 548         NULL );
 549   }
 550   ret = 1;
 551 }
 552
 553 /**
 554  * Main function that will be run by the scheduler.
 555  *
 556  * @param cls closure
 557  * @param args remaining command-line arguments
 558  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 559  * @param my_cfg configuration
 560  */
 561 static void
 562 run(void *cls, char * const *args, const char *cfgfile,
 563     const struct GNUNET_CONFIGURATION_Handle *my_cfg)
 564 {
 565   cfg = (struct GNUNET_CONFIGURATION_Handle *) my_cfg;
 566   GNUNET_CLIENT_service_test ("ats", cfg, TIMEOUT, &testservice_ats,
 567       (void *) cfg);
 568 }
 569
 570 /**
 571  * The main function.
 572  *
 573  * @param argc number of arguments from the command line
 574  * @param argv command line arguments
 575  * @return 0 ok, 1 on error
 576  */
 577 int
 578 main(int argc, char * const *argv)
 579 {
 580   int res;
 581   resolve_addresses_numeric = GNUNET_NO;
 582   op_monitor = GNUNET_NO;
 583   op_list_all = GNUNET_NO;
 584   op_list_used = GNUNET_NO;
 585   op_set_pref = GNUNET_NO;
 586   pending = 0;
 587   receive_done = GNUNET_NO;
 588   type_str = NULL;
 589
 590   static const struct GNUNET_GETOPT_CommandLineOption options[] =
 591   {
 592   { 'u', "used", NULL,
 593       gettext_noop ("get list of active addresses currently used"), 0,
 594       &GNUNET_GETOPT_set_one, &op_list_used },
 595   { 'a', "all", NULL, gettext_noop ("get list of all active addresses"), 0,
 596       &GNUNET_GETOPT_set_one, &op_list_all },
 597   { 'n', "numeric", NULL,
 598       gettext_noop ("do not resolve IP addresses to hostnames"), 0,
 599       &GNUNET_GETOPT_set_one, &resolve_addresses_numeric },
 600   { 'm', "monitor", NULL, gettext_noop ("monitor mode"), 0,
 601       &GNUNET_GETOPT_set_one, &op_monitor },
 602   { 'p', "preference", NULL, gettext_noop ("set preference for the given peer"),
 603       0, &GNUNET_GETOPT_set_one, &op_set_pref },
 604   { 'q', "quotas", NULL, gettext_noop ("print all configured quotas"), 0,
 605       &GNUNET_GETOPT_set_one, &op_print_quotas },
 606   { 'i', "id", "TYPE", gettext_noop ("peer id"), 1, &GNUNET_GETOPT_set_string,
 607       &pid_str },
 608   { 't', "type", "TYPE",
 609       gettext_noop ("preference type to set: latency | bandwidth"), 1,
 610       &GNUNET_GETOPT_set_string, &type_str },
 611   { 'k', "value", "VALUE", gettext_noop ("preference value"), 1,
 612       &GNUNET_GETOPT_set_uint, &value },
 613   { 'V', "verbose", NULL,
 614       gettext_noop ("verbose output (include ATS address properties)"), 0,
 615       &GNUNET_GETOPT_set_one, &verbose }, GNUNET_GETOPT_OPTION_END };
 616
 617   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 618     return 2;
 619
 620   res = GNUNET_PROGRAM_run (argc, argv, "gnunet-ats",
 621       gettext_noop ("Print information about ATS state"), options, &run, NULL );
 622   GNUNET_free_non_null(pid_str);
 623   GNUNET_free_non_null(type_str);
 624   GNUNET_free((void * ) argv);
 625
 626   if (GNUNET_OK == res)
 627     return ret;
 628   else
 629     return 1;
 630
 631 }
 632
 633 /* end of gnunet-ats.c */