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 %u received from transport service, disconnecting temporarily.\n",
248  error);
250 }
251 
252 
263 static void
265 {
266  struct Neighbour *n = cls;
267 
269  n->env = NULL;
271 }
272 
273 
280 static void
281 do_send (struct Neighbour *n)
282 {
283  GNUNET_assert (0 < n->ready_window);
284  GNUNET_assert (NULL != n->env);
285  n->ready_window--;
288  GNUNET_MQ_send (n->h->mq, n->env);
290  "Passed message of type %u for neighbour `%s' to TRANSPORT.\n",
291  ntohs (GNUNET_MQ_env_get_msg (n->env)->type),
292  GNUNET_i2s (&n->id));
293 }
294 
295 
306 static void
308  const struct GNUNET_MessageHeader *msg,
309  void *impl_state)
310 {
311  struct Neighbour *n = impl_state;
312  struct OutboundMessage *obm;
313  uint16_t msize;
314 
315  msize = ntohs (msg->size);
316  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
317  {
318  GNUNET_break (0);
320  return;
321  }
323  "CORE requested transmission of message of type %u to neighbour `%s'.\n",
324  ntohs (msg->type),
325  GNUNET_i2s (&n->id));
326 
327  GNUNET_assert (NULL == n->env);
328  n->env =
330  n->env_size = ntohs (msg->size);
331  {
332  struct GNUNET_MQ_Envelope *env;
333 
335  obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
336  }
337  obm->peer = n->id;
338  if (0 == n->ready_window)
339  {
341  "Flow control delays transmission to CORE until we see SEND_OK.\n");
342  return; /* can't send yet, need to wait for SEND_OK */
343  }
344  do_send (n);
345 }
346 
347 
355 static void
356 mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
357 {
358  struct Neighbour *n = impl_state;
359 
360  GNUNET_assert (mq == n->mq);
361  n->mq = NULL;
362 }
363 
364 
372 static void
373 mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
374 {
375  struct Neighbour *n = impl_state;
376 
377  n->ready_window++;
378  if (GNUNET_YES == n->awaiting_done)
379  {
381  n->env = NULL;
383  }
384  else
385  {
386  GNUNET_assert (0 == n->ready_window);
387  n->env = NULL;
388  }
389 }
390 
391 
400 static void
401 peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
402 {
403  /* struct Neighbour *n = cls; */
404 
405  GNUNET_break_op (0);
406 }
407 
408 
415 static void
416 handle_connect (void *cls, const struct ConnectInfoMessage *cim)
417 {
419  struct Neighbour *n;
420 
422  "Receiving CONNECT message for `%s'\n",
423  GNUNET_i2s (&cim->id));
424  n = neighbour_find (h, &cim->id);
425  if (NULL != n)
426  {
427  GNUNET_break (0);
429  return;
430  }
431  n = GNUNET_new (struct Neighbour);
432  n->id = cim->id;
433  n->h = h;
437  h->neighbours,
438  &n->id,
439  n,
441 
445  n,
446  h->handlers,
448  n);
449  if (NULL != h->nc_cb)
450  {
451  n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
453  }
454 }
455 
456 
463 static void
464 handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
465 {
467  struct Neighbour *n;
468 
469  GNUNET_break (ntohl (dim->reserved) == 0);
471  "Receiving DISCONNECT message for `%s'.\n",
472  GNUNET_i2s (&dim->peer));
473  n = neighbour_find (h, &dim->peer);
474  if (NULL == n)
475  {
476  GNUNET_break (0);
478  return;
479  }
481 }
482 
483 
490 static void
491 handle_send_ok (void *cls, const struct SendOkMessage *okm)
492 {
494  struct Neighbour *n;
495 
497  "Receiving SEND_OK message for transmission to %s\n",
498  GNUNET_i2s (&okm->peer));
499  n = neighbour_find (h, &okm->peer);
500  if (NULL == n)
501  {
502  /* We should never get a 'SEND_OK' for a peer that we are not
503  connected to */
504  GNUNET_break (0);
506  return;
507  }
508  n->ready_window++;
509  if ((NULL != n->env) && (1 == n->ready_window))
510  do_send (n);
511 }
512 
513 
520 static int
521 check_recv (void *cls, const struct InboundMessage *im)
522 {
523  const struct GNUNET_MessageHeader *imm;
524  uint16_t size;
525 
527  "check_recv\n");
528  size = ntohs (im->header.size) - sizeof(*im);
529  if (size < sizeof(struct GNUNET_MessageHeader))
530  {
531  GNUNET_break (0);
532  return GNUNET_SYSERR;
533  }
534  imm = (const struct GNUNET_MessageHeader *) &im[1];
535  if (ntohs (imm->size) != size)
536  {
537  GNUNET_break (0);
538  return GNUNET_SYSERR;
539  }
540  return GNUNET_OK;
541 }
542 
543 
550 static void
551 handle_recv (void *cls, const struct InboundMessage *im)
552 {
554  const struct GNUNET_MessageHeader *imm =
555  (const struct GNUNET_MessageHeader *) &im[1];
556  struct Neighbour *n;
557 
559  "Received message of type %u with %u bytes from `%s'.\n",
560  (unsigned int) ntohs (imm->type),
561  (unsigned int) ntohs (imm->size),
562  GNUNET_i2s (&im->peer));
563  n = neighbour_find (h, &im->peer);
564  if (NULL == n)
565  {
566  GNUNET_break (0);
568  return;
569  }
570  GNUNET_MQ_inject_message (n->mq, imm);
571 }
572 
573 
579 static void
580 reconnect (void *cls)
581 {
584  { GNUNET_MQ_hd_fixed_size (connect,
586  struct ConnectInfoMessage,
587  h),
590  struct DisconnectInfoMessage,
591  h),
592  GNUNET_MQ_hd_fixed_size (send_ok,
594  struct SendOkMessage,
595  h),
596  GNUNET_MQ_hd_var_size (recv,
598  struct InboundMessage,
599  h),
601  struct GNUNET_MQ_Envelope *env;
602  struct StartMessage *s;
603  uint32_t options;
604 
605  h->reconnect_task = NULL;
606  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
607  GNUNET_assert (NULL == h->mq);
608  h->mq =
610  if (NULL == h->mq)
611  return;
613  options = 0;
614  if (h->check_self)
615  options |= 1;
616  if (NULL != h->handlers)
617  options |= 2;
618  s->options = htonl (options);
619  s->self = h->self;
620  GNUNET_MQ_send (h->mq, env);
621 }
622 
623 
629 static void
631 {
633  if (NULL != h->mq)
634  {
636  h->mq = NULL;
637  }
638 }
639 
640 
647 static void
649 {
650  GNUNET_assert (NULL == h->reconnect_task);
651  disconnect (h);
653  "Scheduling task to reconnect to transport service in %s.\n",
655  h->reconnect_task =
656  GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
657  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
658 }
659 
660 
668 struct GNUNET_MQ_Handle *
670  const struct GNUNET_PeerIdentity *peer)
671 {
672  struct Neighbour *n;
673 
674  n = neighbour_find (handle, peer);
675  if (NULL == n)
676  return NULL;
677  return n->mq;
678 }
679 
680 
701 void
702 GNUNET_TRANSPORT_core_receive_continue (struct GNUNET_TRANSPORT_CoreHandle *ch,
703  const struct GNUNET_PeerIdentity *pid)
704 {
705  struct GNUNET_MQ_Envelope *env;
706  struct RecvOkMessage *rok;
707 
709  "Message for %s finished CORE processing, sending RECV_OK.\n",
710  GNUNET_i2s (pid));
711  if (NULL == ch->mq)
712  return;
714  rok->increase_window_delta = htonl (1);
715  rok->peer = *pid;
716  GNUNET_MQ_send (ch->mq, env);
717 }
718 
719 
735  const struct GNUNET_PeerIdentity *self,
736  const struct GNUNET_MQ_MessageHandler *handlers,
737  void *cls,
740 {
742  unsigned int i;
743 
745  if (NULL != self)
746  {
747  h->self = *self;
748  h->check_self = GNUNET_YES;
749  }
750  h->cfg = cfg;
751  h->cls = cls;
752  h->nc_cb = nc;
753  h->nd_cb = nd;
754  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
755  if (NULL != handlers)
756  {
757  for (i = 0; NULL != handlers[i].cb; i++)
758  ;
759  h->handlers = GNUNET_new_array (i + 1, struct GNUNET_MQ_MessageHandler);
760  GNUNET_memcpy (h->handlers,
761  handlers,
762  i * sizeof(struct GNUNET_MQ_MessageHandler));
763  }
764  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
765  reconnect (h);
766  if (NULL == h->mq)
767  {
768  GNUNET_free (h->handlers);
769  GNUNET_free (h);
770  return NULL;
771  }
772  h->neighbours =
774  return h;
775 }
776 
777 
784 void
786 {
787  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
788  /* this disconnects all neighbours... */
789  disconnect (handle);
790  /* and now we stop trying to connect again... */
791  if (NULL != handle->reconnect_task)
792  {
794  handle->reconnect_task = NULL;
795  }
797  handle->neighbours = NULL;
798  GNUNET_free (handle->handlers);
799  handle->handlers = NULL;
801 }
802 
803 
804 /* 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_log(kind,...)
#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:1066
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:770
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:302
#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:467
#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:423
#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:186
#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:640
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:841
#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:491
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:815
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:881
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:685
#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:570
#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.