GNUnet  0.11.x
transport_api2_core.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009-2013, 2016, 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  */
20 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_constants.h"
29 #include "gnunet_arm_service.h"
30 #include "gnunet_hello_lib.h"
31 #include "gnunet_protocols.h"
33 #include "transport.h"
34 
35 #define LOG(kind, ...) GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)
36 
40 #define STARTING_NEIGHBOURS_SIZE 16
41 
50 #define SEND_WINDOW_SIZE 4
51 
52 
56 struct Neighbour
57 {
62 
67 
72 
77 
81  void *handlers_cls;
82 
87  unsigned int ready_window;
88 
96  int16_t awaiting_done;
97 
101  uint16_t env_size;
102 };
103 
104 
110 {
114  void *cls;
115 
121 
126 
131 
136 
141 
147 
151  struct GNUNET_PeerIdentity self;
152 
157 
161  struct GNUNET_TIME_Relative reconnect_delay;
162 
168 };
169 
170 
177 static void
179 
180 
188 static struct Neighbour *
190  const struct GNUNET_PeerIdentity *peer)
191 {
193 }
194 
195 
206 static int
207 neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
208 {
210  struct Neighbour *n = value;
211 
213  "Dropping entry for neighbour `%s'.\n",
214  GNUNET_i2s (key));
215  if (NULL != handle->nd_cb)
216  handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
217  if (NULL != n->env)
218  {
220  n->env = NULL;
221  }
222  GNUNET_MQ_destroy (n->mq);
223  GNUNET_assert (NULL == n->mq);
224  GNUNET_assert (
225  GNUNET_YES ==
227  GNUNET_free (n);
228  return GNUNET_YES;
229 }
230 
231 
241 static void
242 mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
243 {
245 
247  "Error receiving from transport service, disconnecting temporarily.\n");
249 }
250 
251 
262 static void
264 {
265  struct Neighbour *n = cls;
266 
268  n->env = NULL;
270 }
271 
272 
279 static void
280 do_send (struct Neighbour *n)
281 {
282  GNUNET_assert (0 < n->ready_window);
283  GNUNET_assert (NULL != n->env);
284  n->ready_window--;
287  GNUNET_MQ_send (n->h->mq, n->env);
289  "Passed message of type %u for neighbour `%s' to TRANSPORT.\n",
290  ntohs (GNUNET_MQ_env_get_msg (n->env)->type),
291  GNUNET_i2s (&n->id));
292 }
293 
294 
305 static void
307  const struct GNUNET_MessageHeader *msg,
308  void *impl_state)
309 {
310  struct Neighbour *n = impl_state;
311  struct OutboundMessage *obm;
312  uint16_t msize;
313 
314  msize = ntohs (msg->size);
315  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
316  {
317  GNUNET_break (0);
319  return;
320  }
322  "CORE requested transmission of message of type %u to neighbour `%s'.\n",
323  ntohs (msg->type),
324  GNUNET_i2s (&n->id));
325 
326  GNUNET_assert (NULL == n->env);
327  n->env =
329  n->env_size = ntohs (msg->size);
330  {
331  struct GNUNET_MQ_Envelope *env;
332 
334  obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
335  }
336  obm->peer = n->id;
337  if (0 == n->ready_window)
338  {
340  "Flow control delays transmission to CORE until we see SEND_OK.\n");
341  return; /* can't send yet, need to wait for SEND_OK */
342  }
343  do_send (n);
344 }
345 
346 
354 static void
355 mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
356 {
357  struct Neighbour *n = impl_state;
358 
359  GNUNET_assert (mq == n->mq);
360  n->mq = NULL;
361 }
362 
363 
371 static void
372 mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
373 {
374  struct Neighbour *n = impl_state;
375 
376  n->ready_window++;
377  if (GNUNET_YES == n->awaiting_done)
378  {
380  n->env = NULL;
382  }
383  else
384  {
385  GNUNET_assert (0 == n->ready_window);
386  n->env = NULL;
387  }
388 }
389 
390 
399 static void
400 peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
401 {
402  /* struct Neighbour *n = cls; */
403 
404  GNUNET_break_op (0);
405 }
406 
407 
414 static void
415 handle_connect (void *cls, const struct ConnectInfoMessage *cim)
416 {
418  struct Neighbour *n;
419 
421  "Receiving CONNECT message for `%s'\n",
422  GNUNET_i2s (&cim->id));
423  n = neighbour_find (h, &cim->id);
424  if (NULL != n)
425  {
426  GNUNET_break (0);
428  return;
429  }
430  n = GNUNET_new (struct Neighbour);
431  n->id = cim->id;
432  n->h = h;
436  h->neighbours,
437  &n->id,
438  n,
440 
444  n,
445  h->handlers,
447  n);
448  if (NULL != h->nc_cb)
449  {
450  n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
452  }
453 }
454 
455 
462 static void
463 handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
464 {
466  struct Neighbour *n;
467 
468  GNUNET_break (ntohl (dim->reserved) == 0);
470  "Receiving DISCONNECT message for `%s'.\n",
471  GNUNET_i2s (&dim->peer));
472  n = neighbour_find (h, &dim->peer);
473  if (NULL == n)
474  {
475  GNUNET_break (0);
477  return;
478  }
479  GNUNET_assert (GNUNET_YES == neighbour_delete (h, &dim->peer, n));
480 }
481 
482 
489 static void
490 handle_send_ok (void *cls, const struct SendOkMessage *okm)
491 {
493  struct Neighbour *n;
494 
496  "Receiving SEND_OK message for transmission to %s\n",
497  GNUNET_i2s (&okm->peer));
498  n = neighbour_find (h, &okm->peer);
499  if (NULL == n)
500  {
501  /* We should never get a 'SEND_OK' for a peer that we are not
502  connected to */
503  GNUNET_break (0);
505  return;
506  }
507  n->ready_window++;
508  if ((NULL != n->env) && (1 == n->ready_window))
509  do_send (n);
510 }
511 
512 
519 static int
520 check_recv (void *cls, const struct InboundMessage *im)
521 {
522  const struct GNUNET_MessageHeader *imm;
523  uint16_t size;
524 
525  size = ntohs (im->header.size) - sizeof(*im);
526  if (size < sizeof(struct GNUNET_MessageHeader))
527  {
528  GNUNET_break (0);
529  return GNUNET_SYSERR;
530  }
531  imm = (const struct GNUNET_MessageHeader *) &im[1];
532  if (ntohs (imm->size) != size)
533  {
534  GNUNET_break (0);
535  return GNUNET_SYSERR;
536  }
537  return GNUNET_OK;
538 }
539 
540 
547 static void
548 handle_recv (void *cls, const struct InboundMessage *im)
549 {
551  const struct GNUNET_MessageHeader *imm =
552  (const struct GNUNET_MessageHeader *) &im[1];
553  struct Neighbour *n;
554 
556  "Received message of type %u with %u bytes from `%s'.\n",
557  (unsigned int) ntohs (imm->type),
558  (unsigned int) ntohs (imm->size),
559  GNUNET_i2s (&im->peer));
560  n = neighbour_find (h, &im->peer);
561  if (NULL == n)
562  {
563  GNUNET_break (0);
565  return;
566  }
567  GNUNET_MQ_inject_message (n->mq, imm);
568 }
569 
570 
576 static void
577 reconnect (void *cls)
578 {
580  struct GNUNET_MQ_MessageHandler handlers[] =
581  { GNUNET_MQ_hd_fixed_size (connect,
583  struct ConnectInfoMessage,
584  h),
587  struct DisconnectInfoMessage,
588  h),
589  GNUNET_MQ_hd_fixed_size (send_ok,
591  struct SendOkMessage,
592  h),
593  GNUNET_MQ_hd_var_size (recv,
595  struct InboundMessage,
596  h),
598  struct GNUNET_MQ_Envelope *env;
599  struct StartMessage *s;
600  uint32_t options;
601 
602  h->reconnect_task = NULL;
603  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
604  GNUNET_assert (NULL == h->mq);
605  h->mq =
606  GNUNET_CLIENT_connect (h->cfg, "transport", handlers, &mq_error_handler, h);
607  if (NULL == h->mq)
608  return;
610  options = 0;
611  if (h->check_self)
612  options |= 1;
613  if (NULL != h->handlers)
614  options |= 2;
615  s->options = htonl (options);
616  s->self = h->self;
617  GNUNET_MQ_send (h->mq, env);
618 }
619 
620 
626 static void
628 {
630  if (NULL != h->mq)
631  {
632  GNUNET_MQ_destroy (h->mq);
633  h->mq = NULL;
634  }
635 }
636 
637 
644 static void
646 {
647  GNUNET_assert (NULL == h->reconnect_task);
648  disconnect (h);
650  "Scheduling task to reconnect to transport service in %s.\n",
652  h->reconnect_task =
655 }
656 
657 
665 struct GNUNET_MQ_Handle *
667  const struct GNUNET_PeerIdentity *peer)
668 {
669  struct Neighbour *n;
670 
671  n = neighbour_find (handle, peer);
672  if (NULL == n)
673  return NULL;
674  return n->mq;
675 }
676 
677 
698 void
699 GNUNET_TRANSPORT_core_receive_continue (struct GNUNET_TRANSPORT_CoreHandle *ch,
700  const struct GNUNET_PeerIdentity *pid)
701 {
702  struct GNUNET_MQ_Envelope *env;
703  struct RecvOkMessage *rok;
704 
706  "Message for %s finished CORE processing, sending RECV_OK.\n",
707  GNUNET_i2s (pid));
708  if (NULL == ch->mq)
709  return;
711  rok->increase_window_delta = htonl (1);
712  rok->peer = *pid;
713  GNUNET_MQ_send (ch->mq, env);
714 }
715 
716 
732  const struct GNUNET_PeerIdentity *self,
733  const struct GNUNET_MQ_MessageHandler *handlers,
734  void *cls,
737 {
739  unsigned int i;
740 
742  if (NULL != self)
743  {
744  h->self = *self;
745  h->check_self = GNUNET_YES;
746  }
747  h->cfg = cfg;
748  h->cls = cls;
749  h->nc_cb = nc;
750  h->nd_cb = nd;
752  if (NULL != handlers)
753  {
754  for (i = 0; NULL != handlers[i].cb; i++)
755  ;
758  handlers,
759  i * sizeof(struct GNUNET_MQ_MessageHandler));
760  }
761  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
762  reconnect (h);
763  if (NULL == h->mq)
764  {
766  GNUNET_free (h);
767  return NULL;
768  }
769  h->neighbours =
771  return h;
772 }
773 
774 
781 void
783 {
784  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
785  /* this disconnects all neighbours... */
786  disconnect (handle);
787  /* and now we stop trying to connect again... */
788  if (NULL != handle->reconnect_task)
789  {
791  handle->reconnect_task = NULL;
792  }
794  handle->neighbours = NULL;
795  GNUNET_free_non_null (handle->handlers);
796  handle->handlers = NULL;
797  GNUNET_free (handle);
798 }
799 
800 
801 /* end of transport_api_core.c */
struct GNUNET_MQ_MessageHandler * handlers
Functions to call for received data (template for new message queues).
A connected controller which is not our child.
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:141
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static void reconnect(void *cls)
Try again to connect to transport service.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
void * cls
Closure for the callbacks.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:1080
Message used to notify the transport API that it can send another message to the transport service...
Definition: transport.h:260
uint32_t priority
An enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: transport.h:294
common internal definitions for transport service
static void handle_disconnect(void *cls, const struct DisconnectInfoMessage *dim)
Function we use for handling incoming disconnect messages.
void * handlers_cls
Closure for mq handlers.
GNUNET_TRANSPORT_NotifyDisconnect nd_cb
function to call on disconnect events
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK
Message telling transport to limit its receive rate.
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
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct...
GNUNET_MQ_Error
Error codes for the queue.
struct GNUNET_TRANSPORT_CoreHandle * h
Overall transport handle.
struct GNUNET_MQ_Handle * mq
Active message queue for the peer.
const struct GNUNET_CONFIGURATION_Handle * cfg
My configuration.
struct GNUNET_PeerIdentity peer
Which peer should receive the message?
Definition: transport.h:308
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_MQ_Handle * mq
My client connection to the transport service.
struct GNUNET_PeerIdentity peer
Which peer can CORE handle more from now?
Definition: transport.h:276
static void notify_send_done(void *cls)
A message from the handler&#39;s message queue to a neighbour was transmitted.
static void disconnect(struct GNUNET_TRANSPORT_CoreHandle *h)
Disconnect from the transport service.
GNUNET_TRANSPORT_NotifyConnect nc_cb
function to call on connect events
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#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
static void mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_NO
Definition: gnunet_common.h:78
uint32_t increase_window_delta
Number of messages by which to increase the window, greater or equal to one.
Definition: transport.h:271
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define STARTING_NEIGHBOURS_SIZE
How large to start with for the hashmap of neighbours.
struct GNUNET_PeerIdentity self
Identity we think we have.
Definition: transport.h:109
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.
void *(* GNUNET_TRANSPORT_NotifyConnect)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Function called to notify transport users that another peer connected to us.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static void peer_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
We had an error processing a message we forwarded from a peer to the CORE service.
struct GNUNET_PeerIdentity self
Peer identity as assumed by this process, or all zeros.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
static int neighbour_delete(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries, for deleting state of a neighbour.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map of the current connected neighbours of this peer.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
Request to TRANSPORT to transmit a message.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
Message from TRANSPORT notifying about a client that connected to us.
struct GNUNET_TIME_Relative reconnect_delay
Delay until we try to reconnect.
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1020
uint16_t env_size
Size of the message in env.
void GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
Change the closure argument in all of the handlers of the mq.
Definition: mq.c:583
void(* GNUNET_TRANSPORT_NotifyDisconnect)(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
Function called to notify transport users that another peer disconnected from us. ...
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
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint32_t reserved
Reserved, always zero.
Definition: transport.h:159
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:552
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:774
static char * value
Value of the record to add/remove.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
uint32_t options
0: no options 1: The self field should be checked 2: this client is interested in payload traffic ...
Definition: transport.h:103
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static void handle_connect(void *cls, const struct ConnectInfoMessage *cim)
Function we use for handling incoming connect messages.
Message from the transport service to the library informing about neighbors.
Definition: transport.h:117
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int check_self
Should we check that self matches what the service thinks? (if GNUNET_NO, then self is all zeros!)...
GNUNET_MQ_MessageCallback cb
Callback, called every time a new message of the specified type has been receied. ...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_START
Message from the core saying that the transport server should start giving it messages.
void GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *mh)
Call the message message handler that was registered for the type of the given message in the given m...
Definition: mq.c:202
Internal representation of the hash map.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
static void disconnect_and_schedule_reconnect(struct GNUNET_TRANSPORT_CoreHandle *h)
Function that will schedule the job that will try to connect us again to the client.
Message handler for a specific message type.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
Message from TRANSPORT notifying about a client that disconnected from us.
Message used to notify the transport service about a message to be transmitted to another peer...
Definition: transport.h:284
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Message from the transport service to the library asking to check if both processes agree about this ...
Definition: transport.h:91
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_PeerIdentity peer
Which peer sent the message?
Definition: transport.h:208
Message from the transport service to the library informing about disconnects.
Definition: transport.h:149
unsigned int ready_window
How many messages can we still send to this peer before we should throttle?
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
#define LOG(kind,...)
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
static void handle_send_ok(void *cls, const struct SendOkMessage *okm)
Function we use for handling incoming send-ok messages.
static void mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
static void handle_recv(void *cls, const struct InboundMessage *im)
Function we use for handling incoming messages.
Handle to a message queue.
Definition: mq.c:85
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
The identity of the host (wraps the signing key of the peer).
Message used to notify the transport API that it can send another message to the transport service...
Definition: transport.h:216
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:251
int16_t awaiting_done
Used to indicate our status if env is non-NULL.
configuration data
Definition: configuration.c:85
static int check_recv(void *cls, const struct InboundMessage *im)
Function we use for checking incoming "inbound" messages.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
Message from TRANSPORT notifying about a message that was received.
struct GNUNET_PeerIdentity peer
Who got disconnected?
Definition: transport.h:164
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
Entry in list of pending tasks.
Definition: scheduler.c:134
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the task trying to reconnect to the service.
Header for all communications.
struct GNUNET_MQ_Envelope * GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
Function to obtain the current envelope from within GNUNET_MQ_SendImpl implementations.
Definition: mq.c:974
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#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
static struct Neighbour * neighbour_find(struct GNUNET_TRANSPORT_CoreHandle *h, const struct GNUNET_PeerIdentity *peer)
Get the neighbour list entry for the given peer.
struct GNUNET_MQ_Handle * GNUNET_TRANSPORT_core_get_mq(struct GNUNET_TRANSPORT_CoreHandle *handle, const struct GNUNET_PeerIdentity *peer)
Checks if a given peer is connected to us and get the message queue.
struct GNUNET_MQ_Envelope * env
Envelope with the message we are currently transmitting (or NULL).
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV.
Definition: transport.h:203
Handle for the transport service (includes all of the state for the transport service).
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:486
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:916
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static void mq_send_impl(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Implement sending functionality of a message queue.
Message used to notify the transport API about a message received from the network.
Definition: transport.h:198
#define GNUNET_free(ptr)
Wrapper around free.
#define SEND_WINDOW_SIZE
Window size.
Time for relative time used by GNUnet, in microseconds.
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static void do_send(struct Neighbour *n)
We have an envelope waiting for transmission at n, and our transmission window is positive...
struct GNUNET_PeerIdentity pid
Which peer is this about?
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966