GNUnet 0.21.0
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_protocols.h"
32#include "transport.h"
33
34#define LOG(kind, ...) GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)
35
39#define STARTING_NEIGHBOURS_SIZE 16
40
49#define SEND_WINDOW_SIZE 4
50
51
55struct Neighbour
56{
61
66
71
76
81
86 unsigned int ready_window;
87
96
100 uint16_t env_size;
101};
102
103
109{
113 void *cls;
114
120
125
130
135
140
146
151
156
161
166
172};
173
174
181static void
183
184
192static struct Neighbour *
194 const struct GNUNET_PeerIdentity *peer)
195{
196 return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
197}
198
199
210static int
211neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
212{
214 struct Neighbour *n = value;
215
217 "Dropping entry for neighbour `%s'.\n",
218 GNUNET_i2s (key));
219 if (NULL != handle->nd_cb)
220 handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
221 if (NULL != n->env)
222 {
224 n->env = NULL;
225 }
227 GNUNET_assert (NULL == n->mq);
229 GNUNET_YES ==
231 GNUNET_free (n);
232 return GNUNET_YES;
233}
234
235
245static void
246mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
247{
249
251 "Error %u received from transport service, disconnecting temporarily.\n",
252 error);
254}
255
256
267static void
269{
270 struct Neighbour *n = cls;
271
273 n->env = NULL;
274 if (0 < n->ready_window)
276}
277
278
285static void
287{
289 GNUNET_assert (NULL != n->env);
290 n->ready_window--;
293 GNUNET_MQ_send (n->h->mq, n->env);
295 "Passed message of type %u for neighbour `%s' to TRANSPORT. ready_window %u\n",
296 ntohs (GNUNET_MQ_env_get_msg (n->env)->type),
297 GNUNET_i2s (&n->id),
298 n->ready_window);
299}
300
301
312static void
314 const struct GNUNET_MessageHeader *msg,
315 void *impl_state)
316{
317 struct Neighbour *n = impl_state;
318 struct OutboundMessage *obm;
319 uint16_t msize;
320
321 msize = ntohs (msg->size);
322 if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
323 {
324 GNUNET_break (0);
326 return;
327 }
329 "CORE requested transmission of message of type %u to neighbour `%s'.\n",
330 ntohs (msg->type),
331 GNUNET_i2s (&n->id));
332
333 GNUNET_assert (NULL == n->env);
334 n->env =
336 n->env_size = ntohs (msg->size);
337 {
338 struct GNUNET_MQ_Envelope *env;
339
341 obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
342 }
343 obm->peer = n->id;
344 if (0 == n->ready_window)
345 {
347 "Flow control delays transmission to CORE until we see SEND_OK.\n");
348 return; /* can't send yet, need to wait for SEND_OK */
349 }
350 do_send (n);
351}
352
353
361static void
362mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
363{
364 struct Neighbour *n = impl_state;
365
366 GNUNET_assert (mq == n->mq);
367 n->mq = NULL;
368}
369
370
378static void
379mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
380{
381 struct Neighbour *n = impl_state;
382
383 n->ready_window++;
384 if (GNUNET_YES == n->awaiting_done)
385 {
387 n->env = NULL;
389 }
390 else
391 {
392 GNUNET_assert (0 == n->ready_window);
393 n->env = NULL;
394 }
395}
396
397
406static void
408{
409 struct Neighbour *n = cls;
410
411 if (GNUNET_MQ_ERROR_MALFORMED == error)
412 GNUNET_break_op (0);
413 //TODO Look into bug #7887
414
415 GNUNET_TRANSPORT_core_receive_continue (n->h, &n->id);
416}
417
418
425static void
426handle_connect (void *cls, const struct ConnectInfoMessage *cim)
427{
429 struct Neighbour *n;
430
432 "Receiving CONNECT message for `%s'\n",
433 GNUNET_i2s (&cim->id));
434 n = neighbour_find (h, &cim->id);
435 if (NULL != n)
436 {
437 GNUNET_break (0);
439 return;
440 }
441 n = GNUNET_new (struct Neighbour);
442 n->id = cim->id;
443 n->h = h;
447 h->neighbours,
448 &n->id,
449 n,
451
455 n,
456 h->handlers,
458 n);
459 if (NULL != h->nc_cb)
460 {
461 n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
463 }
464}
465
466
473static void
475{
477 struct Neighbour *n;
478
479 GNUNET_break (ntohl (dim->reserved) == 0);
481 "Receiving DISCONNECT message for `%s'.\n",
482 GNUNET_i2s (&dim->peer));
483 n = neighbour_find (h, &dim->peer);
484 if (NULL == n)
485 {
486 GNUNET_break (0);
488 return;
489 }
491}
492
493
500static void
501handle_send_ok (void *cls, const struct SendOkMessage *okm)
502{
504 struct Neighbour *n;
505
507 "Receiving SEND_OK message for transmission to %s\n",
508 GNUNET_i2s (&okm->peer));
509
510 n = neighbour_find (h, &okm->peer);
511
512 if (NULL == n)
513 {
514 /* We should never get a 'SEND_OK' for a peer that we are not
515 connected to */
516 GNUNET_break (0);
518 return;
519 }
520
521 if ((GNUNET_NO == n->awaiting_done) &&
522 (NULL != n->env) &&
523 (0 == n->ready_window))
524 {
525 n->ready_window++;
526 do_send (n);
527 return;
528 }
529 else if ((GNUNET_NO == n->awaiting_done) &&
530 (0 == n->ready_window))
531 {
532 n->ready_window++;
534 return;
535 }
536 n->ready_window++;
537}
538
539
546static int
547check_recv (void *cls, const struct InboundMessage *im)
548{
549 const struct GNUNET_MessageHeader *imm;
550 uint16_t size;
551
553 "check_recv\n");
554 size = ntohs (im->header.size) - sizeof(*im);
555 if (size < sizeof(struct GNUNET_MessageHeader))
556 {
557 GNUNET_break (0);
558 return GNUNET_SYSERR;
559 }
560 imm = (const struct GNUNET_MessageHeader *) &im[1];
561 if (ntohs (imm->size) != size)
562 {
563 GNUNET_break (0);
564 return GNUNET_SYSERR;
565 }
566 return GNUNET_OK;
567}
568
569
576static void
577handle_recv (void *cls, const struct InboundMessage *im)
578{
580 const struct GNUNET_MessageHeader *imm =
581 (const struct GNUNET_MessageHeader *) &im[1];
582 struct Neighbour *n;
583
585 "Received message of type %u with %u bytes from `%s'.\n",
586 (unsigned int) ntohs (imm->type),
587 (unsigned int) ntohs (imm->size),
588 GNUNET_i2s (&im->peer));
589 n = neighbour_find (h, &im->peer);
590 if (NULL == n)
591 {
592 GNUNET_break (0);
594 return;
595 }
597}
598
599
605static void
606reconnect (void *cls)
607{
610 { GNUNET_MQ_hd_fixed_size (connect,
612 struct ConnectInfoMessage,
613 h),
617 h),
620 struct SendOkMessage,
621 h),
624 struct InboundMessage,
625 h),
627 struct GNUNET_MQ_Envelope *env;
628 struct StartMessage *s;
629 uint32_t options;
630
631 h->reconnect_task = NULL;
632 LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
633 GNUNET_assert (NULL == h->mq);
634 h->mq =
636 h->restarted_at = GNUNET_TIME_absolute_get ();
637 if (NULL == h->mq)
638 return;
640 options = 0;
641 if (h->check_self)
642 options |= 1;
643 if (NULL != h->handlers)
644 options |= 2;
645 s->options = htonl (options);
646 s->self = h->self;
648}
649
650
656static void
658{
660 if (NULL != h->mq)
661 {
663 h->mq = NULL;
664 }
665}
666
667
674static void
676{
677 GNUNET_assert (NULL == h->reconnect_task);
678 disconnect (h);
679 {
680 /* Reduce delay based on runtime of the connection,
681 so that there is a cool-down if a connection is up
682 for a while. */
683 struct GNUNET_TIME_Relative runtime;
684 unsigned int minutes;
685
686 runtime = GNUNET_TIME_absolute_get_duration (h->restarted_at);
687 minutes = runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us;
688 if (minutes > 31)
689 h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
690 else
691 h->reconnect_delay.rel_value_us >>= minutes;
692 }
694 "Scheduling task to reconnect to transport service in %s.\n",
697 GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
698 h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
699}
700
701
709struct GNUNET_MQ_Handle *
711 const struct GNUNET_PeerIdentity *peer)
712{
713 struct Neighbour *n;
714
715 n = neighbour_find (handle, peer);
716 if (NULL == n)
717 return NULL;
718 return n->mq;
719}
720
721
742void
743GNUNET_TRANSPORT_core_receive_continue (struct GNUNET_TRANSPORT_CoreHandle *ch,
744 const struct GNUNET_PeerIdentity *pid)
745{
746 struct GNUNET_MQ_Envelope *env;
747 struct RecvOkMessage *rok;
748
750 "Message for %s finished CORE processing, sending RECV_OK.\n",
751 GNUNET_i2s (pid));
752 if (NULL == ch->mq)
753 return;
755 rok->increase_window_delta = htonl (1);
756 rok->peer = *pid;
758}
759
760
776 const struct GNUNET_PeerIdentity *self,
778 void *cls,
781{
783 unsigned int i;
784
786 if (NULL != self)
787 {
788 h->self = *self;
789 h->check_self = GNUNET_YES;
790 }
791 h->cfg = cfg;
792 h->cls = cls;
793 h->nc_cb = nc;
794 h->nd_cb = nd;
795 h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
796 if (NULL != handlers)
797 {
798 for (i = 0; NULL != handlers[i].cb; i++)
799 ;
800 h->handlers = GNUNET_new_array (i + 1, struct GNUNET_MQ_MessageHandler);
801 GNUNET_memcpy (h->handlers,
802 handlers,
803 i * sizeof(struct GNUNET_MQ_MessageHandler));
804 }
805 LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
806 reconnect (h);
807 if (NULL == h->mq)
808 {
809 GNUNET_free (h->handlers);
810 GNUNET_free (h);
811 return NULL;
812 }
813 h->neighbours =
815 return h;
816}
817
818
825void
827{
828 LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
829 /* this disconnects all neighbours... */
831 /* and now we stop trying to connect again... */
832 if (NULL != handle->reconnect_task)
833 {
834 GNUNET_SCHEDULER_cancel (handle->reconnect_task);
835 handle->reconnect_task = NULL;
836 }
838 handle->neighbours = NULL;
839 GNUNET_free (handle->handlers);
840 handle->handlers = NULL;
842}
843
844
845/* end of transport_api_core.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
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 struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static struct GNUNET_NotificationContext * nc
Notification context for broadcasting to monitors.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
uint32_t dim
Definition: gnunet_pq_lib.h:3
Constants for network protocols.
API of the transport service towards the CORE service (TNG version)
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
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_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.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
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
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_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_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.
enum GNUNET_GenericReturnValue 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.
@ 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_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#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:768
GNUNET_MQ_Error
Error codes for the queue.
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:465
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:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#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:421
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
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:187
#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:638
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:879
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:839
#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:489
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:813
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
@ GNUNET_MQ_ERROR_MALFORMED
We received a message that was malformed and thus could not be passed to its handler.
#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:975
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:1272
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
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
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_MINUTES
One minute.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
static unsigned int size
Size of the "table".
Definition: peer.c:68
Message from the transport service to the library informing about neighbors.
Definition: transport.h:88
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:111
Message from the transport service to the library informing about disconnects.
Definition: transport.h:120
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:142
Internal representation of the hash map.
Handle to a message queue.
Definition: mq.c:87
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:136
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
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.
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the task trying to reconnect to the service.
GNUNET_TRANSPORT_NotifyDisconnect nd_cb
function to call on disconnect events
struct GNUNET_MQ_MessageHandler * handlers
Functions to call for received data (template for new message queues).
void * cls
Closure for the callbacks.
struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map of the current connected neighbours of this peer.
GNUNET_TRANSPORT_NotifyConnect nc_cb
function to call on connect events
struct GNUNET_TIME_Relative reconnect_delay
Delay until we try to reconnect.
const struct GNUNET_CONFIGURATION_Handle * cfg
My configuration.
struct GNUNET_MQ_Handle * mq
My client connection to the transport service.
struct GNUNET_TIME_Absolute restarted_at
Transport connection started at.
Message used to notify the transport API about a message received from the network.
Definition: transport.h:143
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV.
Definition: transport.h:147
struct GNUNET_PeerIdentity peer
Which peer sent the message?
Definition: transport.h:152
A neighbour that at least one communicator is connected to.
uint16_t env_size
Size of the message in env.
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).
void * handlers_cls
Closure for mq handlers.
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.
struct GNUNET_TRANSPORT_CoreHandle * h
Overall transport handle.
struct GNUNET_MQ_Handle * mq
Active message queue for the peer.
Message used to notify the transport service about a message to be transmitted to another peer.
Definition: transport.h:229
uint32_t priority
An enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: transport.h:238
struct GNUNET_PeerIdentity peer
Which peer should receive the message?
Definition: transport.h:252
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:205
struct GNUNET_PeerIdentity peer
Which peer can CORE handle more from now?
Definition: transport.h:220
uint32_t increase_window_delta
Number of messages by which to increase the window, greater or equal to one.
Definition: transport.h:215
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:161
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:195
Message from the transport service to the library asking to check if both processes agree about this ...
Definition: transport.h:62
uint32_t options
0: no options 1: The self field should be checked 2: this client is interested in payload traffic
Definition: transport.h:73
struct GNUNET_PeerIdentity self
Identity we think we have.
Definition: transport.h:79
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 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.
static struct Neighbour * neighbour_find(struct GNUNET_TRANSPORT_CoreHandle *h, const struct GNUNET_PeerIdentity *peer)
Get the neighbour list entry for the given peer.
#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,...)
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.
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.