GNUnet  0.10.x
gnunet-service-ats-new.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2011, 2018 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_util_lib.h"
29 #include "gnunet_ats_plugin_new.h"
30 #include "ats2.h"
31 
32 
36 enum ClientType {
40  CT_NONE = 0,
41 
46 
51 };
52 
53 
57 struct Client;
58 
63 {
68 
73 
77  struct Client *client;
78 
82  struct GNUNET_ATS_PreferenceHandle *ph;
83 
88 };
89 
90 
95 {
96 
101 
105  struct Client *client;
106 
111 
115  uint32_t session_id;
116 
117 };
118 
119 
123 struct Client
124 {
129 
134 
139 
143  union {
144 
145  struct {
146 
151 
156 
157  } application;
158 
159  struct {
160 
165 
166  } transport;
167 
168  } details;
169 
170 };
171 
172 
177 
182 
186 static char *plugin_name;
187 
191 static struct Client *transport_client;
192 
193 
202 static void
203 suggest_cb (void *cls,
204  const struct GNUNET_PeerIdentity *pid,
205  const char *address)
206 {
207  struct GNUNET_MQ_Envelope *env;
208  size_t slen = strlen (address) + 1;
209  struct AddressSuggestionMessage *as;
210 
211  if (NULL == transport_client)
212  {
213  // FIXME: stats!
214  return;
215  }
217  "Suggesting address `%s' of peer `%s'\n",
218  address,
219  GNUNET_i2s (pid));
220  env = GNUNET_MQ_msg_extra (as,
221  slen,
223  as->peer = *pid;
224  memcpy (&as[1],
225  address,
226  slen);
227  GNUNET_MQ_send (transport_client->mq,
228  env);
229 }
230 
231 
242 static void
243 allocate_cb (void *cls,
244  struct GNUNET_ATS_Session *session,
245  const struct GNUNET_PeerIdentity *peer,
246  struct GNUNET_BANDWIDTH_Value32NBO bw_in,
247  struct GNUNET_BANDWIDTH_Value32NBO bw_out)
248 {
249  struct GNUNET_MQ_Envelope *env;
250  struct SessionAllocationMessage *sam;
251 
252  (void) cls;
253  if ( (NULL == transport_client) ||
254  (session->client != transport_client) )
255  {
256  /* transport must have just died and solver is addressing the
257  losses of sessions (possibly of previous transport), ignore! */
258  return;
259  }
261  "Allocating %u/%u bytes for %p of peer `%s'\n",
262  ntohl (bw_in.value__),
263  ntohl (bw_out.value__),
264  session,
265  GNUNET_i2s (peer));
266  env = GNUNET_MQ_msg (sam,
268  sam->session_id = session->session_id;
269  sam->peer = *peer;
270  sam->bandwidth_in = bw_in;
271  sam->bandwidth_out = bw_out;
272  GNUNET_MQ_send (transport_client->mq,
273  env);
274 }
275 
276 
283 static void
284 prop_ntoh (const struct PropertiesNBO *properties,
285  struct GNUNET_ATS_Properties *prop)
286 {
287  prop->delay = GNUNET_TIME_relative_ntoh (properties->delay);
288  prop->goodput_out = ntohl (properties->goodput_out);
289  prop->goodput_in = ntohl (properties->goodput_in);
290  prop->utilization_out = ntohl (properties->utilization_out);
291  prop->utilization_in = ntohl (properties->utilization_in);
292  prop->distance = ntohl (properties->distance);
293  prop->mtu = ntohl (properties->mtu);
294  prop->nt = (enum GNUNET_NetworkType) ntohl (properties->nt);
295  prop->cc = (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (properties->cc);
296 }
297 
298 
305 static void
306 handle_suggest (void *cls,
307  const struct ExpressPreferenceMessage *msg)
308 {
309  struct Client *c = cls;
310  struct ClientPreference *cp;
311 
312  if (CT_NONE == c->type)
313  c->type = CT_APPLICATION;
314  if (CT_APPLICATION != c->type)
315  {
316  GNUNET_break (0);
318  return;
319  }
321  "Client suggested we talk to %s with preference %d at rate %u\n",
322  GNUNET_i2s (&msg->peer),
323  (int) ntohl (msg->pk),
324  (int) ntohl (msg->bw.value__));
325  cp = GNUNET_new (struct ClientPreference);
326  cp->client = c;
327  cp->pref.peer = msg->peer;
328  cp->pref.bw = msg->bw;
329  cp->pref.pk = (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk);
330  cp->ph = plugin->preference_add (plugin->cls,
331  &cp->pref);
333  c->details.application.cp_tail,
334  cp);
336 }
337 
338 
345 static void
347  const struct ExpressPreferenceMessage *msg)
348 {
349  struct Client *c = cls;
350  struct ClientPreference *cp;
351 
352  if (CT_NONE == c->type)
353  c->type = CT_APPLICATION;
354  if (CT_APPLICATION != c->type)
355  {
356  GNUNET_break (0);
358  return;
359  }
360  for (cp = c->details.application.cp_head;
361  NULL != cp;
362  cp = cp->next)
363  if ( (cp->pref.pk == (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk)) &&
364  (cp->pref.bw.value__ == msg->bw.value__) &&
365  (0 == GNUNET_memcmp (&cp->pref.peer,
366  &msg->peer)) )
367  break;
368  if (NULL == cp)
369  {
370  GNUNET_break (0);
372  return;
373  }
374  plugin->preference_del (plugin->cls,
375  cp->ph,
376  &cp->pref);
378  c->details.application.cp_tail,
379  cp);
380  GNUNET_free (cp);
382 }
383 
384 
391 static void
392 handle_start (void *cls,
393  const struct GNUNET_MessageHeader *hdr)
394 {
395  struct Client *c = cls;
396 
397  if (CT_NONE != c->type)
398  {
399  GNUNET_break (0);
401  return;
402  }
403  c->type = CT_TRANSPORT;
404  c->details.transport.sessions
406  if (NULL != transport_client)
407  {
408  GNUNET_SERVICE_client_drop (transport_client->client);
409  transport_client = NULL;
410  }
411  transport_client = c;
413 }
414 
415 
424 static int
425 check_session_add (void *cls,
426  const struct SessionAddMessage *message)
427 {
428  struct Client *c = cls;
429 
431  if (CT_TRANSPORT != c->type)
432  {
433  GNUNET_break (0);
434  return GNUNET_SYSERR;
435  }
436  return GNUNET_OK;
437 }
438 
439 
446 static void
448  const struct SessionAddMessage *message)
449 {
450  struct Client *c = cls;
451  const char *address = (const char *) &message[1];
452  struct GNUNET_ATS_Session *session;
454  ntohs (message->header.type));
455 
457  message->session_id);
458  if (NULL != session)
459  {
460  GNUNET_break (0);
462  return;
463  }
464  session = GNUNET_new (struct GNUNET_ATS_Session);
465  session->data.session = session;
466  session->client = c;
467  session->session_id = message->session_id;
468  session->data.peer = message->peer;
469  prop_ntoh (&message->properties,
470  &session->data.prop);
471  session->data.inbound_only = inbound_only;
474  message->session_id,
475  session,
477  session->sh = plugin->session_add (plugin->cls,
478  &session->data,
479  address);
480  GNUNET_assert (NULL != session->sh);
482  "Transport has new session %p to %s\n",
483  session,
484  GNUNET_i2s (&message->peer));
486 }
487 
488 
495 static void
497  const struct SessionUpdateMessage *msg)
498 {
499  struct Client *c = cls;
500  struct GNUNET_ATS_Session *session;
501 
502  if (CT_TRANSPORT != c->type)
503  {
504  GNUNET_break (0);
506  return;
507  }
509  msg->session_id);
510  if (NULL == session)
511  {
512  GNUNET_break (0);
514  return;
515  }
516  prop_ntoh (&msg->properties,
517  &session->data.prop);
518  plugin->session_update (plugin->cls,
519  session->sh,
520  &session->data);
522 }
523 
524 
531 static void
533  const struct SessionDelMessage *message)
534 {
535  struct Client *c = cls;
536  struct GNUNET_ATS_Session *session;
537 
538  if (CT_TRANSPORT != c->type)
539  {
540  GNUNET_break (0);
542  return;
543  }
545  message->session_id);
546  if (NULL == session)
547  {
548  GNUNET_break (0);
550  return;
551  }
552  GNUNET_assert (NULL != session->sh);
553  plugin->session_del (plugin->cls,
554  session->sh,
555  &session->data);
556  session->sh = NULL;
559  session->session_id,
560  session));
562  "Transport lost session %p to %s\n",
563  session,
564  GNUNET_i2s (&session->data.peer));
565  GNUNET_free (session);
567 }
568 
569 
579 static void *
580 client_connect_cb (void *cls,
582  struct GNUNET_MQ_Handle *mq)
583 {
584  struct Client *c = GNUNET_new (struct Client);
585 
586  c->client = client;
587  c->mq = mq;
588  return c;
589 }
590 
591 
600 static int
601 free_session (void *cls,
602  uint32_t key,
603  void *value)
604 {
605  struct Client *c = cls;
606  struct GNUNET_ATS_Session *session = value;
607 
608  (void) key;
609  GNUNET_assert (c == session->client);
610  GNUNET_assert (NULL != session->sh);
611  plugin->session_del (plugin->cls,
612  session->sh,
613  &session->data);
614  session->sh = NULL;
615  GNUNET_free (session);
616  return GNUNET_OK;
617 }
618 
619 
628 static void
631  void *app_ctx)
632 {
633  struct Client *c = app_ctx;
634 
635  (void) cls;
636  GNUNET_assert (c->client == client);
637  switch (c->type)
638  {
639  case CT_NONE:
640  break;
641  case CT_APPLICATION:
642  for (struct ClientPreference *cp = c->details.application.cp_head;
643  NULL != cp;
644  cp = c->details.application.cp_head)
645  {
646  plugin->preference_del (plugin->cls,
647  cp->ph,
648  &cp->pref);
650  c->details.application.cp_tail,
651  cp);
652  GNUNET_free (cp);
653  }
654  break;
655  case CT_TRANSPORT:
656  if (transport_client == c)
657  transport_client = NULL;
659  &free_session,
660  c);
662  break;
663  }
664  GNUNET_free (c);
665 }
666 
667 
673 static void
674 final_cleanup (void *cls)
675 {
676  (void) cls;
677  if (NULL != stats)
678  {
680  GNUNET_NO);
681  stats = NULL;
682  }
683  if (NULL != plugin)
684  {
686  plugin);
687  plugin = NULL;
688  }
689  if (NULL != plugin_name)
690  {
692  plugin_name = NULL;
693  }
694 }
695 
696 
702 static void
703 cleanup_task (void *cls)
704 {
705  (void) cls;
707  "ATS shutdown initiated\n");
709  NULL);
710 }
711 
712 
720 static void
721 run (void *cls,
722  const struct GNUNET_CONFIGURATION_Handle *cfg,
724 {
725  static struct GNUNET_ATS_PluginEnvironment env;
726  char *solver;
727 
728  stats = GNUNET_STATISTICS_create ("ats",
729  cfg);
730  if (GNUNET_SYSERR ==
732  "ats",
733  "SOLVER",
734  &solver))
735  {
737  "No ATS solver configured, using 'simple' approach\n");
738  solver = GNUNET_strdup ("simple");
739  }
741  NULL);
742  env.cls = NULL;
743  env.cfg = cfg;
744  env.stats = stats;
745  env.suggest_cb = &suggest_cb;
746  env.allocate_cb = &allocate_cb;
748  "libgnunet_plugin_ats2_%s",
749  solver);
750  GNUNET_free (solver);
751  if (NULL == (plugin = GNUNET_PLUGIN_load (plugin_name,
752  &env)))
753  {
755  _("Failed to initialize solver `%s'!\n"),
756  plugin_name);
758  return;
759  }
760 }
761 
762 
767 ("ats",
769  &run,
772  NULL,
773  GNUNET_MQ_hd_fixed_size (suggest,
776  NULL),
777  GNUNET_MQ_hd_fixed_size (suggest_cancel,
780  NULL),
783  struct GNUNET_MessageHeader,
784  NULL),
785  GNUNET_MQ_hd_var_size (session_add,
787  struct SessionAddMessage,
788  NULL),
789  GNUNET_MQ_hd_var_size (session_add,
791  struct SessionAddMessage,
792  NULL),
793  GNUNET_MQ_hd_fixed_size (session_update,
795  struct SessionUpdateMessage,
796  NULL),
797  GNUNET_MQ_hd_fixed_size (session_del,
799  struct SessionDelMessage,
800  NULL),
802 
803 
804 /* end of gnunet-service-ats.c */
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Message sent by ATS client to ATS service when an session was destroyed and must thus henceforth no l...
Definition: ats2.h:210
struct Client::@0::@2 transport
static struct GNUNET_STATISTICS_Handle * stats
Handle for statistics.
static void allocate_cb(void *cls, struct GNUNET_ATS_Session *session, const struct GNUNET_PeerIdentity *peer, struct GNUNET_BANDWIDTH_Value32NBO bw_in, struct GNUNET_BANDWIDTH_Value32NBO bw_out)
Function called by the solver to tell the transpor to allocate bandwidth for the specified session...
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
uint32_t cc
What characteristics does this communicator have? A enum GNUNET_TRANSPORT_CommunicatorCharacteristics...
Definition: ats2.h:103
#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...
Information we track per client.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t utilization_in
Actual traffic on this connection from the other peer to this peer.
Definition: ats2.h:78
static void final_cleanup(void *cls)
Task run at the end during shutdown.
struct GNUNET_ATS_Session * session
Handle to the session that has the given properties.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
We don&#39;t know yet.
struct GNUNET_STATISTICS_Handle * stats
Statistics handle to be used by the solver.
struct GNUNET_SERVICE_Client * client
Service handle of the client.
void(* session_update)(void *cls, struct GNUNET_ATS_SessionHandle *sh, const struct GNUNET_ATS_SessionData *data)
data changed for a given sh, solver should consider the updated performance characteristics.
uint32_t goodput_out
Confirmed successful payload on this connection from this peer to the other peer. ...
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
Process template requests.
Handle to a service.
Definition: service.c:116
uint32_t utilization_in
Actual traffic on this connection from the other peer to this peer.
static void handle_session_update(void *cls, const struct SessionUpdateMessage *msg)
Handle &#39;session update&#39; messages from transport clients.
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: ats2.h:255
uint32_t session_id
Internal number this client will henceforth use to refer to this session.
Definition: ats2.h:155
uint32_t session_id
Unique ID for the session when talking with the client.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
struct GNUNET_ATS_SessionHandle * sh
Session state in the plugin.
enum GNUNET_MQ_PreferenceKind pk
What type of performance preference does the client have?
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
Internal representation of a session by the plugin.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_MQ_Handle * mq
Message queue to talk to the client.
struct ClientPreference * prev
DLL pointer.
#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...
static struct GNUNET_TRANSPORT_CoreHandle * transport
Transport service.
enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc
What characteristics does this communicator have?
struct Client * client
Which client expressed the preference?
uint32_t goodput_out
Confirmed successful payload on this connection from this peer to the other peer. ...
Definition: ats2.h:54
#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
struct GNUNET_PeerIdentity peer
Peer the session is with.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int free_session(void *cls, uint32_t key, void *value)
Function called on each session to release associated state on transport disconnect.
Preferences expressed by a client are kept in a DLL per client.
Transport service.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
static struct Client * transport_client
The transport client (there can only be one at a time).
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
Handle for the service.
struct Client::@0::@1 application
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
ATS performance characteristics for an address.
uint32_t session_id
Internal number this client uses to refer to this session.
Definition: ats2.h:188
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
#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_ADD_INBOUND_ONLY
Type of the &#39;struct SessionAddMessage&#39; send by transport clients to ATS to inform ATS about a session...
Transport client to ATS service: here is another session you can use.
Definition: ats2.h:143
static int inbound_only
Option -i.
#define GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION
Type of the &#39;struct SessionAllocationMessage&#39; send by ATS to the transport to tell it about resources...
uint32_t value__
The actual value (bytes per second).
uint32_t utilization_out
Actual traffic on this connection from this peer to the other peer.
Definition: ats2.h:70
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
uint32_t pk
What type of performance preference does the client have? A enum GNUNET_MQ_PreferenceKind in NBO...
Definition: ats2.h:125
void * GNUNET_PLUGIN_unload(const char *library_name, void *arg)
Unload plugin (runs the "done" callback and returns whatever "done" returned).
Definition: plugin.c:258
void(* session_del)(void *cls, struct GNUNET_ATS_SessionHandle *sh, const struct GNUNET_ATS_SessionData *data)
A session went away.
static void handle_session_del(void *cls, const struct SessionDelMessage *message)
Handle &#39;session delete&#39; messages from transport clients.
Handle to a client that is connected to a service.
Definition: service.c:249
static void cleanup_task(void *cls)
Task run during shutdown.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
uint32_t mtu
MTU of the network layer, UINT32_MAX for no MTU (stream).
Definition: ats2.h:91
struct GNUNET_CONTAINER_MultiHashMap32 * sessions
Map from session IDs to struct GNUNET_ATS_Session objects.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
#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
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct ClientPreference * cp_tail
Tail of DLL of preferences expressed by this client.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
GNUNET_MQ_PreferenceKind
Enum defining all known preference categories.
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
uint32_t distance
Distance on network layer (required for distance-vector routing) in hops.
Definition: ats2.h:84
static char * value
Value of the record to add/remove.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD or GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY.
Definition: ats2.h:149
Information about ongoing sessions of the transport client.
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_ATS_PreferenceHandle *(* preference_add)(void *cls, const struct GNUNET_ATS_Preference *pref)
The plugin should begin to respect a new preference.
Message used to notify ATS that the performance characteristics for an session have changed...
Definition: ats2.h:178
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
static int check_session_add(void *cls, const struct SessionAddMessage *message)
Check &#39;session_add&#39; message is well-formed and comes from a transport client.
struct GNUNET_TIME_Relative delay
Delay.
ATS Service allocates resources to an session identified by the given session_id for the given peer w...
Definition: ats2.h:237
Preference being expressed by an application client.
uint32_t session_id
Internal number this client uses to refer to this session.
Definition: ats2.h:220
static char * plugin_name
Solver plugin name as string.
Internal representation of the hash map.
static void handle_suggest(void *cls, const struct ExpressPreferenceMessage *msg)
We have received a struct ExpressPreferenceMessage from an application client.
automatic transport selection messages
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
How much bandwidth we are allowed for sending.
Definition: ats2.h:260
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:638
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
uint32_t goodput_in
Confirmed useful payload on this connection to this peer from the other peer.
struct GNUNET_ATS_SessionHandle *(* session_add)(void *cls, const struct GNUNET_ATS_SessionData *data, const char *address)
Transport established a new session with performance characteristics given in data.
uint32_t session_id
Internal number this client uses to refer to the session this suggestion is about.
Definition: ats2.h:248
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
A client disconnected from us.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
There must only be one value per key; storing a value should fail if a value under the same key alrea...
uint32_t mtu
MTU of the network layer, UINT32_MAX for no MTU (stream).
static void handle_start(void *cls, const struct GNUNET_MessageHeader *hdr)
Handle &#39;start&#39; messages from transport clients.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
struct PropertiesNBO properties
Performance properties of the session.
Definition: ats2.h:200
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
#define GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE
Type of the &#39;struct SessionUpdateMessage&#39; send by transport clients to ATS to inform ATS about proper...
uint32_t nt
Which network scope does the respective address belong to? A enum GNUNET_NetworkType nt in NBO...
Definition: ats2.h:97
struct GNUNET_BANDWIDTH_Value32NBO bw
How much bandwidth in bytes/second does the application expect?
#define GNUNET_MESSAGE_TYPE_ATS_SUGGEST
Type of the &#39;struct ExpressPreferenceMessage&#39; send by clients to ATS to establish bandwidth preferenc...
int inbound_only
Is the session inbound only?
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
void * cls
Closure to pass to all solver functions in this struct.
Plugin-relevant information about a session.
struct GNUNET_PeerIdentity peer
Identity of the peer that this session is for.
Definition: ats2.h:160
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
#define GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL
Type of the &#39;struct ExpressPreferenceMessage&#39; send by clients to ATS to abandon bandwidth preference...
enum GNUNET_NetworkType nt
Which network scope does the respective address belong to?
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
ATS Service suggests to the transport service to use the address identified by the given session_id f...
Definition: ats.h:248
enum ClientType type
Type of the client, initially CT_NONE.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_HashMapIterator32 it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_ATS_Preference pref
Details about the preference.
static void suggest_cb(void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
Function called by the solver to prompt the transport to try out a new address.
Handle to a message queue.
Definition: mq.c:85
void(* suggest_cb)(void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
Suggest to the transport that it should try establishing a connection using the given address...
The identity of the host (wraps the signing key of the peer).
void(* allocate_cb)(void *cls, struct GNUNET_ATS_Session *session, const struct GNUNET_PeerIdentity *peer, struct GNUNET_BANDWIDTH_Value32NBO bw_in, struct GNUNET_BANDWIDTH_Value32NBO bw_out)
Tell the transport that it should allocate the given bandwidth to the specified session.
struct GNUNET_ATS_PreferenceHandle * ph
Plugin&#39;s representation of the preference.
struct GNUNET_ATS_SessionData data
Session data exposed to the plugin.
configuration data
Definition: configuration.c:85
void(* preference_del)(void *cls, struct GNUNET_ATS_PreferenceHandle *ph, const struct GNUNET_ATS_Preference *pref)
The plugin should end respecting a preference.
struct GNUNET_TIME_RelativeNBO delay
Delay.
Definition: ats2.h:46
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected to us.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration handle to be used by the solver.
#define GNUNET_log(kind,...)
static void prop_ntoh(const struct PropertiesNBO *properties, struct GNUNET_ATS_Properties *prop)
Convert properties to prop.
static void handle_session_add(void *cls, const struct SessionAddMessage *message)
Handle &#39;session add&#39; messages from transport clients.
uint32_t goodput_in
Confirmed useful payload on this connection to this peer from the other peer.
Definition: ats2.h:62
struct Client * client
The transport client that provided the session.
static void handle_suggest_cancel(void *cls, const struct ExpressPreferenceMessage *msg)
We have received a struct ExpressPreferenceMessage from an application client.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL
Type of the &#39;struct SessionDelMessage&#39; send by transport clients to ATS to tell ATS that a session is...
void * cls
Closure to pass to all callbacks in this struct.
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:80
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:266
void * GNUNET_PLUGIN_load(const char *library_name, void *arg)
Setup plugin (runs the "init" callback and returns whatever "init" returned).
Definition: plugin.c:210
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
struct ClientPreference * next
DLL pointer.
union Client::@0 details
Details depending on type.
struct GNUNET_PeerIdentity peer
Peer to get address suggestions for.
struct ClientPreference * cp_head
Head of DLL of preferences expressed by this client.
ATS performance characteristics for an address.
Definition: ats2.h:39
The ATS plugin will pass a pointer to a struct of this type as to the initialization function of the ...
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
ClientType
What type of client is this client?
struct GNUNET_BANDWIDTH_Value32NBO bw
How much bandwidth in bytes/second does the application expect?
Definition: ats2.h:135
uint32_t data
The data value.
Application client to ATS service: we would like to have address suggestions for this peer...
Definition: ats2.h:112
unsigned int distance
Distance on network layer (required for distance-vector routing) in hops.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
How much bandwidth we are allowed for receiving.
Definition: ats2.h:265
static char * address
GNS address for this phone.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
GNUNET_SERVICE_MAIN("ats", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(suggest, GNUNET_MESSAGE_TYPE_ATS_SUGGEST, struct ExpressPreferenceMessage, NULL), GNUNET_MQ_hd_fixed_size(suggest_cancel, GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL, struct ExpressPreferenceMessage, NULL), GNUNET_MQ_hd_fixed_size(start, GNUNET_MESSAGE_TYPE_ATS_START, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(session_add, GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD, struct SessionAddMessage, NULL), GNUNET_MQ_hd_var_size(session_add, GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY, struct SessionAddMessage, NULL), GNUNET_MQ_hd_fixed_size(session_update, GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE, struct SessionUpdateMessage, NULL), GNUNET_MQ_hd_fixed_size(session_del, GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL, struct SessionDelMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
struct PropertiesNBO properties
Performance properties of the session.
Definition: ats2.h:165
#define GNUNET_free(ptr)
Wrapper around free.
uint32_t utilization_out
Actual traffic on this connection from this peer to the other peer.
struct GNUNET_PeerIdentity peer
Peer to get address suggestions for.
Definition: ats2.h:130
#define GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD
Type of the &#39;struct SessionAddMessage&#39; send by transport clients to ATS to ask ATS to allocate resour...
struct GNUNET_ATS_Properties prop
ATS performance characteristics for a session.