GNUnet  0.11.x
Data Structures | Macros | Functions
ats_api_performance.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_performance.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_ATS_ReservationContext
 Linked list of pending reservations. More...
 
struct  GNUNET_ATS_AddressListHandle
 Linked list of pending reservations. More...
 
struct  GNUNET_ATS_PerformanceHandle
 ATS Handle to obtain and/or modify performance information. More...
 

Macros

#define LOG(kind, ...)
 

Functions

static void reconnect (struct GNUNET_ATS_PerformanceHandle *ph)
 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 do_reconnect (struct GNUNET_ATS_PerformanceHandle *ph)
 Reconnect to the ATS service, something went wrong. More...
 
static int check_peer_information (void *cls, const struct PeerInformationMessage *pi)
 We received a peer information message. More...
 
static void handle_peer_information (void *cls, const struct PeerInformationMessage *pi)
 We received a peer information message. More...
 
static void handle_reservation_result (void *cls, const struct ReservationResultMessage *rr)
 We received a reservation result message. More...
 
static int check_address_list (void *cls, const struct PeerInformationMessage *pi)
 We received a PeerInformationMessage. More...
 
static void handle_address_list (void *cls, const struct PeerInformationMessage *pi)
 We received a GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE. More...
 
static void mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
 
struct GNUNET_ATS_PerformanceHandleGNUNET_ATS_performance_init (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressInformationCallback addr_info_cb, void *addr_info_cb_cls)
 Get handle to access performance API of the ATS subsystem. More...
 
void GNUNET_ATS_performance_done (struct GNUNET_ATS_PerformanceHandle *ph)
 Client is done using the ATS performance subsystem, release resources. More...
 
struct GNUNET_ATS_ReservationContextGNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int32_t amount, GNUNET_ATS_ReservationCallback rcb, void *rcb_cls)
 Reserve inbound bandwidth from the given peer. More...
 
void GNUNET_ATS_reserve_bandwidth_cancel (struct GNUNET_ATS_ReservationContext *rc)
 Cancel request for reserving bandwidth. More...
 
struct GNUNET_ATS_AddressListHandleGNUNET_ATS_performance_list_addresses (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int all, GNUNET_ATS_AddressInformationCallback infocb, void *infocb_cls)
 Get information about addresses known to the ATS subsystem. More...
 
void GNUNET_ATS_performance_list_addresses_cancel (struct GNUNET_ATS_AddressListHandle *alh)
 Cancel a pending address listing operation. More...
 
const char * GNUNET_ATS_print_preference_type (enum GNUNET_ATS_PreferenceKind type)
 Convert a enum GNUNET_ATS_PreferenceType to a string. More...
 
void GNUNET_ATS_performance_change_preference (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer,...)
 Change preferences for the given peer. More...
 
void GNUNET_ATS_performance_give_feedback (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TIME_Relative scope,...)
 Send feedback to ATS on how good a the requirements for a peer and a preference is satisfied by ATS. More...
 

Detailed Description

automatic transport selection and outbound bandwidth determination

Author
Christian Grothoff
Matthias Wachs

Definition in file ats_api_performance.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)
Value:
GNUNET_log_from (kind, "ats-performance-api", \
__VA_ARGS__)
#define GNUNET_log_from(kind, comp,...)

Definition at line 31 of file ats_api_performance.c.

Function Documentation

◆ reconnect()

static void reconnect ( struct GNUNET_ATS_PerformanceHandle ph)
static

Re-establish the connection to the ATS service.

Parameters
phhandle to use to re-connect.

Definition at line 565 of file ats_api_performance.c.

