GNUnet  0.11.x
Data Structures | Macros | Functions
ats_api_scheduling.c File Reference

automatic transport selection and outbound bandwidth determination More...

#include "platform.h"
#include "gnunet_ats_service.h"
#include "ats.h"
Include dependency graph for ats_api_scheduling.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_ATS_AddressRecord
 Information we track per address, incoming or outgoing. More...
 
struct  GNUNET_ATS_SchedulingHandle
 Handle to the ATS subsystem for bandwidth/transport scheduling information. More...
 

Macros

#define INTERFACE_PROCESSING_INTERVAL
 How frequently do we scan the interfaces for changes to the addresses? More...
 
#define LOG(kind, ...)   GNUNET_log_from (kind, "ats-scheduling-api", __VA_ARGS__)
 
#define NOT_FOUND   0
 Session ID we use if there is no session / slot. More...
 

Functions

static void reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
 Re-establish the connection to the ATS service. More...
 
static void reconnect_task (void *cls)
 Re-establish the connection to the ATS service. More...
 
static void force_reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
 Disconnect from ATS and then reconnect. More...
 
static struct GNUNET_ATS_AddressRecordfind_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. More...
 
static uint32_t find_empty_session_slot (struct GNUNET_ATS_SchedulingHandle *sh)
 Get an available session ID. More...
 
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. More...
 
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). More...
 
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. More...
 
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. More...
 
static void error_handler (void *cls, enum GNUNET_MQ_Error error)
 We encountered an error handling the MQ to the ATS service. More...
 
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. More...
 
struct GNUNET_ATS_SchedulingHandleGNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressSuggestionCallback suggest_cb, void *suggest_cb_cls)
 Initialize the ATS subsystem. More...
 
void GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
 Client is done with ATS scheduling, release resources. More...
 
struct GNUNET_ATS_AddressRecordGNUNET_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. More...
 
void GNUNET_ATS_address_add_session (struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
 An address was used to initiate a session. More...
 
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. More...
 
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. More...
 
void GNUNET_ATS_address_destroy (struct GNUNET_ATS_AddressRecord *ar)
 An address got destroyed, stop using it as a valid address. More...
 

Detailed Description

automatic transport selection and outbound bandwidth determination

Author
Christian Grothoff
Matthias Wachs

TODO:

Definition in file ats_api_scheduling.c.

Macro Definition Documentation

◆ INTERFACE_PROCESSING_INTERVAL

#define INTERFACE_PROCESSING_INTERVAL
Value:
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442

How frequently do we scan the interfaces for changes to the addresses?

Definition at line 41 of file ats_api_scheduling.c.

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "ats-scheduling-api", __VA_ARGS__)

◆ NOT_FOUND

#define NOT_FOUND   0

Session ID we use if there is no session / slot.

Definition at line 49 of file ats_api_scheduling.c.

Referenced by find_empty_session_slot(), find_session_id(), GNUNET_ATS_address_add(), and release_session().

Function Documentation

◆ reconnect()

static void reconnect ( struct GNUNET_ATS_SchedulingHandle sh)
static

Re-establish the connection to the ATS service.

Parameters
shhandle to use to re-connect.

Definition at line 512 of file ats_api_scheduling.c.

References GNUNET_ATS_SchedulingHandle::cfg, error_handler(), force_reconnect(), GNUNET_assert, GNUNET_break, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION, GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE, GNUNET_MESSAGE_TYPE_ATS_START, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg, GNUNET_MQ_send(), init, GNUNET_ATS_SchedulingHandle::mq, send_add_address_message(), GNUNET_ATS_SchedulingHandle::session_array, GNUNET_ATS_SchedulingHandle::session_array_size, ClientStartMessage::start_flag, and START_FLAG_SCHEDULING.

