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 
37 {
41  CT_NONE = 0,
42 
47 
52 };
53 
54 
58 struct Client;
59 
64 {
69 
74 
78  struct Client *client;
79 
83  struct GNUNET_ATS_PreferenceHandle *ph;
84 
89 };
90 
91 
96 {
101 
105  struct Client *client;
106 
111 
115  uint32_t session_id;
116 };
117 
118 
122 struct Client
123 {
128 
133 
138 
142  union
143  {
144  struct
145  {
150 
155  } application;
156 
157  struct
158  {
163  } transport;
164  } details;
165 };
166 
167 
172 
177 
181 static char *plugin_name;
182 
186 static struct Client *transport_client;
187 
188 
197 static void
198 suggest_cb (void *cls,
199  const struct GNUNET_PeerIdentity *pid,
200  const char *address)
201 {
202  struct GNUNET_MQ_Envelope *env;
203  size_t slen = strlen (address) + 1;
204  struct AddressSuggestionMessage *as;
205 
206  if (NULL == transport_client)
207  {
208  // FIXME: stats!
209  return;
210  }
212  "Suggesting address `%s' of peer `%s'\n",
213  address,
214  GNUNET_i2s (pid));
215  env = GNUNET_MQ_msg_extra (as,
216  slen,
218  as->peer = *pid;
219  memcpy (&as[1],
220  address,
221  slen);
222  GNUNET_MQ_send (transport_client->mq,
223  env);
224 }
225 
226 
237 static void
238 allocate_cb (void *cls,
239  struct GNUNET_ATS_Session *session,
240  const struct GNUNET_PeerIdentity *peer,
241  struct GNUNET_BANDWIDTH_Value32NBO bw_in,
242  struct GNUNET_BANDWIDTH_Value32NBO bw_out)
243 {
244  struct GNUNET_MQ_Envelope *env;
245  struct SessionAllocationMessage *sam;
246 
247  (void) cls;
248  if ((NULL == transport_client) ||
249  (session->client != transport_client))
250  {
251  /* transport must have just died and solver is addressing the
252  losses of sessions (possibly of previous transport), ignore! */
253  return;
254  }
256  "Allocating %u/%u bytes for %p of peer `%s'\n",
257  ntohl (bw_in.value__),
258  ntohl (bw_out.value__),
259  session,
260  GNUNET_i2s (peer));
261  env = GNUNET_MQ_msg (sam,
263  sam->session_id = session->session_id;
264  sam->peer = *peer;
265  sam->bandwidth_in = bw_in;
266  sam->bandwidth_out = bw_out;
267  GNUNET_MQ_send (transport_client->mq,
268  env);
269 }
270 
271 
278 static void
279 prop_ntoh (const struct PropertiesNBO *properties,
280  struct GNUNET_ATS_Properties *prop)
281 {
282  prop->delay = GNUNET_TIME_relative_ntoh (properties->delay);
283  prop->goodput_out = ntohl (properties->goodput_out);
284  prop->goodput_in = ntohl (properties->goodput_in);
285  prop->utilization_out = ntohl (properties->utilization_out);
286  prop->utilization_in = ntohl (properties->utilization_in);
287  prop->distance = ntohl (properties->distance);
288  prop->mtu = ntohl (properties->mtu);
289  prop->nt = (enum GNUNET_NetworkType) ntohl (properties->nt);
290  prop->cc = (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (
291  properties->cc);
292 }
293 
294 
301 static void
302 handle_suggest (void *cls,
303  const struct ExpressPreferenceMessage *msg)
304 {
305  struct Client *c = cls;
306  struct ClientPreference *cp;
307 
308  if (CT_NONE == c->type)
309  c->type = CT_APPLICATION;
310  if (CT_APPLICATION != c->type)
311  {
312  GNUNET_break (0);
314  return;
315  }
317  "Client suggested we talk to %s with preference %d at rate %u\n",
318  GNUNET_i2s (&msg->peer),
319  (int) ntohl (msg->pk),
320  (int) ntohl (msg->bw.value__));
321  cp = GNUNET_new (struct ClientPreference);
322  cp->client = c;
323  cp->pref.peer = msg->peer;
324  cp->pref.bw = msg->bw;
325  cp->pref.pk = (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk);
326  cp->ph = plugin->preference_add (plugin->cls,
327  &cp->pref);
329  c->details.application.cp_tail,
330  cp);
332 }
333 
334 
341 static void
343  const struct ExpressPreferenceMessage *msg)
344 {
345  struct Client *c = cls;
346  struct ClientPreference *cp;
347 
348  if (CT_NONE == c->type)
349  c->type = CT_APPLICATION;
350  if (CT_APPLICATION != c->type)
351  {
352  GNUNET_break (0);
354  return;
355  }
356  for (cp = c->details.application.cp_head;
357  NULL != cp;
358  cp = cp->next)
359  if ((cp->pref.pk == (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk)) &&
360  (cp->pref.bw.value__ == msg->bw.value__) &&
361  (0 == GNUNET_memcmp (&cp->pref.peer,
362  &msg->peer)))
363  break;
364  if (NULL == cp)
365  {
366  GNUNET_break (0);
368  return;
369  }
370  plugin->preference_del (plugin->cls,
371  cp->ph,
372  &cp->pref);
374  c->details.application.cp_tail,
375  cp);
376  GNUNET_free (cp);
378 }
379 
380 
387 static void
388 handle_start (void *cls,
389  const struct GNUNET_MessageHeader *hdr)
390 {
391  struct Client *c = cls;
392 
393  if (CT_NONE != c->type)
394  {
395  GNUNET_break (0);
397  return;
398  }
399  c->type = CT_TRANSPORT;
400  c->details.transport.sessions
402  if (NULL != transport_client)
403  {
404  GNUNET_SERVICE_client_drop (transport_client->client);
405  transport_client = NULL;
406  }
407  transport_client = c;
409 }
410 
411 
420 static int
421 check_session_add (void *cls,
422  const struct SessionAddMessage *message)
423 {
424  struct Client *c = cls;
425 
427  if (CT_TRANSPORT != c->type)
428  {
429  GNUNET_break (0);
430  return GNUNET_SYSERR;
431  }
432  return GNUNET_OK;
433 }
434 
435 
442 static void
444  const struct SessionAddMessage *message)
445 {
446  struct Client *c = cls;
447  const char *address = (const char *) &message[1];
448  struct GNUNET_ATS_Session *session;
450  ntohs (message->header.type));
451 
453  message->session_id);
454  if (NULL != session)
455  {
456  GNUNET_break (0);
458  return;
459  }
460  session = GNUNET_new (struct GNUNET_ATS_Session);
461  session->data.session = session;
462  session->client = c;
463  session->session_id = message->session_id;
464  session->data.peer = message->peer;
465  prop_ntoh (&message->properties,
466  &session->data.prop);
467  session->data.inbound_only = inbound_only;
470  c->details.transport.sessions,
471  message->session_id,
472  session,
474  session->sh = plugin->session_add (plugin->cls,
475  &session->data,
476  address);
477  GNUNET_assert (NULL != session->sh);
479  "Transport has new session %p to %s\n",
480  session,
481  GNUNET_i2s (&message->peer));
483 }
484 
485 
492 static void
494  const struct SessionUpdateMessage *msg)
495 {
496  struct Client *c = cls;
497  struct GNUNET_ATS_Session *session;
498 
499  if (CT_TRANSPORT != c->type)
500  {
501  GNUNET_break (0);
503  return;
504  }
506  msg->session_id);
507  if (NULL == session)
508  {
509  GNUNET_break (0);
511  return;
512  }
513  prop_ntoh (&msg->properties,
514  &session->data.prop);
515  plugin->session_update (plugin->cls,
516  session->sh,
517  &session->data);
519 }
520 
521 
528 static void
530  const struct SessionDelMessage *message)
531 {
532  struct Client *c = cls;
533  struct GNUNET_ATS_Session *session;
534 
535  if (CT_TRANSPORT != c->type)
536  {
537  GNUNET_break (0);
539  return;
540  }
542  message->session_id);
543  if (NULL == session)
544  {
545  GNUNET_break (0);
547  return;
548  }
549  GNUNET_assert (NULL != session->sh);
550  plugin->session_del (plugin->cls,
551  session->sh,
552  &session->data);
553  session->sh = NULL;
556  c->details.transport.sessions,
557  session->session_id,
558  session));
560  "Transport lost session %p to %s\n",
561  session,
562  GNUNET_i2s (&session->data.peer));
563  GNUNET_free (session);
565 }
566 
567 
577 static void *
578 client_connect_cb (void *cls,
580  struct GNUNET_MQ_Handle *mq)
581 {
582  struct Client *c = GNUNET_new (struct Client);
583 
584  c->client = client;
585  c->mq = mq;
586  return c;
587 }
588 
589 
598 static int
599 free_session (void *cls,
600  uint32_t key,
601  void *value)
602 {
603  struct Client *c = cls;
604  struct GNUNET_ATS_Session *session = value;
605 
606  (void) key;
607  GNUNET_assert (c == session->client);
608  GNUNET_assert (NULL != session->sh);
609  plugin->session_del (plugin->cls,
610  session->sh,
611  &session->data);
612  session->sh = NULL;
613  GNUNET_free (session);
614  return GNUNET_OK;
615 }
616 
617 
626 static void
629  void *app_ctx)
630 {
631  struct Client *c = app_ctx;
632 
633  (void) cls;
634  GNUNET_assert (c->client == client);
635  switch (c->type)
636  {
637  case CT_NONE:
638  break;
639 
640  case CT_APPLICATION:
641  for (struct ClientPreference *cp = c->details.application.cp_head;
642  NULL != cp;
643  cp = c->details.application.cp_head)
644  {
645  plugin->preference_del (plugin->cls,
646  cp->ph,
647  &cp->pref);
649  c->details.application.cp_tail,
650  cp);
651  GNUNET_free (cp);
652  }
653  break;
654 
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:205
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:102
#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:77
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:249
uint32_t session_id
Internal number this client will henceforth use to refer to this session.
Definition: ats2.h:152
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:1300
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
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
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:53
#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:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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:526
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:184
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:140
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:69
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
uint32_t pk
What type of performance preference does the client have? A enum GNUNET_MQ_PreferenceKind in NBO...
Definition: ats2.h:123
void * GNUNET_PLUGIN_unload(const char *library_name, void *arg)
Unload plugin (runs the "done" callback and returns whatever "done" returned).
Definition: plugin.c:256
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:250
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:90
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:83
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:146
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:174
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:1280
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:231
Preference being expressed by an application client.
uint32_t session_id
Internal number this client uses to refer to this session.
Definition: ats2.h:215
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:254
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:639
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
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:242
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:109
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:196
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#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:96
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:157
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:244
enum ClientType type
Type of the client, initially CT_NONE.
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:45
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:61
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: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:262
void * GNUNET_PLUGIN_load(const char *library_name, void *arg)
Setup plugin (runs the "init" callback and returns whatever "init" returned).
Definition: plugin.c:207
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:133
uint32_t data
The data value.
Application client to ATS service: we would like to have address suggestions for this peer...
Definition: ats2.h:110
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:259
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:2243
#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:162
#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:128
#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.