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 {
61  struct GNUNET_PeerIdentity id;
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 
162 
168 };
169 
170 
177 static void
179 
180 
188 static struct Neighbour *
190  const struct GNUNET_PeerIdentity *peer)
191 {
192  return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
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  }
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 {
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 =
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  {
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 =
653  GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
654  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
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;
751  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
752  if (NULL != handlers)
753  {
754  for (i = 0; NULL != handlers[i].cb; i++)
755  ;
756  h->handlers = GNUNET_new_array (i + 1, struct GNUNET_MQ_MessageHandler);
757  GNUNET_memcpy (h->handlers,
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  {
765  GNUNET_free (h->handlers);
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 (handle->handlers);
796  handle->handlers = NULL;
798 }
799 
800 
801 /* end of transport_api_core.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * value
Value of the record to add/remove.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1064
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash 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.
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).
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.
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.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:929
GNUNET_MQ_Error
Error codes for the queue.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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:565
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct.
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:499
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
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
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
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:787
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1037
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
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:596
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:991
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:1097
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
#define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
Message from TRANSPORT notifying about a client that connected to us.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_START
Message from the core saying that the transport server should start giving it messages.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK
Message telling transport to limit its receive rate.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
Message from TRANSPORT notifying about a message that was received.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
Message from TRANSPORT notifying about a client that disconnected from us.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
Request to TRANSPORT to transmit a message.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
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:557
#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_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.
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.
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_NotifyDisconnect)(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
Function called to notify transport users that another peer disconnected from us.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
static unsigned int size
Size of the "table".
Definition: peer.c:67
Message from the transport service to the library informing about neighbors.
Definition: transport.h:118
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:141
Message from the transport service to the library informing about disconnects.
Definition: transport.h:150
uint32_t reserved
Reserved, always zero.
Definition: transport.h:159
struct GNUNET_PeerIdentity peer
Who got disconnected?
Definition: transport.h:164
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:143
Internal representation of the hash map.
struct GNUNET_SCHEDULER_Task * reconnect_task
Task to reconnect to the service.
Definition: dns_api.c:81
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:135
Time for relative time used by GNUnet, in microseconds.
Handle for the transport service (includes all of the state for the transport service).
int check_self
Should we check that self matches what the service thinks? (if GNUNET_NO, then self is all zeros!...
struct GNUNET_PeerIdentity self
Peer identity as assumed by this process, or all zeros.
const struct GNUNET_CONFIGURATION_Handle * cfg
My configuration.
struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map of the current connected neighbours of this peer.
void * cls
Closure for the callbacks.
GNUNET_TRANSPORT_NotifyDisconnect nd_cb
function to call on disconnect events
struct GNUNET_MQ_Handle * mq
My client connection to the transport service.
GNUNET_TRANSPORT_NotifyConnect nc_cb
function to call on connect events
struct GNUNET_TIME_Relative reconnect_delay
Delay until we try to reconnect.
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the task trying to reconnect to the service.
struct GNUNET_MQ_MessageHandler * handlers
Functions to call for received data (template for new message queues).
Message used to notify the transport API about a message received from the network.
Definition: transport.h:199
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV.
Definition: transport.h:203
struct GNUNET_PeerIdentity peer
Which peer sent the message?
Definition: transport.h:208
A connected controller which is not our child.
void * handlers_cls
Closure for mq handlers.
uint16_t env_size
Size of the message in env.
struct GNUNET_TRANSPORT_CoreHandle * h
Overall transport handle.
int16_t awaiting_done
Used to indicate our status if env is non-NULL.
struct GNUNET_MQ_Envelope * env
Envelope with the message we are currently transmitting (or NULL).
struct GNUNET_MQ_Handle * mq
Active message queue for the peer.
unsigned int ready_window
How many messages can we still send to this peer before we should throttle?
struct GNUNET_PeerIdentity id
Identity of this neighbour.
Message used to notify the transport service about a message to be transmitted to another peer.
Definition: transport.h:285
uint32_t priority
An enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: transport.h:294
struct GNUNET_PeerIdentity peer
Which peer should receive the message?
Definition: transport.h:308
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:261
struct GNUNET_PeerIdentity peer
Which peer can CORE handle more from now?
Definition: transport.h:276
uint32_t increase_window_delta
Number of messages by which to increase the window, greater or equal to one.
Definition: transport.h:271
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:217
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:251
Message from the transport service to the library asking to check if both processes agree about this ...
Definition: transport.h:92
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
struct GNUNET_PeerIdentity self
Identity we think we have.
Definition: transport.h:109
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
common internal definitions for transport service
static int neighbour_delete(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries, for deleting state of a neighbour.
static void handle_connect(void *cls, const struct ConnectInfoMessage *cim)
Function we use for handling incoming connect messages.
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.
static void disconnect(struct GNUNET_TRANSPORT_CoreHandle *h)
Disconnect from the transport service.
static void do_send(struct Neighbour *n)
We have an envelope waiting for transmission at n, and our transmission window is positive.
static void handle_disconnect(void *cls, const struct DisconnectInfoMessage *dim)
Function we use for handling incoming disconnect messages.
static struct Neighbour * neighbour_find(struct GNUNET_TRANSPORT_CoreHandle *h, const struct GNUNET_PeerIdentity *peer)
Get the neighbour list entry for the given peer.
static void handle_send_ok(void *cls, const struct SendOkMessage *okm)
Function we use for handling incoming send-ok messages.
static int check_recv(void *cls, const struct InboundMessage *im)
Function we use for checking incoming "inbound" messages.
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.
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 reconnect(void *cls)
Try again to connect to transport service.
static void notify_send_done(void *cls)
A message from the handler's message queue to a neighbour was transmitted.
static void mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
#define STARTING_NEIGHBOURS_SIZE
How large to start with for the hashmap of neighbours.
#define SEND_WINDOW_SIZE
Window size.
static void mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
#define LOG(kind,...)
static void handle_recv(void *cls, const struct InboundMessage *im)
Function we use for handling incoming messages.
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.