Referenced by GNUNET_ATS_scheduling_init(), and reconnect_task().

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);
539  force_reconnect (sh);
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;
553  send_add_address_message (sh, ar);
554  if (NULL == sh->mq)
555  return;
556  }
557 }
#define GNUNET_MESSAGE_TYPE_ATS_START
Type of the &#39;struct ClientStartMessage&#39; sent by clients to ATS to identify the type of the client...
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.
struct GNUNET_ATS_AddressRecord ** session_array
Array of session objects (we need to translate them to numbers and back for the protocol; the offset ...
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:1057
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
uint32_t start_flag
NBO value of an enum StartFlag.
Definition: ats.h:79
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION
Type of the &#39;struct AddressSuggestionMessage&#39; sent by ATS to clients to suggest switching to a differ...
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE
Type of the &#39;struct SessionReleaseMessage&#39; sent by ATS to client to confirm that a session ID was des...
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
This is a scheduling client (aka transport service)
Definition: ats.h:42
unsigned int session_array_size
Size of the session_array.
Information we track per address, incoming or outgoing.
static void error_handler(void *cls, enum GNUNET_MQ_Error error)
We encountered an error handling the MQ to the ATS service.
Message handler for a specific message type.
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
ATS Service suggests to the transport service to use the address identified by the given session_id f...
Definition: ats.h:243
struct GNUNET_MQ_Handle * mq
Message queue for sending requests to the ATS service.
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:353
Message sent by ATS service to client to confirm that it is done using the given session ID...
Definition: ats.h:217
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
First message any client sends to ATS, used to self-identify (what type of client this is)...
Definition: ats.h:69
static void force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Disconnect from ATS and then reconnect.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reconnect_task()

static void reconnect_task ( void *  cls)
static

Re-establish the connection to the ATS service.

Parameters
clshandle to use to re-connect.

Definition at line 164 of file ats_api_scheduling.c.

References reconnect(), GNUNET_ATS_AddressRecord::sh, and GNUNET_ATS_SchedulingHandle::task.

Referenced by force_reconnect().

165 {
166  struct GNUNET_ATS_SchedulingHandle *sh = cls;
167 
168  sh->task = NULL;
169  reconnect (sh);
170 }
struct GNUNET_SCHEDULER_Task * task
Task to trigger reconnect.
Handle to the ATS subsystem for bandwidth/transport scheduling information.
static struct SolverHandle * sh
static void reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Re-establish the connection to the ATS service.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ force_reconnect()

static void force_reconnect ( struct GNUNET_ATS_SchedulingHandle sh)
static

Disconnect from ATS and then reconnect.

Parameters
shour handle

Definition at line 179 of file ats_api_scheduling.c.

References GNUNET_ATS_SchedulingHandle::backoff, GNUNET_BANDWIDTH_ZERO, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_ATS_SchedulingHandle::mq, reconnect_task(), GNUNET_ATS_SchedulingHandle::suggest_cb, GNUNET_ATS_SchedulingHandle::suggest_cb_cls, and GNUNET_ATS_SchedulingHandle::task.

Referenced by error_handler(), handle_ats_address_suggestion(), reconnect(), and release_session().

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,
193  sh);
194 }
struct GNUNET_SCHEDULER_Task * task
Task to trigger reconnect.
GNUNET_ATS_AddressSuggestionCallback suggest_cb
Callback to invoke on suggestions.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
void * suggest_cb_cls
Closure for suggest_cb.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
struct GNUNET_TIME_Relative backoff
Reconnect backoff delay.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
struct GNUNET_MQ_Handle * mq
Message queue for sending requests to the ATS service.
static void reconnect_task(void *cls)
Re-establish the connection to the ATS service.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_session()

static struct GNUNET_ATS_AddressRecord* find_session ( struct GNUNET_ATS_SchedulingHandle sh,
uint32_t  session_id,
const struct GNUNET_PeerIdentity peer 
)
static

Find the session object corresponding to the given session ID.

Parameters
shour handle
session_idcurrent session ID
peerpeer the session belongs to
Returns
the session object (or NULL)

Definition at line 206 of file ats_api_scheduling.c.