566 {
568  GNUNET_MQ_hd_var_size (peer_information,
570  struct PeerInformationMessage,
571  ph),
572  GNUNET_MQ_hd_fixed_size (reservation_result,
575  ph),
576  GNUNET_MQ_hd_var_size (address_list,
578  struct PeerInformationMessage,
579  ph),
581  };
582  struct GNUNET_MQ_Envelope *env;
583  struct ClientStartMessage *init;
584 
585  GNUNET_assert (NULL == ph->mq);
587  "ats",
588  handlers,
590  ph);
591  if (NULL == ph->mq)
592  return;
595  init->start_flag = htonl ((NULL == ph->addr_info_cb)
598  GNUNET_MQ_send (ph->mq,
599  env);
600 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
@ START_FLAG_PERFORMANCE_NO_PIC
Performance monitoring client that does NOT want to learn about changes in performance characteristic...
Definition: ats.h:54
@ START_FLAG_PERFORMANCE_WITH_PIC
Performance monitoring client that wants to learn about changes in performance characteristics.
Definition: ats.h:48
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
static struct GNUNET_ATS_PerformanceHandle * ph
ATS performance handle used.
Definition: gnunet-ats.c:116
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
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_assert(cond)
Use this for fatal errors that cannot be handled.
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(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#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_RESERVATION_RESULT
Type of the 'struct ReservationResultMessage' sent by ATS to clients in response to a reservation req...
#define GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION
Type of the 'struct PeerInformationMessage' sent by ATS to clients to inform about QoS for a particul...
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE
Type of the 'struct AddressListResponseMessage' sent by ATS to client with information about addresse...
First message any client sends to ATS, used to self-identify (what type of client this is).
Definition: ats.h:70
struct GNUNET_MQ_Handle * mq
Connection to ATS service.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
GNUNET_ATS_AddressInformationCallback addr_info_cb
Callback to invoke when an address has performance changes.
Message handler for a specific message type.

References GNUNET_ATS_PerformanceHandle::addr_info_cb, GNUNET_ATS_PerformanceHandle::cfg, env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE, GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION, GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT, GNUNET_MESSAGE_TYPE_ATS_START, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), handlers, init, GNUNET_ATS_PerformanceHandle::mq, mq_error_handler(), ph, START_FLAG_PERFORMANCE_NO_PIC, and START_FLAG_PERFORMANCE_WITH_PIC.

Referenced by GNUNET_ATS_performance_init(), handle_reservation_result(), and reconnect_task().

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 225 of file ats_api_performance.c.

226 {
227  struct GNUNET_ATS_PerformanceHandle *ph = cls;
228 
229  ph->task = NULL;
230  reconnect (ph);
231 }
static void reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
Re-establish the connection to the ATS service.
ATS Handle to obtain and/or modify performance information.
struct GNUNET_SCHEDULER_Task * task
Task to trigger reconnect.

References ph, reconnect(), and GNUNET_ATS_PerformanceHandle::task.

Referenced by do_reconnect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_reconnect()

static void do_reconnect ( struct GNUNET_ATS_PerformanceHandle ph)
static

Reconnect to the ATS service, something went wrong.

Parameters
phhandle to reconnect

Definition at line 240 of file ats_api_performance.c.

241 {
244  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_zero;
245 
246  if (NULL != ph->mq)
247  {
249  ph->mq = NULL;
250  }
251  while (NULL != (rc = ph->reservation_head))
252  {
255  rc);
256  if (NULL != rc->rcb)
257  rc->rcb (rc->rcb_cls,
258  NULL,
259  0,
261  GNUNET_free (rc);
262  }
263  bandwidth_zero.value__ = htonl (0);
264  while (NULL != (alh = ph->addresslist_head))
265  {
268  alh);
269  if (NULL != alh->cb)
270  alh->cb (alh->cb_cls,
271  NULL,
272  GNUNET_NO,
273  bandwidth_zero,
274  bandwidth_zero,
275  NULL);
276  GNUNET_free (alh);
277  }
278  if (NULL != ph->addr_info_cb)
279  {
280  /* Indicate reconnect */
282  NULL,
283  GNUNET_NO,
284  bandwidth_zero,
285  bandwidth_zero,
286  NULL);
287  }
291  ph);
292 }
static void reconnect_task(void *cls)
Re-establish the connection to the ATS service.
static struct GNUNET_ATS_AddressListHandle * alh
ATS address list handle used.
Definition: gnunet-ats.c:131
@ GNUNET_NO
Definition: gnunet_common.h:94
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
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_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Linked list of pending reservations.
GNUNET_ATS_AddressInformationCallback cb
Callback.
void * cb_cls
Callback closure for cb.
void * addr_info_cb_cls
Closure for addr_info_cb.
struct GNUNET_ATS_AddressListHandle * addresslist_head
Head of linked list of pending address list requests.
struct GNUNET_ATS_AddressListHandle * addresslist_tail
Tail of linked list of pending address list requests.
struct GNUNET_ATS_ReservationContext * reservation_tail
Tail of linked list of pending reservation requests.
struct GNUNET_ATS_ReservationContext * reservation_head
Head of linked list of pending reservation requests.
struct GNUNET_TIME_Relative backoff
Reconnect backoff delay.
Linked list of pending reservations.
GNUNET_ATS_ReservationCallback rcb
Function to call on result.
void * rcb_cls
Closure for rcb.
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.

