GNUnet  0.11.x
ats_api_performance.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2010, 2011, 2016 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  */
26 #include "platform.h"
27 #include "gnunet_ats_service.h"
28 #include "ats.h"
29 
30 
31 #define LOG(kind, ...) GNUNET_log_from (kind, "ats-performance-api", \
32  __VA_ARGS__)
33 
34 
39 {
44 
49 
54 
58  int32_t size;
59 
64 
68  void *rcb_cls;
69 
78  int undo;
79 };
80 
81 
86 {
91 
96 
101 
106 
110  void *cb_cls;
111 
116 
121 
126 
130  uint32_t id;
131 };
132 
133 
138 {
143 
148 
153 
158 
163 
168 
173 
178 
182  struct GNUNET_CLIENT_TransmitHandle *th;
183 
188 
193 
197  uint32_t monitor_id;
198 
202  uint32_t id;
203 
208 };
209 
215 static void
217 
218 
224 static void
225 reconnect_task (void *cls)
226 {
227  struct GNUNET_ATS_PerformanceHandle *ph = cls;
228 
229  ph->task = NULL;
230  reconnect (ph);
231 }
232 
233 
239 static void
241 {
244  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_zero;
245 
246  if (NULL != ph->mq)
247  {
248  GNUNET_MQ_destroy (ph->mq);
249  ph->mq = NULL;
250  }
251  while (NULL != (rc = ph->reservation_head))
252  {
254  ph->reservation_tail,
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  {
267  ph->addresslist_tail,
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 }
293 
294 
302 static int
304  const struct PeerInformationMessage *pi)
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 }
324 
325 
333 static void
335  const struct PeerInformationMessage *pi)
336 {
337  struct GNUNET_ATS_PerformanceHandle *ph = cls;
338  const char *plugin_address;
339  const char *plugin_name;
340  struct GNUNET_HELLO_Address address;
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 }
367 
368 
375 static void
377  const struct ReservationResultMessage *rr)
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  }
393  ph->reservation_tail,
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);
414  (void) GNUNET_ATS_reserve_bandwidth (ph,
415  &rr->peer,
416  -amount,
417  NULL, NULL);
418 }
419 
420 
428 static int
430  const struct PeerInformationMessage *pi)
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 }
450 
451 
459 static void
461  const struct PeerInformationMessage *pi)
462 {
463  struct GNUNET_ATS_PerformanceHandle *ph = cls;
466  const char *plugin_address;
467  const char *plugin_name;
468  struct GNUNET_HELLO_Address address;
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 ((0 == 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);
508  ph->addresslist_tail,
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 }
539 
540 
549 static void
550 mq_error_handler (void *cls,
551  enum GNUNET_MQ_Error error)
552 {
553  struct GNUNET_ATS_PerformanceHandle *ph = cls;
554 
555  do_reconnect (ph);
556 }
557 
558 
564 static void
566 {
567  struct GNUNET_MQ_MessageHandler handlers[] = {
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);
586  ph->mq = GNUNET_CLIENT_connect (ph->cfg,
587  "ats",
588  handlers,
590  ph);
591  if (NULL == ph->mq)
592  return;
593  env = GNUNET_MQ_msg (init,
595  init->start_flag = htonl ((NULL == ph->addr_info_cb)
598  GNUNET_MQ_send (ph->mq,
599  env);
600 }
601 
602 
615  void *addr_info_cb_cls)
616 {
618 
620  ph->cfg = cfg;
623  reconnect (ph);
624  if (NULL == ph->mq)
625  {
626  GNUNET_free (ph);
627  return NULL;
628  }
629  return ph;
630 }
631 
632 
638 void
640 {
643 
644  while (NULL != (alh = ph->addresslist_head))
645  {
647  ph->addresslist_tail,
648  alh);
649  GNUNET_free (alh);
650  }
651  while (NULL != (rc = ph->reservation_head))
652  {
654  ph->reservation_tail,
655  rc);
656  GNUNET_break (NULL == rc->rcb);
657  GNUNET_free (rc);
658  }
659  if (NULL != ph->task)
660  {
662  ph->task = NULL;
663  }
664  if (NULL != ph->mq)
665  {
666  GNUNET_MQ_destroy (ph->mq);
667  ph->mq = NULL;
668  }
669  GNUNET_free (ph);
670 }
671 
672 
689  const struct GNUNET_PeerIdentity *peer,
690  int32_t amount,
692  void *rcb_cls)
693 {
695  struct GNUNET_MQ_Envelope *env;
697 
698  if (NULL == ph->mq)
699  return NULL;
701  rc->size = amount;
702  rc->peer = *peer;
703  rc->rcb = rcb;
704  rc->rcb_cls = rcb_cls;
705  if ((NULL != rcb) &&
706  (amount > 0))
707  rc->undo = GNUNET_YES;
709  ph->reservation_tail,
710  rc);
711  env = GNUNET_MQ_msg (m,
713  m->amount = htonl (amount);
714  m->peer = *peer;
715  GNUNET_MQ_send (ph->mq,
716  env);
717  return rc;
718 }
719 
720 
726 void
728 {
729  rc->rcb = NULL;
730 }
731 
732 
747  const struct GNUNET_PeerIdentity *peer,
748  int all,
750  infocb,
751  void *infocb_cls)
752 {
754  struct GNUNET_MQ_Envelope *env;
756 
757  if (NULL == ph->mq)
758  return NULL;
759  if (NULL == infocb)
760  {
761  GNUNET_break (0);
762  return NULL;
763  }
765  alh->id = ph->id++;
766  alh->cb = infocb;
767  alh->cb_cls = infocb_cls;
768  alh->ph = ph;
769  alh->all_addresses = all;
770  if (NULL == peer)
771  {
772  alh->all_peers = GNUNET_YES;
773  }
774  else
775  {
776  alh->all_peers = GNUNET_NO;
777  alh->peer = *peer;
778  }
780  ph->addresslist_tail,
781  alh);
782  env = GNUNET_MQ_msg (m,
784  m->all = htonl (all);
785  m->id = htonl (alh->id);
786  if (NULL != peer)
787  m->peer = *peer;
788  GNUNET_MQ_send (ph->mq,
789  env);
790  return alh;
791 }
792 
793 
799 void
802 {
803  struct GNUNET_ATS_PerformanceHandle *ph = alh->ph;
804 
806  ph->addresslist_tail,
807  alh);
808  GNUNET_free (alh);
809 }
810 
811 
818 const char *
820 {
821  const char *prefs[] = GNUNET_ATS_PreferenceTypeString;
822 
823  if (type < GNUNET_ATS_PREFERENCE_END)
824  return prefs[type];
825  return NULL;
826 }
827 
828 
837 void
840  const struct
842  ...)
843 {
844  struct GNUNET_MQ_Envelope *env;
845  struct ChangePreferenceMessage *m;
846  uint32_t count;
847  struct PreferenceInformation *pi;
848  va_list ap;
849  enum GNUNET_ATS_PreferenceKind kind;
850 
851  if (NULL == ph->mq)
852  return;
853  count = 0;
854  va_start (ap, peer);
855  while (GNUNET_ATS_PREFERENCE_END !=
857  {
858  switch (kind)
859  {
861  count++;
862  (void) va_arg (ap, double);
863  break;
864 
866  count++;
867  (void) va_arg (ap, double);
868  break;
869 
870  default:
871  GNUNET_assert (0);
872  }
873  }
874  va_end (ap);
875  env = GNUNET_MQ_msg_extra (m,
876  count * sizeof(struct PreferenceInformation),
878  m->num_preferences = htonl (count);
879  m->peer = *peer;
880  pi = (struct PreferenceInformation *) &m[1];
881  count = 0;
882  va_start (ap, peer);
883  while (GNUNET_ATS_PREFERENCE_END != (kind =
884  GNUNET_VA_ARG_ENUM (ap,
886  {
887  pi[count].preference_kind = htonl (kind);
888  switch (kind)
889  {
891  pi[count].preference_value = (float) va_arg (ap, double);
892 
893  count++;
894  break;
895 
897  pi[count].preference_value = (float) va_arg (ap, double);
898 
899  count++;
900  break;
901 
902  default:
903  GNUNET_assert (0);
904  }
905  }
906  va_end (ap);
907  GNUNET_MQ_send (ph->mq,
908  env);
909 }
910 
911 
921 void
923  const struct GNUNET_PeerIdentity *peer,
924  const struct GNUNET_TIME_Relative scope,
925  ...)
926 {
927  struct GNUNET_MQ_Envelope *env;
929  uint32_t count;
930  struct PreferenceInformation *pi;
931  va_list ap;
932  enum GNUNET_ATS_PreferenceKind kind;
933 
934  if (NULL == ph->mq)
935  return;
936  count = 0;
937  va_start (ap, scope);
938  while (GNUNET_ATS_PREFERENCE_END !=
940  {
941  switch (kind)
942  {
944  count++;
945  (void) va_arg (ap, double);
946  break;
947 
949  count++;
950  (void) va_arg (ap, double);
951  break;
952 
953  default:
954  GNUNET_assert (0);
955  }
956  }
957  va_end (ap);
958  env = GNUNET_MQ_msg_extra (m,
959  count * sizeof(struct PreferenceInformation),
961  m->scope = GNUNET_TIME_relative_hton (scope);
962  m->num_feedback = htonl (count);
963  m->peer = *peer;
964  pi = (struct PreferenceInformation *) &m[1];
965  count = 0;
966  va_start (ap, scope);
967  while (GNUNET_ATS_PREFERENCE_END != (kind =
968  GNUNET_VA_ARG_ENUM (ap,
970  {
971  pi[count].preference_kind = htonl (kind);
972  switch (kind)
973  {
975  pi[count].preference_value = (float) va_arg (ap, double);
976 
977  count++;
978  break;
979 
981  pi[count].preference_value = (float) va_arg (ap, double);
982 
983  count++;
984  break;
985 
986  default:
987  GNUNET_assert (0);
988  }
989  }
990  va_end (ap);
991  GNUNET_MQ_send (ph->mq,
992  env);
993 }
994 
995 
996 /* end of ats_api_performance.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_PeerIdentity peer
Which peer is the preference being expressed for?
Definition: ats.h:453
size_t address_length
Number of bytes in address.
struct GNUNET_ATS_AddressListHandle * addresslist_tail
Tail of linked list of pending address list requests.
enum GNUNET_HELLO_AddressInfo local_info
Extended information about address.
uint32_t id
Request multiplexing.
#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 const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
uint32_t monitor_id
Monitor request multiplexing.
const void * address
Binary representation of the address (plugin-specific).
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_ATS_ReservationContext * reservation_tail
Tail of linked list of pending reservation requests.
static struct GNUNET_TIME_Relative backoff
How long should we wait to reconnect?
Definition: resolver_api.c:83
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
uint16_t address_length
Definition: ats.h:288
uint32_t start_flag
NBO value of an enum StartFlag.
Definition: ats.h:79
GNUNET_MQ_Error
Error codes for the queue.
int all_addresses
Return all or used address only.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_ATS_AddressListHandle * addresslist_head
Head of linked list of pending address list requests.
static struct GNUNET_ATS_PerformanceHandle * ph
ATS performance handle used.
Definition: gnunet-ats.c:116
int all_peers
Return all or specific peer only.
struct GNUNET_ATS_ReservationContext * reservation_head
Head of linked list of pending reservation requests.
GNUNET_ATS_ReservationCallback rcb
Function to call on result.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Definition: ats.h:318
struct GNUNET_MQ_Handle * mq
Connection to ATS service.
uint16_t plugin_name_length
Definition: ats.h:293
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION.
Definition: ats.h:283
uint32_t preference_kind
An enum GNUNET_ATS_PreferenceKind in NBO.
Definition: ats.h:424
uint32_t address_local_info
Local-only information of the address, see enum GNUNET_HELLO_AddressInfo.
Definition: ats.h:329
void * rcb_cls
Closure for rcb.
uint32_t id
ID used to match replies to this request.
Definition: ats.h:351
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
Client is done using the ATS performance subsystem, release resources.
static int check_address_list(void *cls, const struct PeerInformationMessage *pi)
We received a PeerInformationMessage.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#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
Performance monitoring client that does NOT want to learn about changes in performance characteristic...
Definition: ats.h:54
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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...
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_ATS_AddressListHandle * next
Kept in a DLL.
void(* GNUNET_ATS_ReservationCallback)(void *cls, const struct GNUNET_PeerIdentity *peer, int32_t amount, struct GNUNET_TIME_Relative res_delay)
Function called with reservation result.
struct GNUNET_ATS_ReservationContext * next
Kept in a DLL.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static void addr_info_cb(void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
Signature of a function that is called with QoS information about an address.
#define GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION
Type of the &#39;struct PeerInformationMessage&#39; sent by ATS to clients to inform about QoS for a particul...
ATS performance characteristics for an address.
struct GNUNET_ATS_PropertiesNBO properties
Performance properties of the address.
Definition: ats.h:323
uint32_t num_feedback
Number of feedback values included.
Definition: ats.h:473
#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:298
Linked list of pending reservations.
GNUNET_ATS_AddressInformationCallback cb
Callback.
End of preference list.
struct GNUNET_CLIENT_TransmitHandle * th
Current request for transmission to ATS.
#define GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST
Type of the &#39;struct AddressListRequestMessage&#39; sent by client to ATS to request information about add...
uint32_t value__
The actual value (bytes per second).
static struct GNUNET_ATS_AddressListHandle * alh
ATS address list handle used.
Definition: gnunet-ats.c:131
struct GNUNET_PeerIdentity peer
Definition: ats.h:406
int undo
Do we need to undo this reservation if it succeeded? Set to GNUNET_YES if a reservation is cancelled...
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
int in_receive
Is the receive loop active?
struct GNUNET_SCHEDULER_Task * task
Task to trigger reconnect.
#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
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
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_BANDWIDTH_Value32NBO bandwidth_out
Definition: ats.h:313
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static enum GNUNET_NetworkType scope
Which network scope do we belong to?
GNUNET_ATS_AddressInformationCallback addr_info_cb
Callback to invoke when an address has performance changes.
void * cb_cls
Callback closure for cb.
struct GNUNET_ATS_PerformanceHandle * ph
Performance handle.
static int check_peer_information(void *cls, const struct PeerInformationMessage *pi)
We received a peer information message.
#define LOG(kind,...)
const char * transport_name
Name of the transport plugin enabling the communication using this address.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:641
static void do_reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
Reconnect to the ATS service, something went wrong.
struct GNUNET_PeerIdentity peer
Peer this feedback is for.
Definition: ats.h:483
Message handler for a specific message type.
void(* GNUNET_ATS_AddressInformationCallback)(void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
Signature of a function that is called with QoS information about an address.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:625
Client to service: please give us an overview of the addresses.
Definition: ats.h:341
uint32_t num_preferences
How many struct PreferenceInformation entries follow this struct?
Definition: ats.h:448
#define GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK
Type of the &#39;struct ChangePreferenceMessage&#39; sent by clients to ATS to ask for allocation preference ...
static void handle_reservation_result(void *cls, const struct ReservationResultMessage *rr)
We received a reservation result message.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
Change the peer&#39;s latency value to the given amount.
struct GNUNET_PeerIdentity peer
Target peer.
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
#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_PeerIdentity peer
For which peer is this an address?
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...
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
static void reconnect_task(void *cls)
Re-establish the connection to the ATS service.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
ATS Handle to obtain and/or modify performance information.
uint32_t id
Request multiplexing.
struct GNUNET_ATS_PerformanceHandle * GNUNET_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.
Handle to a message queue.
Definition: mq.c:85
int32_t all
GNUNET_YES to get information about all addresses, GNUNET_NO to only return addresses that are in use...
Definition: ats.h:362
static void handle_peer_information(void *cls, const struct PeerInformationMessage *pi)
We received a peer information message.
The identity of the host (wraps the signing key of the peer).
Message containing application feedback for a peer.
Definition: ats.h:463
struct GNUNET_TIME_RelativeNBO scope
Relative time describing for which time interval this feedback is.
Definition: ats.h:478
void GNUNET_ATS_reserve_bandwidth_cancel(struct GNUNET_ATS_ReservationContext *rc)
Cancel request for reserving bandwidth.
configuration data
Definition: configuration.c:85
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.
static void reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
Re-establish the connection to the ATS service.
#define GNUNET_VA_ARG_ENUM(va, X)
wrap va_arg for enums
void GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer,...)
Change preferences for the given peer.
An address for communicating with a peer.
struct GNUNET_TIME_Relative backoff
Reconnect backoff delay.
void GNUNET_ATS_performance_list_addresses_cancel(struct GNUNET_ATS_AddressListHandle *alh)
Cancel a pending address listing operation.
Automatic transport selection and outbound bandwidth determination.
Entry in list of pending tasks.
Definition: scheduler.c:134
Change the peer&#39;s bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
Variable-size entry in a struct ChangePreferenceMessage or struct FeedbackPreferenceMessage.
Definition: ats.h:419
struct GNUNET_ATS_AddressListHandle * prev
Kept in a DLL.
Client to ATS: I have a performance preference for a peer.
Definition: ats.h:437
struct GNUNET_ATS_AddressListHandle * GNUNET_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.
#define GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST
Type of the &#39;struct ReservationRequestMessage&#39; sent by clients to ATS to ask for inbound bandwidth re...
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
int32_t size
Desired reservation.
#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:353
#define GNUNET_ATS_PreferenceTypeString
ATS preference types as string array initializer.
GNUNET_ATS_PreferenceKind
Enum defining all known preference categories.
uint32_t address_active
Definition: ats.h:303
struct GNUNET_ATS_ReservationContext * prev
Kept in a DLL.
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...
struct GNUNET_TIME_RelativeNBO res_delay
Definition: ats.h:411
#define GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT
Type of the &#39;struct ReservationResultMessage&#39; sent by ATS to clients in response to a reservation req...
GNUNET_HELLO_AddressInfo
Additional local information about an address.
float preference_value
Degree of preference (or appreciation) for this preference_kind being expressed.
Definition: ats.h:430
void * addr_info_cb_cls
Closure for addr_info_cb.
struct GNUNET_PeerIdentity peer
Which peer do we care about? All zeros for all.
Definition: ats.h:356
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE
Type of the &#39;struct ChangePreferenceMessage&#39; sent by clients to ATS to ask for allocation preference ...
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static char * plugin_name
Name of our plugin.
struct GNUNET_PeerIdentity peer
Definition: ats.h:384
automatic transport selection messages
static void handle_address_list(void *cls, const struct PeerInformationMessage *pi)
We received a GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE.
First message any client sends to ATS, used to self-identify (what type of client this is)...
Definition: ats.h:69
Performance monitoring client that wants to learn about changes in performance characteristics.
Definition: ats.h:48
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_PeerIdentity peer
Target peer.
Linked list of pending reservations.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966