GNUnet  0.10.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 
227 
231 static struct PendingResolutions *head;
232 
236 static struct PendingResolutions *tail;
237 
238 
247 static int
248 free_addr_it (void *cls,
249  const struct GNUNET_PeerIdentity *key,
250  void *value)
251 {
252  struct ATSAddress *a = value;
253 
256  key,
257  value));
259  GNUNET_free (a);
260  return GNUNET_OK;
261 }
262 
263 
269 static void
270 end (void *cls)
271 {
272  struct PendingResolutions * pr;
273  struct PendingResolutions * next;
274  unsigned int pending;
275 
276  if (NULL != alh)
277  {
279  alh = NULL;
280  }
281 
282  if (NULL != ph)
283  {
285  ph = NULL;
286  }
287 
288  pending = 0;
289  next = head;
290  while (NULL != (pr = next))
291  {
292  next = pr->next;
293  GNUNET_CONTAINER_DLL_remove(head, tail, pr);
295  GNUNET_free(pr->address);
296  GNUNET_free(pr);
297  pending++;
298  }
300  &free_addr_it,
301  NULL);
303  addresses = NULL;
304 
305  if (0 < pending)
306  FPRINTF (stdout,
307  _("%u address resolutions had a timeout\n"),
308  pending);
310  FPRINTF (stdout,
311  _("ATS returned stat_results for %u addresses\n"),
312  stat_results);
313 
314  if (NULL != ats_sh)
315  {
317  ats_sh = NULL;
318  }
319  if (NULL != ats_ch)
320  {
322  ats_ch = NULL;
323  }
324  ret = 0;
325 }
326 
327 
344 static void
346  const char *address,
347  int res)
348 {
349  struct PendingResolutions *pr = cls;
350 
351  if (NULL == address)
352  {
353  /* We're done */
355  tail,
356  pr);
357  GNUNET_free (pr->address);
358  GNUNET_free (pr);
359  stat_pending--;
360 
361  if ((GNUNET_YES == stat_receive_done) && (0 == stat_pending))
362  {
363  /* All messages received and no resolutions pending*/
364  if (shutdown_task != NULL)
365  GNUNET_SCHEDULER_cancel (shutdown_task);
366  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
367  }
368  return;
369  }
370  switch (res)
371  {
372  case GNUNET_SYSERR:
373  FPRINTF (stderr,
374  "Failed to convert address for peer `%s' plugin `%s' length %u to string (communication error)\n",
375  GNUNET_i2s (&pr->address->peer),
376  pr->address->transport_name,
377  (unsigned int) pr->address->address_length);
378  return;
379  case GNUNET_NO:
380  FPRINTF (stderr,
381  "Failed to convert address for peer `%s' plugin `%s' length %u to string (address invalid or not supported)\n",
382  GNUNET_i2s (&pr->address->peer),
383  pr->address->transport_name,
384  (unsigned int) pr->address->address_length);
385  return;
386  case GNUNET_OK:
387  /* continues below */
388  break;
389  default:
390  GNUNET_break (0);
391  return;
392  }
393 
394  FPRINTF (stdout,
395  _("Peer `%s' plugin `%s', address `%s', `%s' bw out: %u Bytes/s, bw in %u Bytes/s, %s\n"),
396  GNUNET_i2s (&pr->address->peer),
397  pr->address->transport_name,
398  address,
400  ntohl (pr->bandwidth_out.value__),
401  ntohl (pr->bandwidth_in.value__),
402  pr->active ? _("active ") : _("inactive "));
403 }
404 
405 
410 {
414  const struct GNUNET_HELLO_Address *src;
415 
419  struct ATSAddress *res;
420 };
421 
422 
431 static int
432 find_address_it (void *cls,
433  const struct GNUNET_PeerIdentity *key,
434  void *value)
435 {
436  struct AddressFindCtx *actx = cls;
437  struct ATSAddress *exist = value;
438 
439  if (0 == GNUNET_HELLO_address_cmp (actx->src, exist->address))
440  {
441  actx->res = exist;
442  return GNUNET_NO;
443  }
444  return GNUNET_YES;
445 }
446 
447 
448 
462 static void
463 ats_perf_mon_cb (void *cls,
464  const struct GNUNET_HELLO_Address *address,
465  int active,
468  const struct GNUNET_ATS_Properties *prop)
469 {
470  struct PendingResolutions *pr;
471  struct PendingResolutions *cur;
472  struct PendingResolutions *next;
473 
474  if (NULL == address)
475  {
476  /* ATS service temporarily disconnected, remove current state */
477  next = head;
478  for (cur = next; NULL != cur; cur = next)
479  {
480  next = cur->next;
481  GNUNET_CONTAINER_DLL_remove (head, tail, cur);
484  GNUNET_free (cur);
485  }
487  &free_addr_it,
488  NULL);
489  return;
490  }
491  if (GNUNET_SYSERR == active)
492  {
493  /* remove address */
494  struct AddressFindCtx actx;
495 
496  actx.src = address;
497  actx.res = NULL;
499  &address->peer,
501  &actx);
502  if (NULL == actx.res)
503  {
504  GNUNET_break (0);
505  return;
506  }
509  &address->peer,
510  actx.res));
511  FPRINTF (stdout,
512  _("Removed address of peer `%s' with plugin `%s'\n"),
513  GNUNET_i2s (&address->peer),
514  actx.res->address->transport_name);
516  return;
517  }
518 
519  if (GNUNET_NO == opt_verbose)
520  {
521  struct AddressFindCtx actx;
522  struct ATSAddress *a;
523 
524  actx.src = address;
525  actx.res = NULL;
527  &address->peer,
529  &actx);
530  if ((NULL != actx.res))
531  {
532  if ((bandwidth_in.value__ == actx.res->bandwidth_in.value__) &&
533  (bandwidth_out.value__ == actx.res->bandwidth_out.value__) &&
534  (active == actx.res->active))
535  {
536  return; /* Nothing to do here */
537  }
538  else
539  {
540  actx.res->bandwidth_in = bandwidth_in;
542  }
543  }
544  else
545  {
546  a = GNUNET_new (struct ATSAddress);
547 
548  a->address = GNUNET_HELLO_address_copy(address);
551  a->active = active;
553  &address->peer,
554  a,
556  }
557  }
558 
559  pr = GNUNET_new (struct PendingResolutions);
560  pr->properties = *prop;
561  pr->address = GNUNET_HELLO_address_copy (address);
564  pr->active = active;
565  pr->tats_ctx = GNUNET_TRANSPORT_address_to_string (cfg, address,
569  pr);
570  GNUNET_CONTAINER_DLL_insert (head, tail, pr);
571  stat_results++;
572  stat_pending++;
573 }
574 
575 
587 static void
588 ats_perf_cb (void *cls,
589  const struct GNUNET_HELLO_Address *address,
590  int active,
593  const struct GNUNET_ATS_Properties *prop)
594 {
595  struct PendingResolutions *pr;
596 
597  if (NULL == address)
598  {
599  /* All messages received */
601  alh = NULL;
602  if (0 == stat_pending)
603  {
604  /* All messages received and no resolutions pending*/
605  if (shutdown_task != NULL)
606  GNUNET_SCHEDULER_cancel (shutdown_task);
607  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
608  }
609  return;
610  }
611 
612  pr = GNUNET_new (struct PendingResolutions);
613  pr->properties = *prop;
614  pr->address = GNUNET_HELLO_address_copy (address);
617  pr->active = active;
618  pr->tats_ctx = GNUNET_TRANSPORT_address_to_string (cfg, address,
622  GNUNET_CONTAINER_DLL_insert (head, tail, pr);
623  stat_results++;
624  stat_pending++;
625 }
626 
627 
635 static unsigned int
637 {
638  char * entry_in = NULL;
639  char * entry_out = NULL;
640  char * quota_out_str;
641  char * quota_in_str;
642  unsigned long long int quota_out;
643  unsigned long long int quota_in;
644  int c;
645 
646  for (c = 0; (c < GNUNET_NT_COUNT); c++)
647  {
648 
649  GNUNET_asprintf (&entry_out,
650  "%s_QUOTA_OUT",
651  GNUNET_NT_to_string (c));
652  GNUNET_asprintf (&entry_in,
653  "%s_QUOTA_IN",
654  GNUNET_NT_to_string (c));
655 
656  /* quota out */
657  if (GNUNET_OK ==
659  "ats",
660  entry_out,
661  &quota_out_str))
662  {
663  if (0 == strcmp (quota_out_str, UNLIMITED_STRING)
664  || (GNUNET_SYSERR ==
665  GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str,
666  &quota_out)))
667  quota_out = UINT32_MAX;
668 
669  GNUNET_free(quota_out_str);
670  GNUNET_asprintf (&quota_out_str, "%llu", quota_out);
671  }
672  else
673  {
674  FPRINTF (stderr,
675  "Outbound quota for network `%11s' not configured!\n",
676  GNUNET_NT_to_string (c));
677  GNUNET_asprintf (&quota_out_str, "-");
678  }
679  GNUNET_free (entry_out);
680 
681  /* quota in */
682  if (GNUNET_OK ==
684  "ats",
685  entry_in,
686  &quota_in_str))
687  {
688  if (0 == strcmp (quota_in_str, UNLIMITED_STRING)
689  || (GNUNET_SYSERR ==
690  GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &quota_in)))
691  quota_in = UINT32_MAX;
692  GNUNET_free (quota_in_str);
693  GNUNET_asprintf (&quota_in_str, "%llu", quota_in);
694  }
695  else
696  {
697  FPRINTF (stderr,
698  "Inbound quota for network `%11s' not configured!\n",
699  GNUNET_NT_to_string (c));
700  GNUNET_asprintf (&quota_in_str, "-");
701  }
702  GNUNET_free(entry_in);
703 
704  FPRINTF (stdout,
705  _("Quota for network `%11s' (in/out): %10s / %10s\n"),
707  quota_in_str,
708  quota_out_str);
709  GNUNET_free(quota_out_str);
710  GNUNET_free(quota_in_str);
711  }
712  return GNUNET_NT_COUNT;
713 }
714 
715 
724 static void
725 run (void *cls,
726  char * const *args,
727  const char *cfgfile,
728  const struct GNUNET_CONFIGURATION_Handle *my_cfg)
729 {
730  struct GNUNET_PeerIdentity pid;
731  struct GNUNET_PeerIdentity cpid;
732  unsigned int c;
733  unsigned int type;
734 
735  cfg = (struct GNUNET_CONFIGURATION_Handle *) my_cfg;
737  stat_results = 0;
738 
739  c = 0;
740  if (NULL != opt_pid_str)
741  {
742  if (GNUNET_OK !=
744  strlen (opt_pid_str),
745  &pid.public_key))
746  {
747  FPRINTF (stderr,
748  _("Failed to parse peer identity `%s'\n"),
749  opt_pid_str);
750  return;
751  }
752  }
753  if (NULL != cpid_str)
754  {
755  if (GNUNET_OK !=
757  strlen (cpid_str),
758  &cpid.public_key))
759  {
760  FPRINTF (stderr,
761  _("Failed to parse peer identity `%s'\n"),
762  cpid_str);
763  return;
764  }
765  c++;
766  }
767 
769 
770  if (1 < c)
771  {
772  FPRINTF (stderr,
773  _("Please select one operation: %s or %s or %s or %s or %s\n"),
774  "--used",
775  "--all",
776  "--monitor",
777  "--preference",
778  "--quotas");
779  return;
780  }
781  if (0 == c)
782  opt_list_used = GNUNET_YES; /* set default */
783  if (opt_print_quotas)
784  {
785  ret = print_quotas (cfg);
786  return;
787  }
788  if (opt_list_all)
789  {
790  ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
791  if (NULL == ph)
792  {
793  FPRINTF (stderr,
794  "%s",
795  _("Cannot connect to ATS service, exiting...\n"));
796  return;
797  }
799  (NULL == opt_pid_str) ? NULL : &pid,
800  GNUNET_YES,
801  &ats_perf_cb, NULL);
802  if (NULL == alh)
803  {
804  FPRINTF (stderr,
805  "%s",
806  _("Cannot issue request to ATS service, exiting...\n"));
807  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
808  return;
809  }
810  shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end,
811  NULL);
812  return;
813  }
814  if (opt_list_used)
815  {
816  ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
817  if (NULL == ph)
818  FPRINTF (stderr,
819  "%s",
820  _("Cannot connect to ATS service, exiting...\n"));
821 
823  (NULL == opt_pid_str)
824  ? NULL
825  : &pid,
826  GNUNET_NO,
827  &ats_perf_cb, NULL);
828  if (NULL == alh)
829  {
830  FPRINTF (stderr,
831  "%s",
832  _("Cannot issue request to ATS service, exiting...\n"));
833  shutdown_task = GNUNET_SCHEDULER_add_now (&end, NULL);
834  return;
835  }
836  shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end,
837  NULL);
838  return;
839  }
840  if (opt_monitor)
841  {
842  ph = GNUNET_ATS_performance_init (cfg,
844  NULL);
845  shutdown_task = GNUNET_SCHEDULER_add_shutdown (&end,
846  NULL);
847  if (NULL == ph)
848  {
849  FPRINTF (stderr,
850  "%s",
851  _("Cannot connect to ATS service, exiting...\n"));
853  }
854  return;
855  }
856  if (opt_set_pref)
857  {
858  if (NULL == opt_type_str)
859  {
860  FPRINTF (stderr,
861  "%s",
862  _("No preference type given!\n"));
863  return;
864  }
865  if (NULL == opt_pid_str)
866  {
867  FPRINTF (stderr,
868  "%s",
869  _("No peer given!\n"));
870  return;
871  }
872 
873  for (c = 0; c < strlen (opt_type_str); c++)
874  {
875  if (isupper ((unsigned char) opt_type_str[c]))
876  opt_type_str[c] = tolower ((unsigned char) opt_type_str[c]);
877  }
878 
879  if (0 == strcasecmp ("latency", opt_type_str))
881  else if (0 == strcasecmp ("bandwidth", opt_type_str))
883  else
884  {
885  FPRINTF (stderr,
886  "%s",
887  _("Valid type required\n"));
888  return;
889  }
890 
891  /* set */
892  ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
893  if (NULL == ph)
894  FPRINTF (stderr,
895  "%s",
896  _("Cannot connect to ATS service, exiting...\n"));
897 
899  &pid,
900  type,
901  (double) opt_pref_value,
903 
905  &end,
906  NULL);
907  return;
908  }
909  if (NULL != cpid_str)
910  {
911  ats_ch = GNUNET_ATS_connectivity_init (cfg);
912  ats_sh = GNUNET_ATS_connectivity_suggest (ats_ch,
913  &cpid,
914  1000);
915  shutdown_task
917  &end,
918  NULL);
919  return;
920  }
921  ret = 1;
922 }
923 
924 
932 int
933 main (int argc,
934  char * const *argv)
935 {
936  int res;
937 
943  stat_pending = 0;
945  opt_type_str = NULL;
946 
947  struct GNUNET_GETOPT_CommandLineOption options[] = {
949  "used",
950  gettext_noop ("get list of active addresses currently used"),
951  &opt_list_used),
953  "all",
954  gettext_noop ("get list of all active addresses"),
955  &opt_list_all),
956 
958  "connect",
959  NULL,
960  gettext_noop ("connect to PEER"),
961  &cpid_str),
963  "numeric",
964  gettext_noop ("do not resolve IP addresses to hostnames"),
966 
968  "monitor",
969  gettext_noop ("monitor mode"),
970  &opt_monitor),
971 
973  "preference",
974  gettext_noop ("set preference for the given peer"),
975  &opt_set_pref),
976 
978  "quotas",
979  gettext_noop ("print all configured quotas"),
982  "id",
983  "TYPE",
984  gettext_noop ("peer id"),
985  &opt_pid_str),
986 
988  "type",
989  "TYPE",
990  gettext_noop ("preference type to set: latency | bandwidth"),
991  &opt_type_str),
992 
994  "value",
995  "VALUE",
996  gettext_noop ("preference value"),
997  &opt_pref_value),
998 
1000  "verbose",
1001  gettext_noop ("verbose output (include ATS address properties)"),
1002  &opt_verbose),
1004  };
1005 
1006  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1007  return 2;
1008 
1009  res = GNUNET_PROGRAM_run (argc, argv,
1010  "gnunet-ats",
1011  gettext_noop ("Print information about ATS state"),
1012  options,
1013  &run, NULL);
1016  GNUNET_free((void *) argv);
1017 
1018  if (GNUNET_OK == res)
1019  return ret;
1020  else
1021  return 1;
1022 }
1023 
1024 /* 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:933
const char * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:43
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:636
#define FPRINTF
Definition: plibc.h:683
static void end(void *cls)
Task run on shutdown.
Definition: gnunet-ats.c:270
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:1293
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1521
#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:317
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:81
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:725
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#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:524
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:414
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:208
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:463
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:1246
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:1273
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:248
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:439
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:588
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:79
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:432
struct ATSAddress * res
Where to write the struct ATSAddress if we found one that matches.
Definition: gnunet-ats.c:419
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:501
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:231
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:345
Closure for find_address_it().
Definition: gnunet-ats.c:409
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:236
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:361
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:80
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:965