References GNUNET_ATS_PerformanceHandle::addr_info_cb, GNUNET_ATS_PerformanceHandle::addr_info_cb_cls, GNUNET_ATS_PerformanceHandle::addresslist_head, GNUNET_ATS_PerformanceHandle::addresslist_tail, alh, GNUNET_ATS_PerformanceHandle::backoff, GNUNET_ATS_AddressListHandle::cb, GNUNET_ATS_AddressListHandle::cb_cls, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_ATS_PerformanceHandle::mq, ph, GNUNET_ATS_ReservationContext::rcb, GNUNET_ATS_ReservationContext::rcb_cls, reconnect_task(), GNUNET_ATS_PerformanceHandle::reservation_head, GNUNET_ATS_PerformanceHandle::reservation_tail, GNUNET_ATS_PerformanceHandle::task, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by mq_error_handler().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_peer_information()

static int check_peer_information ( void *  cls,
const struct PeerInformationMessage pi 
)
static

We received a peer information message.

Validate and process it.

Parameters
clsour context with the callback
pithe message
Returns
GNUNET_OK if the message was well-formed

Definition at line 303 of file ats_api_performance.c.

305 {
306  const char *plugin_address;
307  const char *plugin_name;
308  uint16_t plugin_address_length;
309  uint16_t plugin_name_length;
310 
311  plugin_address_length = ntohs (pi->address_length);
312  plugin_name_length = ntohs (pi->plugin_name_length);
313  plugin_address = (const char *) &pi[1];
314  plugin_name = &plugin_address[plugin_address_length];
315  if ((plugin_address_length + plugin_name_length
316  + sizeof(struct PeerInformationMessage) != ntohs (pi->header.size)) ||
317  (plugin_name[plugin_name_length - 1] != '\0'))
318  {
319  GNUNET_break (0);
320  return GNUNET_SYSERR;
321  }
322  return GNUNET_OK;
323 }
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static char * plugin_name
Name of our plugin.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, pi, and plugin_name.

◆ handle_peer_information()

static void handle_peer_information ( void *  cls,
const struct PeerInformationMessage pi 
)
static

We received a peer information message.

Validate and process it.

Parameters
clsour context with the callback
pithe message
Returns
GNUNET_OK if the message was well-formed

Definition at line 334 of file ats_api_performance.c.

336 {
337  struct GNUNET_ATS_PerformanceHandle *ph = cls;
338  const char *plugin_address;
339  const char *plugin_name;
341  uint16_t plugin_address_length;
342  int addr_active;
343  struct GNUNET_ATS_Properties prop;
344 
345  if (NULL == ph->addr_info_cb)
346  return;
347  plugin_address_length = ntohs (pi->address_length);
348  addr_active = (int) ntohl (pi->address_active);
349  plugin_address = (const char *) &pi[1];
350  plugin_name = &plugin_address[plugin_address_length];
351 
353  &pi->properties);
354  address.peer = pi->peer;
355  address.local_info = (enum GNUNET_HELLO_AddressInfo) ntohl (
356  pi->address_local_info);
357  address.address = plugin_address;
358  address.address_length = plugin_address_length;
359  address.transport_name = plugin_name;
361  &address,
362  addr_active,
363  pi->bandwidth_out,
364  pi->bandwidth_in,
365  &prop);
366 }
static char * address
GNS address for this phone.
void GNUNET_ATS_properties_ntoh(struct GNUNET_ATS_Properties *hbo, const struct GNUNET_ATS_PropertiesNBO *nbo)
Convert ATS properties from network to host byte order.
GNUNET_HELLO_AddressInfo
Additional local information about an address.
ATS performance characteristics for an address.
An address for communicating with a peer.

