GNUnet  0.17.6
gnunet-service-ats_addresses.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2011-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"
32 
33 
38 
39 
43 static void
45 {
47  "# addresses",
49  GNUNET_NO);
50 }
51 
52 
58 static void
59 free_address (struct ATS_Address *addr)
60 {
63  &addr->peer,
64  addr));
68  addr->plugin,
69  addr->addr,
70  addr->addr_len,
71  GNUNET_NO,
72  NULL,
73  addr->local_address_info,
76  GNUNET_free (addr->plugin);
77  GNUNET_free (addr);
78 }
79 
80 
86 static void
88 {
89  unsigned int c;
90 
91  for (c = 0; c < GAS_normalization_queue_length; c++)
92  norm->atsi_abs[c] = UINT64_MAX;
93 }
94 
95 
107 static struct ATS_Address *
109  const char *plugin_name,
110  const void *plugin_addr,
111  size_t plugin_addr_len,
112  uint32_t local_address_info,
113  uint32_t session_id)
114 {
115  struct ATS_Address *aa;
116 
117  aa = GNUNET_malloc (sizeof(struct ATS_Address) + plugin_addr_len);
118  aa->peer = *peer;
119  aa->addr_len = plugin_addr_len;
120  aa->addr = &aa[1];
121  GNUNET_memcpy (&aa[1],
122  plugin_addr,
123  plugin_addr_len);
125  aa->session_id = session_id;
127  init_norm (&aa->norm_delay);
128  init_norm (&aa->norm_distance);
131  return aa;
132 }
133 
134 
139 {
143  uint32_t session_id;
144 
149 };
150 
151 
160 static int
161 find_address_cb (void *cls,
162  const struct GNUNET_PeerIdentity *key,
163  void *value)
164 {
165  struct FindAddressContext *fac = cls;
166  struct ATS_Address *aa = value;
167 
168  if (aa->session_id == fac->session_id)
169  {
170  fac->exact_address = aa;
171  return GNUNET_NO;
172  }
173  return GNUNET_YES;
174 }
175 
176 
184 static struct ATS_Address *
186  uint32_t session_id)
187 {
188  struct FindAddressContext fac;
189 
190  fac.exact_address = NULL;
191  fac.session_id = session_id;
193  peer,
194  &find_address_cb, &fac);
195  return fac.exact_address;
196 }
197 
198 
199 void
201  const char *plugin_name,
202  const void *plugin_addr,
203  size_t plugin_addr_len,
204  uint32_t local_address_info,
205  uint32_t session_id,
206  const struct GNUNET_ATS_Properties *prop)
207 {
208  struct ATS_Address *new_address;
209 
210  if (NULL != find_exact_address (peer,
211  session_id))
212  {
213  GNUNET_break (0);
214  return;
215  }
217  new_address = create_address (peer,
218  plugin_name,
219  plugin_addr,
220  plugin_addr_len,
222  session_id);
223  /* Add a new address */
224  new_address->properties = *prop;
225  new_address->t_added = GNUNET_TIME_absolute_get ();
226  new_address->t_last_activity = GNUNET_TIME_absolute_get ();
229  peer,
230  new_address,
234  "Adding new address for peer `%s' slot %u\n",
235  GNUNET_i2s (peer),
236  session_id);
237  /* Tell solver about new address */
239  GAS_plugin_new_address (new_address);
240  GAS_normalization_update_property (new_address); // FIXME: needed?
242  /* Notify performance clients about new address */
244  new_address->plugin,
245  new_address->addr,
246  new_address->addr_len,
247  new_address->active,
248  &new_address->properties,
249  new_address->local_address_info,
251  new_address->assigned_bw_out),
253  new_address->assigned_bw_in));
254 }
255 
256 
257 void
259  uint32_t session_id,
260  const struct GNUNET_ATS_Properties *prop)
261 {
262  struct ATS_Address *aa;
263 
264  /* Get existing address */
265  aa = find_exact_address (peer,
266  session_id);
267  if (NULL == aa)
268  {
269  GNUNET_break (0);
270  return;
271  }
272  if (NULL == aa->solver_information)
273  {
274  GNUNET_break (0);
275  return;
276  }
278  "Received ADDRESS_UPDATE for peer `%s' slot %u\n",
279  GNUNET_i2s (peer),
280  (unsigned int) session_id);
282  /* Update address */
284  aa->properties = *prop;
285  /* Notify performance clients about updated address */
287  aa->plugin,
288  aa->addr,
289  aa->addr_len,
290  aa->active,
291  prop,
292  aa->local_address_info,
294  aa->assigned_bw_out),
296  aa->assigned_bw_in));
297 
299 }
300 
301 
308 void
310  uint32_t session_id)
311 {
312  struct ATS_Address *ea;
313 
314  /* Get existing address */
315  ea = find_exact_address (peer,
316  session_id);
317  if (NULL == ea)
318  {
319  GNUNET_break (0);
320  return;
321  }
323  "Received ADDRESS_DESTROYED for peer `%s' session %u\n",
324  GNUNET_i2s (peer),
325  session_id);
326  free_address (ea);
327 }
328 
329 
336 void
338 {
341  GNUNET_NO);
343 }
344 
345 
354 static int
356  const struct GNUNET_PeerIdentity *key,
357  void *value)
358 {
359  struct ATS_Address *aa = value;
360 
361  free_address (aa);
362  return GNUNET_OK;
363 }
364 
365 
369 void
371 {
373  "Destroying all addresses\n");
374  if (NULL == GSA_addresses)
375  return;
376  if (0 ==
378  return;
382  NULL);
384 }
385 
386 
390 void
392 {
394  "Shutting down addresses\n");
399  GSA_addresses = NULL;
400 }
401 
402 
407 {
412 
416  void *it_cls;
417 };
418 
419 
428 static int
429 peerinfo_it (void *cls,
430  const struct GNUNET_PeerIdentity *key,
431  void *value)
432 {
433  struct PeerInfoIteratorContext *pi_ctx = cls;
434  struct ATS_Address *addr = value;
435 
436  pi_ctx->it (pi_ctx->it_cls,
437  &addr->peer,
438  addr->plugin,
439  addr->addr,
440  addr->addr_len,
441  addr->active,
442  &addr->properties,
443  addr->local_address_info,
444  GNUNET_BANDWIDTH_value_init (addr->assigned_bw_out),
445  GNUNET_BANDWIDTH_value_init (addr->assigned_bw_in));
446  return GNUNET_OK;
447 }
448 
449 
450 void
453  void *pi_it_cls)
454 {
455  struct PeerInfoIteratorContext pi_ctx;
456 
457  if (NULL == pi_it)
458  {
459  /* does not make sense without callback */
460  GNUNET_break (0);
461  return;
462  }
464  "Returning information for %s from a total of %u known addresses\n",
465  (NULL == peer)
466  ? "all peers"
467  : GNUNET_i2s (peer),
468  (unsigned int) GNUNET_CONTAINER_multipeermap_size (
469  GSA_addresses));
470  pi_ctx.it = pi_it;
471  pi_ctx.it_cls = pi_it_cls;
472  if (NULL == peer)
474  &peerinfo_it,
475  &pi_ctx);
476  else
478  peer,
479  &peerinfo_it, &pi_ctx);
480  pi_it (pi_it_cls,
481  NULL, NULL, NULL, 0,
482  GNUNET_NO,
483  NULL,
487 }
488 
489 
495 {
500 
504  int all;
505 
509  uint32_t id;
510 };
511 
512 
528 static void
530  const struct GNUNET_PeerIdentity *id,
531  const char *plugin_name,
532  const void *plugin_addr,
533  size_t plugin_addr_len,
534  int active,
535  const struct GNUNET_ATS_Properties *prop,
536  enum GNUNET_HELLO_AddressInfo local_address_info,
537  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
538  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
539 
540 {
541  struct GNUNET_MQ_Envelope *env;
542  struct PeerInformationMessage *msg;
543  char *addrp;
544  size_t plugin_name_length;
545  size_t msize;
546 
547  if (NULL != plugin_name)
548  plugin_name_length = strlen (plugin_name) + 1;
549  else
550  plugin_name_length = 0;
551  msize = plugin_addr_len + plugin_name_length;
552 
553  GNUNET_assert (sizeof(struct PeerInformationMessage) + msize
556  msize,
558  msg->id = htonl (ai->id);
559  if (NULL != id)
560  msg->peer = *id;
561  msg->address_length = htons (plugin_addr_len);
562  msg->address_active = ntohl (active);
563  msg->plugin_name_length = htons (plugin_name_length);
564  msg->bandwidth_out = bandwidth_out;
565  msg->bandwidth_in = bandwidth_in;
566  if (NULL != prop)
567  GNUNET_ATS_properties_hton (&msg->properties,
568  prop);
569  msg->address_local_info = htonl ((uint32_t) local_address_info);
570  addrp = (char *) &msg[1];
571  GNUNET_memcpy (addrp,
572  plugin_addr,
573  plugin_addr_len);
574  if (NULL != plugin_name)
575  strcpy (&addrp[plugin_addr_len],
576  plugin_name);
578  env);
579 }
580 
581 
597 static void
599  const struct GNUNET_PeerIdentity *id,
600  const char *plugin_name,
601  const void *plugin_addr,
602  size_t plugin_addr_len,
603  int active,
604  const struct GNUNET_ATS_Properties *prop,
605  enum GNUNET_HELLO_AddressInfo local_address_info,
608 {
609  struct AddressIteration *ai = cls;
610 
611  if ((NULL == id) &&
612  (NULL == plugin_name) &&
613  (NULL == plugin_addr))
614  {
616  "Address iteration done for one peer\n");
617  return;
618  }
620  "Callback for %s peer `%s' plugin `%s' BW out %u, BW in %u\n",
621  (active == GNUNET_YES) ? "ACTIVE" : "INACTIVE",
622  GNUNET_i2s (id),
623  plugin_name,
624  (unsigned int) ntohl (bandwidth_out.value__),
625  (unsigned int) ntohl (bandwidth_in.value__));
626  /* Transmit result (either if address is active, or if
627  client wanted all addresses) */
628  if ((GNUNET_YES != ai->all) &&
629  (GNUNET_YES != active))
630  return;
632  id,
633  plugin_name,
634  plugin_addr, plugin_addr_len,
635  active,
636  prop,
637  local_address_info,
638  bandwidth_out,
639  bandwidth_in);
640 }
641 
642 
643 void
645  const struct AddressListRequestMessage *alrm)
646 {
647  struct AddressIteration ai;
648  struct GNUNET_PeerIdentity allzeros;
649 
651  "Received ADDRESSLIST_REQUEST message\n");
652  ai.all = ntohl (alrm->all);
653  ai.id = ntohl (alrm->id);
654  ai.client = client;
655 
656  memset (&allzeros,
657  '\0',
658  sizeof(struct GNUNET_PeerIdentity));
659  if (GNUNET_YES == GNUNET_is_zero (&alrm->peer))
660  {
661  /* Return addresses for all peers */
664  &ai);
665  }
666  else
667  {
668  /* Return addresses for a specific peer */
671  &ai);
672  }
674  "Finished handling `%s' message\n",
675  "ADDRESSLIST_REQUEST");
677  NULL, NULL, NULL,
678  0, GNUNET_NO,
679  NULL,
683 }
684 
685 
686 /* end of gnunet-service-ats_addresses.c */
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_STATISTICS_Handle * GSA_stats
Handle for statistics.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static struct GNUNET_HashCode session_id
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
#define GAS_normalization_queue_length
void GAS_addresses_destroy(const struct GNUNET_PeerIdentity *peer, uint32_t session_id)
Remove an address for a peer.
static void req_addr_peerinfo_it(void *cls, const struct GNUNET_PeerIdentity *id, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, int active, const struct GNUNET_ATS_Properties *prop, enum GNUNET_HELLO_AddressInfo local_address_info, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
Iterator for GAS_addresses_get_peer_info(), called with peer-specific information to be passed back t...
void GAS_addresses_get_peer_info(const struct GNUNET_PeerIdentity *peer, GNUNET_ATS_PeerInfo_Iterator pi_it, void *pi_it_cls)
Return information all peers currently known to ATS.
void GAS_addresses_init()
Initialize address subsystem.
struct GNUNET_CONTAINER_MultiPeerMap * GSA_addresses
A multihashmap to store all addresses.
static int find_address_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find session matching given session ID.
void GAS_addresses_update(const struct GNUNET_PeerIdentity *peer, uint32_t session_id, const struct GNUNET_ATS_Properties *prop)
Update an address with new performance information for a peer.
static struct ATS_Address * create_address(const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t local_address_info, uint32_t session_id)
Create a ATS_address with the given information.
void GAS_addresses_destroy_all()
Remove all addresses.
static struct ATS_Address * find_exact_address(const struct GNUNET_PeerIdentity *peer, uint32_t session_id)
Find the exact address.
static void update_addresses_stat()
Update statistic on number of addresses.
void GAS_addresses_add(const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t local_address_info, uint32_t session_id, const struct GNUNET_ATS_Properties *prop)
Add a new address for a peer.
static int peerinfo_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator to iterate over a peer's addresses.
static void init_norm(struct GAS_NormalizationInfo *norm)
Initialize norm.
static void free_address(struct ATS_Address *addr)
Free the given address.
void GAS_handle_request_address_list(struct GNUNET_SERVICE_Client *client, const struct AddressListRequestMessage *alrm)
Handle 'address list request' messages from clients.
static int destroy_all_address_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Destroy all addresses iterator.
void GAS_addresses_done()
Shutdown address subsystem.
static void transmit_req_addr(struct AddressIteration *ai, const struct GNUNET_PeerIdentity *id, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, int active, const struct GNUNET_ATS_Properties *prop, enum GNUNET_HELLO_AddressInfo local_address_info, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
Send a GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE with the given address details to the client iden...
ats service address management
void(* GNUNET_ATS_PeerInfo_Iterator)(void *cls, const struct GNUNET_PeerIdentity *id, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, const int address_active, const struct GNUNET_ATS_Properties *prop, enum GNUNET_HELLO_AddressInfo local_address_info, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
Iterator for GAS_addresses_get_peer_info()
void GAS_normalization_update_property(struct ATS_Address *address)
Update and normalize atsi performance information.
ats service address: management of ATS properties and preferences normalization
void GAS_performance_notify_all_clients(const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, int active, const struct GNUNET_ATS_Properties *prop, enum GNUNET_HELLO_AddressInfo local_address_info, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
Transmit the given performance information to all performance clients.
ats service, interaction with 'performance' API
void GAS_plugin_solver_unlock()
Resume instant solving, we are done with the bulk state updates.
void GAS_plugin_solver_lock()
Stop instant solving, there are many state updates happening in bulk right now.
void GAS_plugin_delete_address(struct ATS_Address *address)
Tell the solver that the given address is no longer valid can cannot be used any longer.
void GAS_plugin_new_address(struct ATS_Address *new_address)
Tell the solver that the given address can now be used for talking to the respective peer.
ats service plugin management
static char * plugin_name
Name of our plugin.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
void GNUNET_ATS_properties_hton(struct GNUNET_ATS_PropertiesNBO *nbo, const struct GNUNET_ATS_Properties *hbo)
Convert ATS properties from host to network byte order.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init(uint32_t bytes_per_second)
Create a new bandwidth value.
Definition: bandwidth.c:39
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
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).
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.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
GNUNET_HELLO_AddressInfo
Additional local information about an address.
@ GNUNET_HELLO_ADDRESS_INFO_NONE
No additional information.
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:302
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:56
@ GNUNET_NT_UNSPECIFIED
Category of last resort.
Definition: gnunet_nt_lib.h:40
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE
Type of the 'struct AddressListResponseMessage' sent by ATS to client with information about addresse...
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2442
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:110
uint32_t fac(uint32_t x)
Factorial.
Address with additional information.
struct GAS_NormalizationInfo norm_delay
Normalized delay information for this address.
uint32_t assigned_bw_in
Inbound bandwidth assigned by solver.
char * plugin
Plugin name.
struct GNUNET_PeerIdentity peer
Peer ID this address is for.
int active
Is this the active address for this peer?
enum GNUNET_HELLO_AddressInfo local_address_info
Field to store local flags.
void * solver_information
Solver-specific information for this address.
struct GNUNET_TIME_Absolute t_last_activity
Time when address had last activity (update, in uses)
uint32_t assigned_bw_out
Outbound bandwidth assigned by solver.
struct GAS_NormalizationInfo norm_distance
Normalized distance information for this address.
struct GAS_NormalizationInfo norm_utilization_out
Normalized utilization outbound for this address.
uint32_t session_id
Session ID, can never be 0.
size_t addr_len
Address length, number of bytes in addr.
struct GAS_NormalizationInfo norm_utilization_in
Normalized utilization inbound for this address.
struct GNUNET_ATS_Properties properties
ATS performance information for this address.
const void * addr
Address (in plugin-specific binary format).
struct GNUNET_TIME_Absolute t_added
Time when address was added.
Information we need for the callbacks to return a list of addresses back to the client.
uint32_t id
Which ID should be included in the response?
struct GNUNET_SERVICE_Client * client
Actual handle to the client.
int all
Are we sending all addresses, or only those that are active?
Client to service: please give us an overview of the addresses.
Definition: ats.h:342
uint32_t id
ID used to match replies to this request.
Definition: ats.h:351
struct GNUNET_PeerIdentity peer
Which peer do we care about? All zeros for all.
Definition: ats.h:356
int32_t all
GNUNET_YES to get information about all addresses, GNUNET_NO to only return addresses that are in use...
Definition: ats.h:362
Closure for find_address_cb()
uint32_t session_id
Session Id to look for.
struct ATS_Address * exact_address
Where to store matching address result.
Information provided by ATS normalization.
uint64_t atsi_abs[3]
Averaging queue.
ATS performance characteristics for an address.
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change.
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
uint32_t value__
The actual value (bytes per second).
Internal representation of the hash map.
The identity of the host (wraps the signing key of the peer).
Handle to a client that is connected to a service.
Definition: service.c:251
Closure for peerinfo_it().
GNUNET_ATS_PeerInfo_Iterator it
Function to call for each address.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Definition: ats.h:318
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Definition: ats.h:313
uint16_t plugin_name_length
Definition: ats.h:293
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.