GNUnet  0.11.x
gnunet-ats.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009--2015 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your 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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_ats_service.h"
31 
35 #define UNLIMITED_STRING "unlimited"
36 
37 
42 
46 static int opt_verbose;
47 
51 static int opt_list_used;
52 
56 static int opt_list_all;
57 
61 static int opt_set_pref;
62 
66 static int opt_print_quotas;
67 
71 static int opt_monitor;
72 
76 static char *opt_pid_str;
77 
81 static char *opt_type_str;
82 
86 static unsigned int opt_pref_value;
87 
91 static int ret;
92 
96 static int stat_results;
97 
101 static int stat_receive_done;
102 
106 static int stat_pending;
107 
111 static char *cpid_str;
112 
117 
122 
127 
132 
137 
142 
147 
148 
155 {
160 
165 
170 
176 
181 
186 
191 
195  int active;
196 };
197 
198 
204 {
209 
214 
219 
223  int active;
224 };
225 
226 
230 static struct PendingResolutions *head;
231 
235 static struct PendingResolutions *tail;
236 
237 
246 static int
247 free_addr_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
248 {
249  struct ATSAddress *a = value;
250 
252  GNUNET_CONTAINER_multipeermap_remove (addresses, key, value));
254  GNUNET_free (a);
255  return GNUNET_OK;
256 }
257 
258 
264 static void
265 end (void *cls)
266 {
267  struct PendingResolutions *pr;
268  struct PendingResolutions *next;
269  unsigned int pending;
270 
271  if (NULL != alh)
272  {
274  alh = NULL;
275  }
276 
277  if (NULL != ph)
278  {
280  ph = NULL;
281  }
282 
283  pending = 0;
284  next = head;
285  while (NULL != (pr = next))
286  {
287  next = pr->next;
288  GNUNET_CONTAINER_DLL_remove (head, tail, pr);
290  GNUNET_free (pr->address);
291  GNUNET_free (pr);
292  pending++;
293  }
296  addresses = NULL;
297 
298  if (0 < pending)
299  fprintf (stdout, _ ("%u address resolutions had a timeout\n"), pending);
301  fprintf (stdout,
302  _ ("ATS returned stat_results for %u addresses\n"),
303  stat_results);
304 
305  if (NULL != ats_sh)
306  {
308  ats_sh = NULL;
309  }
310  if (NULL != ats_ch)
311  {
313  ats_ch = NULL;
314  }
315  ret = 0;
316 }
317 
318 
335 static void
336 transport_addr_to_str_cb (void *cls, const char *address, int res)
337 {
338  struct PendingResolutions *pr = cls;
339 
340  if (NULL == address)
341  {
342  /* We're done */
343  GNUNET_CONTAINER_DLL_remove (head, tail, pr);
344  GNUNET_free (pr->address);
345  GNUNET_free (pr);
346  stat_pending--;
347 
348  if ((GNUNET_YES == stat_receive_done) && (0 == stat_pending))
349  {
350  /* All messages received and no resolutions pending*/
351  if (shutdown_task != NULL)
352  GNUNET_SCHEDULER_cancel (shutdown_task);
353  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
354  }
355  return;
356  }
357  switch (res)
358  {
359  case GNUNET_SYSERR:
360  fprintf (
361  stderr,
362  "Failed to convert address for peer `%s' plugin `%s' length %u to string (communication error)\n",
363  GNUNET_i2s (&pr->address->peer),
364  pr->address->transport_name,
365  (unsigned int) pr->address->address_length);
366  return;
367 
368  case GNUNET_NO:
369  fprintf (
370  stderr,
371  "Failed to convert address for peer `%s' plugin `%s' length %u to string (address invalid or not supported)\n",
372  GNUNET_i2s (&pr->address->peer),
373  pr->address->transport_name,
374  (unsigned int) pr->address->address_length);
375  return;
376 
377  case GNUNET_OK:
378  /* continues below */
379  break;
380 
381  default:
382  GNUNET_break (0);
383  return;
384  }
385 
386  fprintf (
387  stdout,
388  _ (
389  "Peer `%s' plugin `%s', address `%s', `%s' bw out: %u Bytes/s, bw in %u Bytes/s, %s\n"),
390  GNUNET_i2s (&pr->address->peer),
391  pr->address->transport_name,
392  address,
394  ntohl (pr->bandwidth_out.value__),
395  ntohl (pr->bandwidth_in.value__),
396  pr->active ? _ ("active ") : _ ("inactive "));
397 }
398 
399 
404 {
408  const struct GNUNET_HELLO_Address *src;
409 
413  struct ATSAddress *res;
414 };
415 
416 
425 static int
426 find_address_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
427 {
428  struct AddressFindCtx *actx = cls;
429  struct ATSAddress *exist = value;
430 
431  if (0 == GNUNET_HELLO_address_cmp (actx->src, exist->address))
432  {
433  actx->res = exist;
434  return GNUNET_NO;
435  }
436  return GNUNET_YES;
437 }
438 
439 
453 static void
454 ats_perf_mon_cb (void *cls,
455  const struct GNUNET_HELLO_Address *address,
456  int active,
459  const struct GNUNET_ATS_Properties *prop)
460 {
461  struct PendingResolutions *pr;
462  struct PendingResolutions *cur;
463  struct PendingResolutions *next;
464 
465  if (NULL == address)
466  {
467  /* ATS service temporarily disconnected, remove current state */
468  next = head;
469  for (cur = next; NULL != cur; cur = next)
470  {
471  next = cur->next;
472  GNUNET_CONTAINER_DLL_remove (head, tail, cur);
475  GNUNET_free (cur);
476  }
478  return;
479  }
480  if (GNUNET_SYSERR == active)
481  {
482  /* remove address */
483  struct AddressFindCtx actx;
484 
485  actx.src = address;
486  actx.res = NULL;
488  &address->peer,
490  &actx);
491  if (NULL == actx.res)
492  {
493  GNUNET_break (0);
494  return;
495  }
498  &address->peer,
499  actx.res));
500  fprintf (stdout,
501  _ ("Removed address of peer `%s' with plugin `%s'\n"),
502  GNUNET_i2s (&address->peer),
503  actx.res->address->transport_name);
505  return;
506  }
507 
508  if (GNUNET_NO == opt_verbose)
509  {
510  struct AddressFindCtx actx;
511  struct ATSAddress *a;
512 
513  actx.src = address;
514  actx.res = NULL;
516  &address->peer,
518  &actx);
519  if ((NULL != actx.res))
520  {
521  if ((bandwidth_in.value__ == actx.res->bandwidth_in.value__) &&
522  (bandwidth_out.value__ == actx.res->bandwidth_out.value__) &&
523  (active == actx.res->active))
524  {
525  return; /* Nothing to do here */
526  }
527  else
528  {
529  actx.res->bandwidth_in = bandwidth_in;
531  }
532  }
533  else
534  {
535  a = GNUNET_new (struct ATSAddress);
536 
537  a->address = GNUNET_HELLO_address_copy (address);
540  a->active = active;
542  addresses,
543  &address->peer,
544  a,
546  }
547  }
548 
549  pr = GNUNET_new (struct PendingResolutions);
550  pr->properties = *prop;
551  pr->address = GNUNET_HELLO_address_copy (address);
554  pr->active = active;
556  cfg,
557  address,
561  pr);
562  GNUNET_CONTAINER_DLL_insert (head, tail, pr);
563  stat_results++;
564  stat_pending++;
565 }
566 
567 
579 static void
580 ats_perf_cb (void *cls,
581  const struct GNUNET_HELLO_Address *address,
582  int active,
585  const struct GNUNET_ATS_Properties *prop)
586 {
587  struct PendingResolutions *pr;
588 
589  if (NULL == address)
590  {
591  /* All messages received */
593  alh = NULL;
594  if (0 == stat_pending)
595  {
596  /* All messages received and no resolutions pending*/
597  if (shutdown_task != NULL)
598  GNUNET_SCHEDULER_cancel (shutdown_task);
599  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
600  }
601  return;
602  }
603 
604  pr = GNUNET_new (struct PendingResolutions);
605  pr->properties = *prop;
606  pr->address = GNUNET_HELLO_address_copy (address);
609  pr->active = active;
611  cfg,
612  address,
616  pr);
617  GNUNET_CONTAINER_DLL_insert (head, tail, pr);
618  stat_results++;
619  stat_pending++;
620 }
621 
622 
630 static unsigned int
632 {
633  char *entry_in = NULL;
634  char *entry_out = NULL;
635  char *quota_out_str;
636  char *quota_in_str;
637  unsigned long long int quota_out;
638  unsigned long long int quota_in;
639  int c;
640 
641  for (c = 0; (c < GNUNET_NT_COUNT); c++)
642  {
643  GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", GNUNET_NT_to_string (c));
644  GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", GNUNET_NT_to_string (c));
645 
646  /* quota out */
648  "ats",
649  entry_out,
650  &quota_out_str))
651  {
652  if ((0 == strcmp (quota_out_str, UNLIMITED_STRING)) ||
653  (GNUNET_SYSERR ==
654  GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, &quota_out)))
655  quota_out = UINT32_MAX;
656 
657  GNUNET_free (quota_out_str);
658  GNUNET_asprintf (&quota_out_str, "%llu", quota_out);
659  }
660  else
661  {
662  fprintf (stderr,
663  "Outbound quota for network `%11s' not configured!\n",
664  GNUNET_NT_to_string (c));
665  GNUNET_asprintf (&quota_out_str, "-");
666  }
667  GNUNET_free (entry_out);
668 
669  /* quota in */
671  "ats",
672  entry_in,
673  &quota_in_str))
674  {
675  if ((0 == strcmp (quota_in_str, UNLIMITED_STRING)) ||
676  (GNUNET_SYSERR ==
677  GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &quota_in)))
678  quota_in = UINT32_MAX;
679  GNUNET_free (quota_in_str);
680  GNUNET_asprintf (&quota_in_str, "%llu", quota_in);
681  }
682  else
683  {
684  fprintf (stderr,
685  "Inbound quota for network `%11s' not configured!\n",
686  GNUNET_NT_to_string (c));
687  GNUNET_asprintf (&quota_in_str, "-");
688  }
689  GNUNET_free (entry_in);
690 
691  fprintf (stdout,
692  _ ("Quota for network `%11s' (in/out): %10s / %10s\n"),
694  quota_in_str,
695  quota_out_str);
696  GNUNET_free (quota_out_str);
697  GNUNET_free (quota_in_str);
698  }
699  return GNUNET_NT_COUNT;
700 }
701 
702 
711 static void
712 run (void *cls,
713  char *const *args,
714  const char *cfgfile,
715  const struct GNUNET_CONFIGURATION_Handle *my_cfg)
716 {
717  struct GNUNET_PeerIdentity pid;
718  struct GNUNET_PeerIdentity cpid;
719  unsigned int c;
720  unsigned int type;
721 
722  cfg = (struct GNUNET_CONFIGURATION_Handle *) my_cfg;
724  stat_results = 0;
725 
726  c = 0;
727  if (NULL != opt_pid_str)
728  {
729  if (GNUNET_OK !=
731  strlen (opt_pid_str),
732  &pid.public_key))
733  {
734  fprintf (stderr, _ ("Failed to parse peer identity `%s'\n"), opt_pid_str);
735  return;
736  }
737  }
738  if (NULL != cpid_str)
739  {
740  if (GNUNET_OK !=
742  strlen (cpid_str),
743  &cpid.public_key))
744  {
745  fprintf (stderr, _ ("Failed to parse peer identity `%s'\n"), cpid_str);
746  return;
747  }
748  c++;
749  }
750 
752 
753  if (1 < c)
754  {
755  fprintf (stderr,
756  _ ("Please select one operation: %s or %s or %s or %s or %s\n"),
757  "--used",
758  "--all",
759  "--monitor",
760  "--preference",
761  "--quotas");
762  return;
763  }
764  if (0 == c)
765  opt_list_used = GNUNET_YES; /* set default */
766  if (opt_print_quotas)
767  {
768  ret = print_quotas (cfg);
769  return;
770  }
771  if (opt_list_all)
772  {
773  ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
774  if (NULL == ph)
775  {
776  fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
777  return;
778  }
780  (NULL == opt_pid_str) ? NULL
781  : &pid,
782  GNUNET_YES,
783  &ats_perf_cb,
784  NULL);
785  if (NULL == alh)
786  {
787  fprintf (stderr,
788  "%s",
789  _ ("Cannot issue request to ATS service, exiting...\n"));
790  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
791  return;
792  }
793  shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end, NULL);
794  return;
795  }
796  if (opt_list_used)
797  {
798  ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
799  if (NULL == ph)
800  fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
801 
803  (NULL == opt_pid_str) ? NULL
804  : &pid,
805  GNUNET_NO,
806  &ats_perf_cb,
807  NULL);
808  if (NULL == alh)
809  {
810  fprintf (stderr,
811  "%s",
812  _ ("Cannot issue request to ATS service, exiting...\n"));
813  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
814  return;
815  }
816  shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end, NULL);
817  return;
818  }
819  if (opt_monitor)
820  {
821  ph = GNUNET_ATS_performance_init (cfg, &ats_perf_mon_cb, NULL);
822  shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end, NULL);
823  if (NULL == ph)
824  {
825  fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
827  }
828  return;
829  }
830  if (opt_set_pref)
831  {
832  if (NULL == opt_type_str)
833  {
834  fprintf (stderr, "%s", _ ("No preference type given!\n"));
835  return;
836  }
837  if (NULL == opt_pid_str)
838  {
839  fprintf (stderr, "%s", _ ("No peer given!\n"));
840  return;
841  }
842 
843  for (c = 0; c < strlen (opt_type_str); c++)
844  {
845  if (isupper ((unsigned char) opt_type_str[c]))
846  opt_type_str[c] = tolower ((unsigned char) opt_type_str[c]);
847  }
848 
849  if (0 == strcasecmp ("latency", opt_type_str))
851  else if (0 == strcasecmp ("bandwidth", opt_type_str))
853  else
854  {
855  fprintf (stderr, "%s", _ ("Valid type required\n"));
856  return;
857  }
858 
859  /* set */
860  ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
861  if (NULL == ph)
862  fprintf (stderr, "%s", _ ("Cannot connect to ATS service, exiting...\n"));
863 
865  &pid,
866  type,
867  (double) opt_pref_value,
869 
870  shutdown_task =
872  return;
873  }
874  if (NULL != cpid_str)
875  {
876  ats_ch = GNUNET_ATS_connectivity_init (cfg);
877  ats_sh = GNUNET_ATS_connectivity_suggest (ats_ch, &cpid, 1000);
878  shutdown_task =
880  return;
881  }
882  ret = 1;
883 }
884 
885 
893 int
894 main (int argc, char *const *argv)
895 {
896  int res;
897 
903  stat_pending = 0;
905  opt_type_str = NULL;
906 
907  struct GNUNET_GETOPT_CommandLineOption options[] =
909  "used",
910  gettext_noop (
911  "get list of active addresses currently used"),
912  &opt_list_used),
914  "all",
915  gettext_noop (
916  "get list of all active addresses"),
917  &opt_list_all),
918 
920  "connect",
921  NULL,
922  gettext_noop ("connect to PEER"),
923  &cpid_str),
925  "numeric",
926  gettext_noop (
927  "do not resolve IP addresses to hostnames"),
929 
931  "monitor",
932  gettext_noop ("monitor mode"),
933  &opt_monitor),
934 
936  "preference",
937  gettext_noop (
938  "set preference for the given peer"),
939  &opt_set_pref),
940 
942  "quotas",
943  gettext_noop ("print all configured quotas"),
946  "id",
947  "TYPE",
948  gettext_noop ("peer id"),
949  &opt_pid_str),
950 
952  "type",
953  "TYPE",
954  gettext_noop (
955  "preference type to set: latency | bandwidth"),
956  &opt_type_str),
957 
959  "value",
960  "VALUE",
961  gettext_noop ("preference value"),
962  &opt_pref_value),
963 
965  'V',
966  "verbose",
967  gettext_noop ("verbose output (include ATS address properties)"),
968  &opt_verbose),
970 
971  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
972  return 2;
973 
974  res = GNUNET_PROGRAM_run (argc,
975  argv,
976  "gnunet-ats",
977  gettext_noop ("Print information about ATS state"),
978  options,
979  &run,
980  NULL);
983  GNUNET_free ((void *) argv);
984 
985  if (GNUNET_OK == res)
986  return ret;
987  else
988  return 1;
989 }
990 
991 
992 /* end of gnunet-ats.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Current inbound bandwidth.
Definition: gnunet-ats.c:218
static int opt_list_all
CLI Option: List all addresses.
Definition: gnunet-ats.c:56
size_t address_length
Number of bytes in address.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Amount of inbound bandwidth assigned by ATS.
Definition: gnunet-ats.c:190
static int opt_monitor
CLI Option: Monitor addresses used.
Definition: gnunet-ats.c:71
int main(int argc, char *const *argv)
The main function.
Definition: gnunet-ats.c:894
const char * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:44
int active
Is this an active address?
Definition: gnunet-ats.c:223
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static int stat_receive_done
State: all pending receive operations done?
Definition: gnunet-ats.c:101
static char * opt_type_str
CLI Option: preference type to set.
Definition: gnunet-ats.c:81
static unsigned int print_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg)
Print information about the quotas configured for the various network scopes.
Definition: gnunet-ats.c:631
static void end(void *cls)
Task run on shutdown.
Definition: gnunet-ats.c:265
Structure used to remember all pending address resolutions.
Definition: gnunet-ats.c:154
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_HELLO_Address * address
Copy of the address we are resolving.
Definition: gnunet-ats.c:169
static struct GNUNET_ATS_PerformanceHandle * ph
ATS performance handle used.
Definition: gnunet-ats.c:116
#define GNUNET_TIME_UNIT_SECONDS
One second.
static int opt_list_used
CLI Option: List only addresses currently used (active)
Definition: gnunet-ats.c:51
struct GNUNET_ATS_Properties properties
Performance data.
Definition: gnunet-ats.c:180
void GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
Client is done using the ATS performance subsystem, release resources.
struct PendingResolutions * prev
Kept in a DLL.
Definition: gnunet-ats.c:164
int GNUNET_STRINGS_fancy_size_to_bytes(const char *fancy_size, unsigned long long *size)
Convert a given fancy human-readable size to bytes.
Definition: strings.c:319
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_CONTAINER_MultiPeerMap * addresses
Hashmap to store addresses.
Definition: gnunet-ats.c:146
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.
Definition: gnunet-ats.c:712
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
static const struct GNUNET_CONFIGURATION_Handle * my_cfg
Our configuration.
Definition: gnunet-cadet.c:97
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
const struct GNUNET_HELLO_Address * src
Address we are looking for.
Definition: gnunet-ats.c:408
ATS performance characteristics for an address.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Linked list of pending reservations.
End of preference list.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
uint32_t value__
The actual value (bytes per second).
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_ATS_ConnectivitySuggestHandle * GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
We would like to receive address suggestions for a peer.
static struct GNUNET_ATS_AddressListHandle * alh
ATS address list handle used.
Definition: gnunet-ats.c:131
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.
Definition: gnunet-ats.c:454
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
static struct GNUNET_SCHEDULER_Task * shutdown_task
Shutdown task.
Definition: gnunet-ats.c:141
static int opt_set_pref
CLI Option: set preference.
Definition: gnunet-ats.c:61
struct PendingResolutions * next
Kept in a DLL.
Definition: gnunet-ats.c:159
static char * value
Value of the record to add/remove.
static unsigned int opt_pref_value
CLI Option: preference value to set.
Definition: gnunet-ats.c:86
struct GNUNET_TRANSPORT_AddressToStringContext * tats_ctx
Handle to the transport request to convert the address to a string.
Definition: gnunet-ats.c:175
void GNUNET_TRANSPORT_address_to_string_cancel(struct GNUNET_TRANSPORT_AddressToStringContext *alc)
Cancel request for address conversion.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
static int opt_resolve_addresses_numeric
CLI Opt:
Definition: gnunet-ats.c:41
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Current outbound bandwidth.
Definition: gnunet-ats.c:213
static struct GNUNET_CONFIGURATION_Handle * cfg
Configuration handle.
Definition: gnunet-ats.c:136
Handle for ATS address suggestion requests.
static int stat_results
Number of results returned from service.
Definition: gnunet-ats.c:96
static int free_addr_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Free address corresponding to a given peer.
Definition: gnunet-ats.c:247
const char * transport_name
Name of the transport plugin enabling the communication using this address.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
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.
Definition: gnunet-ats.c:580
static struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle for address suggestion request.
Definition: gnunet-ats.c:126
Internal representation of the hash map.
static int res
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
static int ret
Final status code.
Definition: gnunet-ats.c:91
#define UNLIMITED_STRING
String to respresent unlimited.
Definition: gnunet-ats.c:35
struct GNUNET_HashCode key
The key used in the DHT.
static int stat_pending
State: number of pending operations.
Definition: gnunet-ats.c:106
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static char * cpid_str
Which peer should we connect to?
Definition: gnunet-ats.c:111
struct GNUNET_TRANSPORT_AddressToStringContext * GNUNET_TRANSPORT_address_to_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HELLO_Address *address, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressToStringCallback aluc, void *aluc_cls)
Convert a binary address into a human readable address.
Change the peer&#39;s latency value to the given amount.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Amount of outbound bandwidth assigned by ATS.
Definition: gnunet-ats.c:185
static unsigned int pending
The number of queries that are outstanding.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
static char * opt_pid_str
CLI Option: use specific peer.
Definition: gnunet-ats.c:76
int active
Is this an active address?
Definition: gnunet-ats.c:195
ATS Handle to obtain and/or modify performance information.
static int find_address_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find address corresponding to a given peer.
Definition: gnunet-ats.c:426
struct ATSAddress * res
Where to write the struct ATSAddress if we found one that matches.
Definition: gnunet-ats.c:413
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change...
Allow multiple values with the same key.
struct GNUNET_ATS_PerformanceHandle * GNUNET_ATS_performance_init(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressInformationCallback addr_info_cb, void *addr_info_cb_cls)
Get handle to access performance API of the ATS subsystem.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
int GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:499
The identity of the host (wraps the signing key of the peer).
static int opt_print_quotas
CLI Option: print quotas configured.
Definition: gnunet-ats.c:66
struct GNUNET_HELLO_Address * address
Address information.
Definition: gnunet-ats.c:208
configuration data
Definition: configuration.c:85
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:230
Information we keep for an address.
Definition: gnunet-ats.c:203
void GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer,...)
Change preferences for the given peer.
An address for communicating with a peer.
static int opt_verbose
CLI Opt: Print verbose ATS information.
Definition: gnunet-ats.c:46
void GNUNET_ATS_performance_list_addresses_cancel(struct GNUNET_ATS_AddressListHandle *alh)
Cancel a pending address listing operation.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
static void transport_addr_to_str_cb(void *cls, const char *address, int res)
Function to call with a textual representation of an address.
Definition: gnunet-ats.c:336
Closure for find_address_it().
Definition: gnunet-ats.c:403
Automatic transport selection and outbound bandwidth determination.
Entry in list of pending tasks.
Definition: scheduler.c:134
Change the peer&#39;s bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
static struct PendingResolutions * tail
Tail of list of pending resolution requests.
Definition: gnunet-ats.c:235
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
struct GNUNET_ATS_AddressListHandle * GNUNET_ATS_performance_list_addresses(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int all, GNUNET_ATS_AddressInformationCallback infocb, void *infocb_cls)
Get information about addresses known to the ATS subsystem.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
Handle to the ATS subsystem for connectivity management.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_NT_COUNT
#define GNUNET_HELLO_address_free(addr)
Free an address.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
static struct GNUNET_ATS_ConnectivityHandle * ats_ch
Our connectivity handle.
Definition: gnunet-ats.c:121
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966