GNUnet  0.10.x
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
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);
124  aa->plugin = GNUNET_strdup(plugin_name);
125  aa->session_id = session_id;
127  init_norm(&aa->norm_delay);
128  init_norm(&aa->norm_distance);
131  return aa;
132 }
133 
134 
142  uint32_t session_id;
143 
148 };
149 
150 
159 static int
160 find_address_cb(void *cls,
161  const struct GNUNET_PeerIdentity *key,
162  void *value)
163 {
164  struct FindAddressContext *fac = cls;
165  struct ATS_Address *aa = value;
166 
167  if (aa->session_id == fac->session_id)
168  {
169  fac->exact_address = aa;
170  return GNUNET_NO;
171  }
172  return GNUNET_YES;
173 }
174 
175 
183 static struct ATS_Address *
185  uint32_t session_id)
186 {
187  struct FindAddressContext fac;
188 
189  fac.exact_address = NULL;
190  fac.session_id = session_id;
192  peer,
193  &find_address_cb, &fac);
194  return fac.exact_address;
195 }
196 
197 
209 void
211  const char *plugin_name,
212  const void *plugin_addr,
213  size_t plugin_addr_len,
214  uint32_t local_address_info,
215  uint32_t session_id,
216  const struct GNUNET_ATS_Properties *prop)
217 {
218  struct ATS_Address *new_address;
219 
220  if (NULL != find_exact_address(peer,
221  session_id))
222  {
223  GNUNET_break(0);
224  return;
225  }
227  new_address = create_address(peer,
228  plugin_name,
229  plugin_addr,
230  plugin_addr_len,
231  local_address_info,
232  session_id);
233  /* Add a new address */
234  new_address->properties = *prop;
235  new_address->t_added = GNUNET_TIME_absolute_get();
236  new_address->t_last_activity = GNUNET_TIME_absolute_get();
238  GNUNET_CONTAINER_multipeermap_put(GSA_addresses,
239  peer,
240  new_address,
244  "Adding new address for peer `%s' slot %u\n",
245  GNUNET_i2s(peer),
246  session_id);
247  /* Tell solver about new address */
249  GAS_plugin_new_address(new_address);
250  GAS_normalization_update_property(new_address); // FIXME: needed?
252  /* Notify performance clients about new address */
254  new_address->plugin,
255  new_address->addr,
256  new_address->addr_len,
257  new_address->active,
258  &new_address->properties,
259  new_address->local_address_info,
262 }
263 
264 
272 void
274  uint32_t session_id,
275  const struct GNUNET_ATS_Properties *prop)
276 {
277  struct ATS_Address *aa;
278 
279  /* Get existing address */
280  aa = find_exact_address(peer,
281  session_id);
282  if (NULL == aa)
283  {
284  GNUNET_break(0);
285  return;
286  }
287  if (NULL == aa->solver_information)
288  {
289  GNUNET_break(0);
290  return;
291  }
293  "Received ADDRESS_UPDATE for peer `%s' slot %u\n",
294  GNUNET_i2s(peer),
295  (unsigned int)session_id);
297  /* Update address */
299  aa->properties = *prop;
300  /* Notify performance clients about updated address */
302  aa->plugin,
303  aa->addr,
304  aa->addr_len,
305  aa->active,
306  prop,
307  aa->local_address_info,
310 
312 }
313 
314 
321 void
323  uint32_t session_id)
324 {
325  struct ATS_Address *ea;
326 
327  /* Get existing address */
328  ea = find_exact_address(peer,
329  session_id);
330  if (NULL == ea)
331  {
332  GNUNET_break(0);
333  return;
334  }
336  "Received ADDRESS_DESTROYED for peer `%s' session %u\n",
337  GNUNET_i2s(peer),
338  session_id);
339  free_address(ea);
340 }
341 
342 
349 void
351 {
352  GSA_addresses
354  GNUNET_NO);
356 }
357 
358 
367 static int
369  const struct GNUNET_PeerIdentity *key,
370  void *value)
371 {
372  struct ATS_Address *aa = value;
373 
374  free_address(aa);
375  return GNUNET_OK;
376 }
377 
378 
382 void
384 {
386  "Destroying all addresses\n");
387  if (0 ==
388  GNUNET_CONTAINER_multipeermap_size(GSA_addresses))
389  return;
393  NULL);
395 }
396 
397 
401 void
403 {
405  "Shutting down addresses\n");
410  GSA_addresses = NULL;
411 }
412 
413 
422 
426  void *it_cls;
427 };
428 
429 
438 static int
439 peerinfo_it(void *cls,
440  const struct GNUNET_PeerIdentity *key,
441  void *value)
442 {
443  struct PeerInfoIteratorContext *pi_ctx = cls;
444  struct ATS_Address *addr = value;
445 
446  pi_ctx->it(pi_ctx->it_cls,
447  &addr->peer,
448  addr->plugin,
449  addr->addr,
450  addr->addr_len,
451  addr->active,
452  &addr->properties,
453  addr->local_address_info,
456  return GNUNET_OK;
457 }
458 
459 
467 void
470  void *pi_it_cls)
471 {
472  struct PeerInfoIteratorContext pi_ctx;
473 
474  if (NULL == pi_it)
475  {
476  /* does not make sense without callback */
477  GNUNET_break(0);
478  return;
479  }
481  "Returning information for %s from a total of %u known addresses\n",
482  (NULL == peer)
483  ? "all peers"
484  : GNUNET_i2s(peer),
485  (unsigned int)GNUNET_CONTAINER_multipeermap_size(GSA_addresses));
486  pi_ctx.it = pi_it;
487  pi_ctx.it_cls = pi_it_cls;
488  if (NULL == peer)
490  &peerinfo_it,
491  &pi_ctx);
492  else
494  peer,
495  &peerinfo_it, &pi_ctx);
496  pi_it(pi_it_cls,
497  NULL, NULL, NULL, 0,
498  GNUNET_NO,
499  NULL,
503 }
504 
505 
515 
519  int all;
520 
524  uint32_t id;
525 };
526 
527 
543 static void
545  const struct GNUNET_PeerIdentity *id,
546  const char *plugin_name,
547  const void *plugin_addr,
548  size_t plugin_addr_len,
549  int active,
550  const struct GNUNET_ATS_Properties *prop,
551  enum GNUNET_HELLO_AddressInfo local_address_info,
552  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
553  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
554 
555 {
556  struct GNUNET_MQ_Envelope *env;
557  struct PeerInformationMessage *msg;
558  char *addrp;
559  size_t plugin_name_length;
560  size_t msize;
561 
562  if (NULL != plugin_name)
563  plugin_name_length = strlen(plugin_name) + 1;
564  else
565  plugin_name_length = 0;
566  msize = plugin_addr_len + plugin_name_length;
567 
568  GNUNET_assert(sizeof(struct PeerInformationMessage) + msize
570  env = GNUNET_MQ_msg_extra(msg,
571  msize,
573  msg->id = htonl(ai->id);
574  if (NULL != id)
575  msg->peer = *id;
576  msg->address_length = htons(plugin_addr_len);
577  msg->address_active = ntohl(active);
578  msg->plugin_name_length = htons(plugin_name_length);
580  msg->bandwidth_in = bandwidth_in;
581  if (NULL != prop)
583  prop);
584  msg->address_local_info = htonl((uint32_t)local_address_info);
585  addrp = (char *)&msg[1];
586  GNUNET_memcpy(addrp,
587  plugin_addr,
588  plugin_addr_len);
589  if (NULL != plugin_name)
590  strcpy(&addrp[plugin_addr_len],
591  plugin_name);
593  env);
594 }
595 
596 
612 static void
614  const struct GNUNET_PeerIdentity *id,
615  const char *plugin_name,
616  const void *plugin_addr,
617  size_t plugin_addr_len,
618  int active,
619  const struct GNUNET_ATS_Properties *prop,
620  enum GNUNET_HELLO_AddressInfo local_address_info,
623 {
624  struct AddressIteration *ai = cls;
625 
626  if ((NULL == id) &&
627  (NULL == plugin_name) &&
628  (NULL == plugin_addr))
629  {
631  "Address iteration done for one peer\n");
632  return;
633  }
635  "Callback for %s peer `%s' plugin `%s' BW out %u, BW in %u\n",
636  (active == GNUNET_YES) ? "ACTIVE" : "INACTIVE",
637  GNUNET_i2s(id),
638  plugin_name,
639  (unsigned int)ntohl(bandwidth_out.value__),
640  (unsigned int)ntohl(bandwidth_in.value__));
641  /* Transmit result (either if address is active, or if
642  client wanted all addresses) */
643  if ((GNUNET_YES != ai->all) &&
644  (GNUNET_YES != active))
645  return;
647  id,
648  plugin_name,
649  plugin_addr, plugin_addr_len,
650  active,
651  prop,
652  local_address_info,
653  bandwidth_out,
654  bandwidth_in);
655 }
656 
657 
664 void
666  const struct AddressListRequestMessage *alrm)
667 {
668  struct AddressIteration ai;
669  struct GNUNET_PeerIdentity allzeros;
670 
672  "Received ADDRESSLIST_REQUEST message\n");
673  ai.all = ntohl(alrm->all);
674  ai.id = ntohl(alrm->id);
675  ai.client = client;
676 
677  memset(&allzeros,
678  '\0',
679  sizeof(struct GNUNET_PeerIdentity));
680  if (0 == GNUNET_is_zero(&alrm->peer))
681  {
682  /* Return addresses for all peers */
685  &ai);
686  }
687  else
688  {
689  /* Return addresses for a specific peer */
692  &ai);
693  }
695  "Finished handling `%s' message\n",
696  "ADDRESSLIST_REQUEST");
697  transmit_req_addr(&ai,
698  NULL, NULL, NULL,
699  0, GNUNET_NO,
700  NULL,
704 }
705 
706 
707 
708 /* end of gnunet-service-ats_addresses.c */
static void init_norm(struct GAS_NormalizationInfo *norm)
Initialize norm.
Information we need for the callbacks to return a list of addresses back to the client.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t id
Which ID should be included in the response?
static void update_addresses_stat()
Update statistic on number of addresses.
uint32_t session_id
Session ID, can never be 0.
#define GAS_normalization_queue_length
struct GNUNET_ATS_Properties properties
ATS performance information for this address.
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...
uint16_t address_length
Definition: ats.h:280
int active
Is this the active address for this peer?
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2424
struct GNUNET_PeerIdentity peer
Peer ID this address is for.
void GAS_plugin_solver_lock()
Stop instant solving, there are many state updates happening in bulk right now.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Closure for find_address_cb()
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Definition: ats.h:310
uint64_t atsi_abs[3]
Averaging queue.
const void * addr
Address (in plugin-specific binary format).
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.
uint16_t plugin_name_length
Definition: ats.h:285
uint32_t address_local_info
Local-only information of the address, see enum GNUNET_HELLO_AddressInfo.
Definition: ats.h:321
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.
uint32_t id
ID used to match replies to this request.
Definition: ats.h:342
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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 of ATS properties and preferences normalization
static struct GNUNET_HashCode session_id
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.
ats service plugin management
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
size_t addr_len
Address length, number of bytes in addr.
char * plugin
Plugin name.
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.
struct GNUNET_SERVICE_Client * client
Actual handle to the client.
void GAS_addresses_destroy_all()
Remove all addresses.
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).
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_STATISTICS_Handle * GSA_stats
Handle for statistics.
ATS performance characteristics for an address.
struct GNUNET_ATS_PropertiesNBO properties
Performance properties of the address.
Definition: ats.h:315
static int find_address_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find session matching given session ID.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_PeerIdentity peer
Definition: ats.h:290
struct ATS_Address * exact_address
Where to store matching address result.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
ats service, interaction with &#39;performance&#39; API
uint32_t value__
The actual value (bytes per second).
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.
Handle to a client that is connected to a service.
Definition: service.c:246
void GAS_plugin_solver_unlock()
Resume instant solving, we are done with the bulk state updates.
uint32_t assigned_bw_in
Inbound bandwidth assigned by solver.
void GAS_normalization_update_property(struct ATS_Address *address)
Update and normalize atsi performance information.
#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:52
static char * value
Value of the record to add/remove.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Definition: ats.h:305
Closure for peerinfo_it().
static struct ATS_Address * find_exact_address(const struct GNUNET_PeerIdentity *peer, uint32_t session_id)
Find the exact address.
int all
Are we sending all addresses, or only those that are active?
static char * plugin_name
Solver plugin name as string.
struct GAS_NormalizationInfo norm_utilization_out
Normalized utilization outbound for this address.
Internal representation of the hash map.
Information provided by ATS normalization.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
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()
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
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.
struct GNUNET_TIME_Absolute t_added
Time when address was added.
Address with additional information.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
void * solver_information
Solver-specific information for this address.
Client to service: please give us an overview of the addresses.
Definition: ats.h:333
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CONTAINER_MultiPeerMap * GSA_addresses
A multihashmap to store all addresses.
GNUNET_ATS_PeerInfo_Iterator it
Function to call for each address.
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init(uint32_t bytes_per_second)
Create a new bandwidth value.
Definition: bandwidth.c:39
void GAS_addresses_destroy(const struct GNUNET_PeerIdentity *peer, uint32_t session_id)
Remove an address for a peer.
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE
Type of the &#39;struct AddressListResponseMessage&#39; sent by ATS to client with information about addresse...
ats service address management
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
uint32_t fac(uint32_t x)
Factorial.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
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.
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.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
int32_t all
GNUNET_YES to get information about all addresses, GNUNET_NO to only return addresses that are in use...
Definition: ats.h:353
The identity of the host (wraps the signing key of the peer).
No additional information.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
uint32_t assigned_bw_out
Outbound bandwidth assigned by solver.
struct GAS_NormalizationInfo norm_utilization_in
Normalized utilization inbound for this address.
#define GNUNET_log(kind,...)
struct GAS_NormalizationInfo norm_delay
Normalized delay information for this address.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:351
void GAS_addresses_init()
Initialize address subsystem.
void GAS_addresses_done()
Shutdown address subsystem.
static int peerinfo_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator to iterate over a peer&#39;s addresses.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
uint32_t address_active
Definition: ats.h:295
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.
GNUNET_HELLO_AddressInfo
Additional local information about an address.
struct GNUNET_PeerIdentity peer
Which peer do we care about? All zeros for all.
Definition: ats.h:347
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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.
enum GNUNET_HELLO_AddressInfo local_address_info
Field to store local flags.
static int destroy_all_address_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Destroy all addresses iterator.
#define GNUNET_malloc(size)
Wrapper around malloc.
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...
struct GAS_NormalizationInfo norm_distance
Normalized distance information for this address.
uint32_t session_id
Session Id to look for.
#define GNUNET_free(ptr)
Wrapper around free.
Category of last resort.
Definition: gnunet_nt_lib.h:39
void GAS_handle_request_address_list(struct GNUNET_SERVICE_Client *client, const struct AddressListRequestMessage *alrm)
Handle &#39;address list request&#39; messages from clients.
static void free_address(struct ATS_Address *addr)
Free the given address.
struct GNUNET_TIME_Absolute t_last_activity
Time when address had last activity (update, in uses)