References GNUNET_ATS_PerformanceHandle::addr_info_cb, GNUNET_ATS_PerformanceHandle::addr_info_cb_cls, address, GNUNET_ATS_properties_ntoh(), consensus-simulation::int, ph, pi, and plugin_name.

Here is the call graph for this function:

◆ handle_reservation_result()

static void handle_reservation_result ( void *  cls,
const struct ReservationResultMessage rr 
)
static

We received a reservation result message.

Validate and process it.

Parameters
clsour context with the callback
rrthe message

Definition at line 376 of file ats_api_performance.c.

378 {
379  struct GNUNET_ATS_PerformanceHandle *ph = cls;
381  int32_t amount;
382 
383  amount = ntohl (rr->amount);
384  rc = ph->reservation_head;
385  if (0 != GNUNET_memcmp (&rr->peer,
386  &rc->peer))
387  {
388  GNUNET_break (0);
389  reconnect (ph);
390  return;
391  }
394  rc);
395  if ((0 == amount) ||
396  (NULL != rc->rcb))
397  {
398  /* tell client if not cancelled */
399  if (NULL != rc->rcb)
400  rc->rcb (rc->rcb_cls,
401  &rr->peer,
402  amount,
404  GNUNET_free (rc);
405  return;
406  }
407  /* amount non-zero, but client cancelled, consider undo! */
408  if (GNUNET_YES != rc->undo)
409  {
410  GNUNET_free (rc);
411  return; /* do not try to undo failed undos or negative amounts */
412  }
413  GNUNET_free (rc);
415  &rr->peer,
416  -amount,
417  NULL, NULL);
418 }
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_YES
Definition: gnunet_common.h:97
struct GNUNET_ATS_ReservationContext * GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int32_t amount, GNUNET_ATS_ReservationCallback rcb, void *rcb_cls)
Reserve inbound bandwidth from the given peer.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:454
struct GNUNET_PeerIdentity peer
Target peer.
int undo
Do we need to undo this reservation if it succeeded? Set to GNUNET_YES if a reservation is cancelled.
struct GNUNET_TIME_RelativeNBO res_delay
Definition: ats.h:411
struct GNUNET_PeerIdentity peer
Definition: ats.h:406