References GNUNET_ATS_AddressRecord::address, GNUNET_break, GNUNET_memcmp, GNUNET_HELLO_Address::peer, GNUNET_ATS_SchedulingHandle::session_array, GNUNET_ATS_SchedulingHandle::session_array_size, and session_id.

Referenced by handle_ats_address_suggestion().

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 }
struct GNUNET_ATS_AddressRecord ** session_array
Array of session objects (we need to translate them to numbers and back for the protocol; the offset ...
static struct GNUNET_HashCode session_id
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
unsigned int session_array_size
Size of the session_array.
Information we track per address, incoming or outgoing.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_HELLO_Address * address
Address data.
Here is the caller graph for this function:

◆ find_empty_session_slot()

static uint32_t find_empty_session_slot ( struct GNUNET_ATS_SchedulingHandle sh)
static

Get an available session ID.

Parameters
shour handle
Returns
an unused slot, but never NOT_FOUND (0)

Definition at line 248 of file ats_api_scheduling.c.

References GNUNET_array_grow, GNUNET_assert, NOT_FOUND, GNUNET_ATS_SchedulingHandle::session_array, and GNUNET_ATS_SchedulingHandle::session_array_size.

Referenced by GNUNET_ATS_address_add().

249 {
250  static uint32_t off;
251  uint32_t i;
252 
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;
267  sh->session_array_size,
268  sh->session_array_size * 2);
269  return i;
270 }
struct GNUNET_ATS_AddressRecord ** session_array
Array of session objects (we need to translate them to numbers and back for the protocol; the offset ...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define NOT_FOUND
Session ID we use if there is no session / slot.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
unsigned int session_array_size
Size of the session_array.
Here is the caller graph for this function:

◆ find_session_id()

static uint32_t find_session_id ( struct GNUNET_ATS_SchedulingHandle sh,
struct GNUNET_ATS_Session session,
const struct GNUNET_HELLO_Address address 
)
static

Get the ID for the given session object.

Parameters
shour handle
sessionsession object
addressthe address we are looking for
Returns
the session id or NOT_FOUND for error

Definition at line 282 of file ats_api_scheduling.c.

References GNUNET_ATS_AddressRecord::address, GNUNET_break, GNUNET_HELLO_address_cmp(), GNUNET_memcmp, GNUNET_NO, GNUNET_ATS_AddressRecord::in_destroy, NOT_FOUND, GNUNET_HELLO_Address::peer, GNUNET_ATS_AddressRecord::session, GNUNET_ATS_SchedulingHandle::session_array, and GNUNET_ATS_SchedulingHandle::session_array_size.

Referenced by GNUNET_ATS_address_add().

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)) &&
300  (0 == GNUNET_HELLO_address_cmp (address,
301  sh->session_array[i]->address)))
302  return i;
303  return NOT_FOUND;
304 }
struct GNUNET_ATS_AddressRecord ** session_array
Array of session objects (we need to translate them to numbers and back for the protocol; the offset ...
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_ATS_Session * session
Session handle.
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
#define NOT_FOUND
Session ID we use if there is no session / slot.
unsigned int session_array_size
Size of the session_array.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_HELLO_Address * address
Address data.
int in_destroy
We&#39;re about to destroy this address record, just ATS does not know this yet.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ release_session()

static void release_session ( struct GNUNET_ATS_SchedulingHandle sh,
uint32_t  session_id 
)
static

Release the session slot from the session table (ATS service is also done using it).

Parameters
shour handle
session_ididentifies session that is no longer valid

Definition at line 315 of file ats_api_scheduling.c.

References GNUNET_ATS_AddressRecord::address, force_reconnect(), GNUNET_break, GNUNET_free, GNUNET_HELLO_address_free, NOT_FOUND, GNUNET_ATS_AddressRecord::session, GNUNET_ATS_SchedulingHandle::session_array, GNUNET_ATS_SchedulingHandle::session_array_size, and session_id.

Referenced by handle_ats_session_release().

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);
325  force_reconnect (sh);
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);
333  force_reconnect (sh);
334  return;
335  }
337  GNUNET_free (ar);
338  sh->session_array[session_id] = NULL;
339 }
struct GNUNET_ATS_AddressRecord ** session_array
Array of session objects (we need to translate them to numbers and back for the protocol; the offset ...
static struct GNUNET_HashCode 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_ATS_Session * session
Session handle.
#define NOT_FOUND
Session ID we use if there is no session / slot.
unsigned int session_array_size
Size of the session_array.
Information we track per address, incoming or outgoing.
struct GNUNET_HELLO_Address * address
Address data.
#define GNUNET_HELLO_address_free(addr)
Free an address.
#define GNUNET_free(ptr)
Wrapper around free.
static void force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Disconnect from ATS and then reconnect.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_ats_session_release()

static void handle_ats_session_release ( void *  cls,
const struct GNUNET_ATS_SessionReleaseMessage srm 
)
static

Type of a function to call when we receive a session release message from the service.

Parameters
clsthe struct GNUNET_ATS_SchedulingHandle
srmmessage received

Definition at line 350 of file ats_api_scheduling.c.

References release_session(), GNUNET_ATS_SessionReleaseMessage::session_id, and GNUNET_ATS_AddressRecord::sh.

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 */
357  release_session (sh,
358  ntohl (srm->session_id));
359 }
Handle to the ATS subsystem for bandwidth/transport scheduling information.
uint32_t session_id
Number the client used to identify the session.
Definition: ats.h:227
static struct SolverHandle * sh
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).
Here is the call graph for this function:

◆ handle_ats_address_suggestion()

static void handle_ats_address_suggestion ( void *  cls,
const struct AddressSuggestionMessage m 
)
static

Type of a function to call when we receive a address suggestion message from the service.

Parameters
clsthe struct GNUNET_ATS_SchedulingHandle
mmessage received

Definition at line 370 of file ats_api_scheduling.c.

References GNUNET_ATS_AddressRecord::address, GNUNET_ATS_SchedulingHandle::backoff, AddressSuggestionMessage::bandwidth_in, AddressSuggestionMessage::bandwidth_out, find_session(), force_reconnect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GNUNET_ATS_AddressRecord::in_destroy, LOG, AddressSuggestionMessage::peer, GNUNET_HELLO_Address::peer, GNUNET_ATS_AddressRecord::session, session_id, AddressSuggestionMessage::session_id, GNUNET_ATS_AddressRecord::sh, GNUNET_ATS_AddressRecord::slot, GNUNET_ATS_SchedulingHandle::suggest_cb, GNUNET_ATS_SchedulingHandle::suggest_cb_cls, GNUNET_HELLO_Address::transport_name, and GNUNET_BANDWIDTH_Value32NBO::value__.

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);
381  force_reconnect (sh);
382  return;
383  }
384  ar = find_session (sh,
385  session_id,
386  &m->peer);
387  if (NULL == ar)
388  {
389  GNUNET_break (0);
390  force_reconnect (sh);
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  }
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 }
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.
Handle to the ATS subsystem for bandwidth/transport scheduling information.
GNUNET_ATS_AddressSuggestionCallback suggest_cb
Callback to invoke on suggestions.
static struct GNUNET_HashCode session_id
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
How much bandwidth we are allowed for receiving.
Definition: ats.h:271
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
How much bandwidth we are allowed for sending.
Definition: ats.h:266
#define LOG(kind,...)
uint32_t session_id
Internal number this client uses to refer to the address this suggestion is about.
Definition: ats.h:254
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t value__
The actual value (bytes per second).
struct GNUNET_ATS_Session * session
Session handle.
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
void * suggest_cb_cls
Closure for suggest_cb.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
static struct SolverHandle * sh
const char * transport_name
Name of the transport plugin enabling the communication using this address.
Information we track per address, incoming or outgoing.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_TIME_Relative backoff
Reconnect backoff delay.
struct GNUNET_HELLO_Address * address
Address data.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_PeerIdentity peer
Which peer is this about? (Technically redundant, as the session_id should be sufficient, but may enable client to find the session faster and/or check consistency).
Definition: ats.h:261
int in_destroy
We&#39;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...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Disconnect from ATS and then reconnect.
Here is the call graph for this function:

◆ error_handler()

static void error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

We encountered an error handling the MQ to the ATS service.

Reconnect.

Parameters
clsthe struct GNUNET_ATS_SchedulingHandle
errordetails about the error

Definition at line 446 of file ats_api_scheduling.c.

References force_reconnect(), GNUNET_ERROR_TYPE_DEBUG, LOG, and GNUNET_ATS_AddressRecord::sh.

Referenced by reconnect().

448 {
449  struct GNUNET_ATS_SchedulingHandle *sh = cls;
450 
452  "ATS connection died (code %d), reconnecting\n",
453  (int) error);
454  force_reconnect (sh);
455 }
Handle to the ATS subsystem for bandwidth/transport scheduling information.
#define LOG(kind,...)
static struct SolverHandle * sh
static void force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
Disconnect from ATS and then reconnect.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_add_address_message()

static void send_add_address_message ( struct GNUNET_ATS_SchedulingHandle sh,
const struct GNUNET_ATS_AddressRecord ar 
)
static

Generate and transmit the struct AddressAddMessage for the given address record.

Parameters
shthe scheduling handle to use for transmission
arthe address to inform the ATS service about

Definition at line 466 of file ats_api_scheduling.c.

References GNUNET_ATS_AddressRecord::address, GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, AddressAddMessage::address_length, AddressAddMessage::address_local_info, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NT_UNSPECIFIED, GNUNET_HELLO_Address::local_info, LOG, m, GNUNET_ATS_SchedulingHandle::mq, AddressAddMessage::peer, GNUNET_HELLO_Address::peer, AddressAddMessage::plugin_name_length, pm, GNUNET_ATS_AddressRecord::properties, AddressAddMessage::properties, GNUNET_ATS_PropertiesNBO::scope, GNUNET_ATS_AddressRecord::session, AddressAddMessage::session_id, GNUNET_ATS_AddressRecord::slot, and GNUNET_HELLO_Address::transport_name.

Referenced by GNUNET_ATS_address_add(), and reconnect().

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 }
size_t address_length
Number of bytes in address.
uint16_t address_length
Number of bytes in the address that follows this struct.
Definition: ats.h:121
enum GNUNET_HELLO_AddressInfo local_info
Extended information about address.
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_PeerIdentity peer
Identity of the peer that this address is for.
Definition: ats.h:131
struct GNUNET_ATS_PropertiesNBO properties
Performance properties of the address.
Definition: ats.h:148
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint32_t scope
Which network scope does the respective address belong to? This property does not change...
#define LOG(kind,...)
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_ATS_Session * session
Session handle.
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
#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
const char * transport_name
Name of the transport plugin enabling the communication using this address.
uint16_t plugin_name_length
Number of bytes in the plugin name that follows this struct.
Definition: ats.h:126
struct GNUNET_ATS_PropertiesNBO properties
Performance data about the address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
uint32_t address_local_info
Local-only information of the address, see enum GNUNET_HELLO_AddressInfo.
Definition: ats.h:143
struct GNUNET_MQ_Handle * mq
Message queue for sending requests to the ATS service.
struct GNUNET_HELLO_Address * address
Address data.
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:353
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD
Type of the &#39;struct AddressUpdateMessage&#39; sent by client to ATS to add a new address.
uint32_t session_id
Internal number this client will henceforth use to refer to this address.
Definition: ats.h:137
uint32_t slot
Which slot (index) in the session array does this record correspond to? FIXME: a linear search on thi...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
Category of last resort.
Definition: gnunet_nt_lib.h:40
Scheduling client to ATS service: here is another address you can use.
Definition: ats.h:111
Here is the call graph for this function:
Here is the caller graph for this function: