GNUnet  0.11.x
ats_api_scheduling.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2010-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  */
34 #include "platform.h"
35 #include "gnunet_ats_service.h"
36 #include "ats.h"
37 
41 #define INTERFACE_PROCESSING_INTERVAL GNUNET_TIME_relative_multiply ( \
42  GNUNET_TIME_UNIT_MINUTES, 2)
43 
44 #define LOG(kind, ...) GNUNET_log_from (kind, "ats-scheduling-api", __VA_ARGS__)
45 
49 #define NOT_FOUND 0
50 
51 
58 {
63 
68 
74 
79 
88  uint32_t slot;
89 
96 };
97 
98 
103 {
108 
113 
118 
123 
131 
136 
141 
145  unsigned int session_array_size;
146 };
147 
148 
154 static void
156 
157 
163 static void
164 reconnect_task (void *cls)
165 {
166  struct GNUNET_ATS_SchedulingHandle *sh = cls;
167 
168  sh->task = NULL;
169  reconnect (sh);
170 }
171 
172 
178 static void
180 {
181  if (NULL != sh->mq)
182  {
183  GNUNET_MQ_destroy (sh->mq);
184  sh->mq = NULL;
185  }
186  sh->suggest_cb (sh->suggest_cb_cls,
187  NULL, NULL, NULL,
190  sh->backoff = GNUNET_TIME_STD_BACKOFF (sh->backoff);
191  sh->task = GNUNET_SCHEDULER_add_delayed (sh->backoff,
193  sh);
194 }
195 
196 
205 static struct GNUNET_ATS_AddressRecord *
207  uint32_t session_id,
208  const struct GNUNET_PeerIdentity *peer)
209 {
210  struct GNUNET_ATS_AddressRecord *ar;
211 
212  if (session_id >= sh->session_array_size)
213  {
214  GNUNET_break (0);
215  return NULL;
216  }
217  if (0 == session_id)
218  return NULL;
219  ar = sh->session_array[session_id];
220  if (NULL == ar)
221  {
222  GNUNET_break (0);
223  return NULL;
224  }
225  if (NULL == ar->address)
226  {
227  /* address was destroyed in the meantime, this can happen
228  as we communicate asynchronously with the ATS service. */
229  return NULL;
230  }
231  if (0 != GNUNET_memcmp (peer,
232  &ar->address->peer))
233  {
234  GNUNET_break (0);
235  return NULL;
236  }
237  return ar;
238 }
239 
240 
247 static uint32_t
249 {
250  static uint32_t off;
251  uint32_t i;
252 
253  GNUNET_assert (0 != sh->session_array_size);
254  i = 0;
255  while (((NOT_FOUND == off) ||
256  (NULL != sh->session_array[off % sh->session_array_size])) &&
257  (i < sh->session_array_size))
258  {
259  off++;
260  i++;
261  }
262  if ((NOT_FOUND != off % sh->session_array_size) &&
263  (NULL == sh->session_array[off % sh->session_array_size]))
264  return off;
265  i = sh->session_array_size;
266  GNUNET_array_grow (sh->session_array,
267  sh->session_array_size,
268  sh->session_array_size * 2);
269  return i;
270 }
271 
272 
281 static uint32_t
283  struct GNUNET_ATS_Session *session,
284  const struct GNUNET_HELLO_Address *address)
285 {
286  uint32_t i;
287 
288  if (NULL == address)
289  {
290  GNUNET_break (0);
291  return NOT_FOUND;
292  }
293  for (i = 1; i < sh->session_array_size; i++)
294  if ((NULL != sh->session_array[i]) &&
295  (GNUNET_NO == sh->session_array[i]->in_destroy) &&
296  ((session == sh->session_array[i]->session) ||
297  (NULL == sh->session_array[i]->session)) &&
298  (0 == GNUNET_memcmp (&address->peer,
299  &sh->session_array[i]->address->peer)) &&
301  sh->session_array[i]->address)))
302  return i;
303  return NOT_FOUND;
304 }
305 
306 
314 static void
316  uint32_t session_id)
317 {
318  struct GNUNET_ATS_AddressRecord *ar;
319 
320  if (NOT_FOUND == session_id)
321  return;
322  if (session_id >= sh->session_array_size)
323  {
324  GNUNET_break (0);
326  return;
327  }
328  /* this slot should have been removed from remove_session before */
329  ar = sh->session_array[session_id];
330  if (NULL != ar->session)
331  {
332  GNUNET_break (0);
334  return;
335  }
337  GNUNET_free (ar);
338  sh->session_array[session_id] = NULL;
339 }
340 
341 
349 static void
351  const struct GNUNET_ATS_SessionReleaseMessage *srm)
352 {
353  struct GNUNET_ATS_SchedulingHandle *sh = cls;
354 
355  /* Note: peer field in srm not necessary right now,
356  but might be good to have in the future */
358  ntohl (srm->session_id));
359 }
360 
361 
369 static void
371  const struct AddressSuggestionMessage *m)
372 {
373  struct GNUNET_ATS_SchedulingHandle *sh = cls;
374  struct GNUNET_ATS_AddressRecord *ar;
375  uint32_t session_id;
376 
377  session_id = ntohl (m->session_id);
378  if (0 == session_id)
379  {
380  GNUNET_break (0);
382  return;
383  }
384  ar = find_session (sh,
385  session_id,
386  &m->peer);
387  if (NULL == ar)
388  {
389  GNUNET_break (0);
391  return;
392  }
393  if (NULL == sh->suggest_cb)
394  return;
395  if (GNUNET_YES == ar->in_destroy)
396  {
397  /* ignore suggestion, as this address is dying, unless BW is 0,
398  in that case signal 'disconnect' via BW 0 */
399  if ((0 == ntohl (m->bandwidth_out.value__)) &&
400  (0 == ntohl (m->bandwidth_in.value__)))
401  {
403  "ATS suggests disconnect from peer `%s' with BW %u/%u\n",
404  GNUNET_i2s (&ar->address->peer),
405  (unsigned int) ntohl (m->bandwidth_out.value__),
406  (unsigned int) ntohl (m->bandwidth_in.value__));
407  sh->suggest_cb (sh->suggest_cb_cls,
408  &m->peer,
409  NULL,
410  NULL,
411  m->bandwidth_out,
412  m->bandwidth_in);
413  }
414  return;
415  }
416  if ((NULL == ar->session) &&
419  {
420  GNUNET_break (0);
421  return;
422  }
423  sh->backoff = GNUNET_TIME_UNIT_ZERO;
425  "ATS suggests address slot %u for peer `%s' using plugin %s\n",
426  ar->slot,
427  GNUNET_i2s (&ar->address->peer),
428  ar->address->transport_name);
429  sh->suggest_cb (sh->suggest_cb_cls,
430  &m->peer,
431  ar->address,
432  ar->session,
433  m->bandwidth_out,
434  m->bandwidth_in);
435 }
436 
437 
445 static void
446 error_handler (void *cls,
447  enum GNUNET_MQ_Error error)
448 {
449  struct GNUNET_ATS_SchedulingHandle *sh = cls;
450 
452  "ATS connection died (code %d), reconnecting\n",
453  (int) error);
455 }
456 
457 
465 static void
467  const struct GNUNET_ATS_AddressRecord *ar)
468 {
469  struct GNUNET_MQ_Envelope *ev;
470  struct AddressAddMessage *m;
471  char *pm;
472  size_t namelen;
473  size_t msize;
474 
475  if (NULL == sh->mq)
476  return; /* disconnected, skip for now */
478  namelen = strlen (ar->address->transport_name) + 1;
479  msize = ar->address->address_length + namelen;
481  m->peer = ar->address->peer;
482  m->address_length = htons (ar->address->address_length);
483  m->address_local_info = htonl ((uint32_t) ar->address->local_info);
484  m->plugin_name_length = htons (namelen);
485  m->session_id = htonl (ar->slot);
486  m->properties = ar->properties;
487 
489  "Adding address for peer `%s', plugin `%s', session %p slot %u\n",
490  GNUNET_i2s (&ar->address->peer),
491  ar->address->transport_name,
492  ar->session,
493  ar->slot);
494  pm = (char *) &m[1];
495  GNUNET_memcpy (pm,
496  ar->address->address,
497  ar->address->address_length);
498  if (NULL != ar->address->transport_name)
500  ar->address->transport_name,
501  namelen);
502  GNUNET_MQ_send (sh->mq, ev);
503 }
504 
505 
511 static void
513 {
515  GNUNET_MQ_hd_fixed_size (ats_session_release,
518  sh),
519  GNUNET_MQ_hd_fixed_size (ats_address_suggestion,
522  sh),
524  };
525  struct GNUNET_MQ_Envelope *ev;
526  struct ClientStartMessage *init;
527  unsigned int i;
528  struct GNUNET_ATS_AddressRecord *ar;
529 
530  GNUNET_assert (NULL == sh->mq);
531  sh->mq = GNUNET_CLIENT_connect (sh->cfg,
532  "ats",
533  handlers,
534  &error_handler,
535  sh);
536  if (NULL == sh->mq)
537  {
538  GNUNET_break (0);
540  return;
541  }
542  ev = GNUNET_MQ_msg (init,
544  init->start_flag = htonl (START_FLAG_SCHEDULING);
545  GNUNET_MQ_send (sh->mq, ev);
546  if (NULL == sh->mq)
547  return;
548  for (i = 0; i < sh->session_array_size; i++)
549  {
550  ar = sh->session_array[i];
551  if (NULL == ar)
552  continue;
554  if (NULL == sh->mq)
555  return;
556  }
557 }
558 
559 
571  void *suggest_cb_cls)
572 {
574 
576  sh->cfg = cfg;
577  sh->suggest_cb = suggest_cb;
578  sh->suggest_cb_cls = suggest_cb_cls;
579  GNUNET_array_grow (sh->session_array,
580  sh->session_array_size,
581  4);
582  reconnect (sh);
583  return sh;
584 }
585 
586 
592 void
594 {
595  struct GNUNET_ATS_AddressRecord *ar;
596  unsigned int i;
597 
598  if (NULL != sh->mq)
599  {
600  GNUNET_MQ_destroy (sh->mq);
601  sh->mq = NULL;
602  }
603  if (NULL != sh->task)
604  {
605  GNUNET_SCHEDULER_cancel (sh->task);
606  sh->task = NULL;
607  }
608  for (i = 0; i < sh->session_array_size; i++)
609  {
610  if (NULL != (ar = sh->session_array[i]))
611  {
613  GNUNET_free (ar);
614  sh->session_array[i] = NULL;
615  }
616  }
617  GNUNET_array_grow (sh->session_array,
618  sh->session_array_size,
619  0);
620  GNUNET_free (sh);
621 }
622 
623 
638  const struct GNUNET_HELLO_Address *address,
639  struct GNUNET_ATS_Session *session,
640  const struct GNUNET_ATS_Properties *prop)
641 {
642  struct GNUNET_ATS_AddressRecord *ar;
643  size_t namelen;
644  size_t msize;
645  uint32_t s;
646 
647  if (NULL == address)
648  {
649  /* we need a valid address */
650  GNUNET_break (0);
651  return NULL;
652  }
654  namelen = strlen (address->transport_name) + 1;
655  msize = address->address_length + namelen;
656  if ((msize + sizeof(struct AddressUpdateMessage) >=
658  (address->address_length >= GNUNET_MAX_MESSAGE_SIZE) ||
659  (namelen >= GNUNET_MAX_MESSAGE_SIZE))
660  {
661  /* address too large for us, this should not happen */
662  GNUNET_break (0);
663  return NULL;
664  }
665 
666  if (NOT_FOUND !=
668  session,
669  address))
670  {
671  /* Already existing, nothing todo, but this should not happen */
672  GNUNET_break (0);
673  return NULL;
674  }
676  ar = GNUNET_new (struct GNUNET_ATS_AddressRecord);
677  ar->sh = sh;
678  ar->slot = s;
679  ar->session = session;
682  prop);
683  sh->session_array[s] = ar;
685  return ar;
686 }
687 
688 
695 void
697  struct GNUNET_ATS_Session *session)
698 {
699  GNUNET_break (NULL == ar->session);
700  ar->session = session;
701 }
702 
703 
716 int
718  struct GNUNET_ATS_Session *session)
719 {
720  GNUNET_assert (session == ar->session);
721  ar->session = NULL;
724  {
726  return GNUNET_YES;
727  }
728  return GNUNET_NO;
729 }
730 
731 
743 void
745  const struct GNUNET_ATS_Properties *prop)
746 {
747  struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
748  struct GNUNET_MQ_Envelope *ev;
749  struct AddressUpdateMessage *m;
750 
752  "Updating address for peer `%s', plugin `%s', session %p slot %u\n",
753  GNUNET_i2s (&ar->address->peer),
754  ar->address->transport_name,
755  ar->session,
756  ar->slot);
759  prop);
760  if (NULL == sh->mq)
761  return; /* disconnected, skip for now */
763  m->session_id = htonl (ar->slot);
764  m->peer = ar->address->peer;
765  m->properties = ar->properties;
766  GNUNET_MQ_send (sh->mq,
767  ev);
768 }
769 
770 
776 void
778 {
779  struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
780  struct GNUNET_MQ_Envelope *ev;
781  struct AddressDestroyedMessage *m;
782 
784  "Deleting address for peer `%s', plugin `%s', slot %u session %p\n",
785  GNUNET_i2s (&ar->address->peer),
786  ar->address->transport_name,
787  ar->slot,
788  ar->session);
789  GNUNET_break (NULL == ar->session);
790  ar->session = NULL;
791  ar->in_destroy = GNUNET_YES;
792  if (NULL == sh->mq)
793  return;
795  m->session_id = htonl (ar->slot);
796  m->peer = ar->address->peer;
797  GNUNET_MQ_send (sh->mq, ev);
798 }
799 
800 
801 /* end of ats_api_scheduling.c */
automatic transport selection messages
@ START_FLAG_SCHEDULING
This is a scheduling client (aka transport service)
Definition: ats.h:42
static void force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Disconnect from ATS and then reconnect.
#define NOT_FOUND
Session ID we use if there is no session / slot.
static void release_session(struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id)
Release the session slot from the session table (ATS service is also done using it).
static void error_handler(void *cls, enum GNUNET_MQ_Error error)
We encountered an error handling the MQ to the ATS service.
static struct GNUNET_ATS_AddressRecord * find_session(struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id, const struct GNUNET_PeerIdentity *peer)
Find the session object corresponding to the given session ID.
static void handle_ats_session_release(void *cls, const struct GNUNET_ATS_SessionReleaseMessage *srm)
Type of a function to call when we receive a session release message from the service.
static uint32_t find_session_id(struct GNUNET_ATS_SchedulingHandle *sh, struct GNUNET_ATS_Session *session, const struct GNUNET_HELLO_Address *address)
Get the ID for the given session object.
static void send_add_address_message(struct GNUNET_ATS_SchedulingHandle *sh, const struct GNUNET_ATS_AddressRecord *ar)
Generate and transmit the struct AddressAddMessage for the given address record.
#define LOG(kind,...)
static void reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Re-establish the connection to the ATS service.
static uint32_t find_empty_session_slot(struct GNUNET_ATS_SchedulingHandle *sh)
Get an available session ID.
static void reconnect_task(void *cls)
Re-establish the connection to the ATS service.
static void handle_ats_address_suggestion(void *cls, const struct AddressSuggestionMessage *m)
Type of a function to call when we receive a address suggestion message from the service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
static struct SolverHandle * sh
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static struct GNUNET_HashCode session_id
static char * address
GNS address for this phone.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
Automatic transport selection and outbound bandwidth determination.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
void GNUNET_ATS_address_add_session(struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
An address was used to initiate a session.
struct GNUNET_ATS_SchedulingHandle * GNUNET_ATS_scheduling_init(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressSuggestionCallback suggest_cb, void *suggest_cb_cls)
Initialize the ATS subsystem.
void GNUNET_ATS_address_update(struct GNUNET_ATS_AddressRecord *ar, const struct GNUNET_ATS_Properties *prop)
We have updated performance statistics for a given address.
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.
int GNUNET_ATS_address_del_session(struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
A session was destroyed, disassociate it from the given address record.
void(* GNUNET_ATS_AddressSuggestionCallback)(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
Signature of a function called by ATS with the current bandwidth and address preferences as determine...
void GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
An address got destroyed, stop using it as a valid address.
void GNUNET_ATS_scheduling_done(struct GNUNET_ATS_SchedulingHandle *sh)
Client is done with ATS scheduling, release resources.
struct GNUNET_ATS_AddressRecord * GNUNET_ATS_address_add(struct GNUNET_ATS_SchedulingHandle *sh, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_ATS_Properties *prop)
We have a new address ATS should know.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1064
#define GNUNET_HELLO_address_free(addr)
Free an address.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
int GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
Check if an address has a local option set.
Definition: address.c:39
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
@ GNUNET_HELLO_ADDRESS_INFO_INBOUND
This is an inbound address and cannot be used to initiate an outbound connection to another peer.
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
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_MQ_Error
Error codes for the queue.
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:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#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
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
@ GNUNET_NT_UNSPECIFIED
Category of last resort.
Definition: gnunet_nt_lib.h:40
#define GNUNET_MESSAGE_TYPE_ATS_START
Type of the 'struct ClientStartMessage' sent by clients to ATS to identify the type of the client.
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE
Type of the 'struct AddressUpdateMessage' sent by clients to ATS to inform ATS about performance chan...
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION
Type of the 'struct AddressSuggestionMessage' sent by ATS to clients to suggest switching to a differ...
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD
Type of the 'struct AddressUpdateMessage' sent by client to ATS to add a new address.
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED
Type of the 'struct AddressDestroyedMessage' sent by clients to ATS to inform ATS about an address be...
#define GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE
Type of the 'struct SessionReleaseMessage' sent by ATS to client to confirm that a session ID was des...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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:1269
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Scheduling client to ATS service: here is another address you can use.
Definition: ats.h:112
Message sent by ATS client to ATS service when an address was destroyed and must thus henceforth no l...
Definition: ats.h:193
ATS Service suggests to the transport service to use the address identified by the given session_id f...
Definition: ats.h:244
Message used to notify ATS that the performance characteristics for an address have changed.
Definition: ats.h:162
First message any client sends to ATS, used to self-identify (what type of client this is).
Definition: ats.h:70
Information we track per address, incoming or outgoing.
struct GNUNET_HELLO_Address * address
Address data.
struct GNUNET_ATS_Session * session
Session handle.
int in_destroy
We're about to destroy this address record, just ATS does not know this yet.
uint32_t slot
Which slot (index) in the session array does this record correspond to? FIXME: a linear search on thi...
struct GNUNET_ATS_SchedulingHandle * sh
Scheduling handle this address record belongs to.
struct GNUNET_ATS_PropertiesNBO properties
Performance data about the address.
ATS performance characteristics for an address in network byte order (for IPC).
uint32_t scope
Which network scope does the respective address belong to? This property does not change.
ATS performance characteristics for an address.
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change.
Handle to the ATS subsystem for bandwidth/transport scheduling information.
struct GNUNET_SCHEDULER_Task * task
Task to trigger reconnect.
unsigned int session_array_size
Size of the session_array.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct GNUNET_ATS_AddressRecord ** session_array
Array of session objects (we need to translate them to numbers and back for the protocol; the offset ...
void * suggest_cb_cls
Closure for suggest_cb.
GNUNET_ATS_AddressSuggestionCallback suggest_cb
Callback to invoke on suggestions.
struct GNUNET_TIME_Relative backoff
Reconnect backoff delay.
struct GNUNET_MQ_Handle * mq
Message queue for sending requests to the ATS service.
Message sent by ATS service to client to confirm that it is done using the given session ID.
Definition: ats.h:218
uint32_t session_id
Number the client used to identify the session.
Definition: ats.h:227
Session handle for connections.
An address for communicating with a peer.
const char * transport_name
Name of the transport plugin enabling the communication using this address.
size_t address_length
Number of bytes in address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
enum GNUNET_HELLO_AddressInfo local_info
Extended information about address.
const void * address
Binary representation of the address (plugin-specific).
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:135
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.