References ReservationResultMessage::amount, GNUNET_ATS_reserve_bandwidth(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_memcmp, GNUNET_TIME_relative_ntoh(), GNUNET_YES, ReservationResultMessage::peer, GNUNET_ATS_ReservationContext::peer, ph, GNUNET_ATS_ReservationContext::rcb, GNUNET_ATS_ReservationContext::rcb_cls, reconnect(), ReservationResultMessage::res_delay, GNUNET_ATS_PerformanceHandle::reservation_head, GNUNET_ATS_PerformanceHandle::reservation_tail, and GNUNET_ATS_ReservationContext::undo.

Here is the call graph for this function:

◆ check_address_list()

static int check_address_list ( void *  cls,
const struct PeerInformationMessage pi 
)
static

We received a PeerInformationMessage.

Validate it.

Parameters
clsour context with the callback
pithe message
Returns
GNUNET_OK if the message was well-formed

Definition at line 429 of file ats_api_performance.c.

431 {
432  const char *plugin_address;
433  const char *plugin_name;
434  uint16_t plugin_address_length;
435  uint16_t plugin_name_length;
436 
437  plugin_address_length = ntohs (pi->address_length);
438  plugin_name_length = ntohs (pi->plugin_name_length);
439  plugin_address = (const char *) &pi[1];
440  plugin_name = &plugin_address[plugin_address_length];
441  if ((plugin_address_length + plugin_name_length
442  + sizeof(struct PeerInformationMessage) != ntohs (pi->header.size)) ||
443  (plugin_name[plugin_name_length - 1] != '\0'))
444  {
445  GNUNET_break (0);
446  return GNUNET_SYSERR;
447  }
448  return GNUNET_OK;
449 }

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, pi, and plugin_name.

◆ handle_address_list()

static void handle_address_list ( void *  cls,
const struct PeerInformationMessage pi 
)
static

We received a GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE.

Process it.

Parameters
clsour context with the callback
pithe message

Definition at line 460 of file ats_api_performance.c.

462 {
463  struct GNUNET_ATS_PerformanceHandle *ph = cls;
466  const char *plugin_address;
467  const char *plugin_name;
469  struct GNUNET_PeerIdentity allzeros;
470  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_zero;
471  struct GNUNET_ATS_Properties prop;
472  uint16_t plugin_address_length;
473  uint16_t plugin_name_length;
474  uint32_t active;
475  uint32_t id;
476 
477  id = ntohl (pi->id);
478  active = ntohl (pi->address_active);
479  plugin_address_length = ntohs (pi->address_length);
480  plugin_name_length = ntohs (pi->plugin_name_length);
481  plugin_address = (const char *) &pi[1];
482  plugin_name = &plugin_address[plugin_address_length];
484  "Received ATS_ADDRESSLIST_RESPONSE message for peer %s and plugin %s\n",
485  GNUNET_i2s (&pi->peer),
486  plugin_name);
487 
488  next = ph->addresslist_head;
489  while (NULL != (alh = next))
490  {
491  next = alh->next;
492  if (alh->id == id)
493  break;
494  }
495  if (NULL == alh)
496  return; /* was canceled */
497 
498  memset (&allzeros, '\0', sizeof(allzeros));
499  if ((GNUNET_YES == GNUNET_is_zero (&pi->peer)) &&
500  (0 == plugin_name_length) &&
501  (0 == plugin_address_length))
502  {
503  /* Done */
505  "Received last message for ATS_ADDRESSLIST_RESPONSE\n");
506  bandwidth_zero.value__ = htonl (0);
509  alh);
510  if (NULL != alh->cb)
511  alh->cb (alh->cb_cls,
512  NULL,
513  GNUNET_NO,
514  bandwidth_zero,
515  bandwidth_zero,
516  NULL);
517  GNUNET_free (alh);
518  return;
519  }
520 
521  address.peer = pi->peer;
522  address.address = plugin_address;
523  address.address_length = plugin_address_length;
524  address.transport_name = plugin_name;
525  if (((GNUNET_YES == alh->all_addresses) ||
526  (GNUNET_YES == active)) &&
527  (NULL != alh->cb))
528  {
530  &pi->properties);
531  alh->cb (alh->cb_cls,
532  &address,
533  active,
534  pi->bandwidth_out,
535  pi->bandwidth_in,
536  &prop);
537  }
538 }
#define LOG(kind,...)
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_ATS_AddressListHandle * next
Kept in a DLL.
uint32_t id
Request multiplexing.
int all_addresses
Return all or used address only.
The identity of the host (wraps the signing key of the peer).

References address, GNUNET_ATS_PerformanceHandle::addresslist_head, GNUNET_ATS_PerformanceHandle::addresslist_tail, alh, GNUNET_ATS_AddressListHandle::all_addresses, GNUNET_ATS_AddressListHandle::cb, GNUNET_ATS_AddressListHandle::cb_cls, GNUNET_ATS_properties_ntoh(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_is_zero, GNUNET_NO, GNUNET_YES, GNUNET_ATS_AddressListHandle::id, id, LOG, GNUNET_ATS_AddressListHandle::next, ph, pi, plugin_name, and GNUNET_BANDWIDTH_Value32NBO::value__.

Here is the call graph for this function:

◆ mq_error_handler()

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

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsclosure with the struct GNUNET_ATS_PerformanceHandle *
errorerror code

Definition at line 550 of file ats_api_performance.c.

552 {
553  struct GNUNET_ATS_PerformanceHandle *ph = cls;
554 
555  do_reconnect (ph);
556 }
static void do_reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
Reconnect to the ATS service, something went wrong.

References do_reconnect(), and ph.

Referenced by reconnect().

Here is the call graph for this function:
Here is the caller graph for this function: