2 This file is part of GNUnet.
3 Copyright (C) 2001-2017 GNUnet e.V.
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
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 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
21 * @file cadet/gnunet-service-cadet-new_channel.c
22 * @brief logical links between CADET clients
23 * @author Bartlomiej Polot
24 * @author Christian Grothoff
27 * - Congestion/flow control:
28 * + estimate max bandwidth using bursts and use to for CONGESTION CONTROL!
29 * (and figure out how/where to use this!)
30 * + figure out flow control without ACKs (unreliable traffic!)
31 * - revisit handling of 'unbuffered' traffic!
32 * (need to push down through tunnel into connection selection)
33 * - revisit handling of 'buffered' traffic: 4 is a rather small buffer; maybe
34 * reserve more bits in 'options' to allow for buffer size control?
37 #include "gnunet_util_lib.h"
39 #include "gnunet_statistics_service.h"
40 #include "gnunet-service-cadet-new.h"
41 #include "gnunet-service-cadet-new_channel.h"
42 #include "gnunet-service-cadet-new_connection.h"
43 #include "gnunet-service-cadet-new_tunnels.h"
44 #include "gnunet-service-cadet-new_peer.h"
45 #include "gnunet-service-cadet-new_paths.h"
47 #define LOG(level,...) GNUNET_log_from (level,"cadet-chn",__VA_ARGS__)
50 * How long do we initially wait before retransmitting?
52 #define CADET_INITIAL_RETRANSMIT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250)
55 * How long do we wait before dropping state about incoming
56 * connection to closed port?
58 #define TIMEOUT_CLOSED_PORT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
61 * How long do we wait at least before retransmitting ever?
63 #define MIN_RTT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 75)
66 * Maximum message ID into the future we accept for out-of-order messages.
67 * If the message is more than this into the future, we drop it. This is
68 * important both to detect values that are actually in the past, as well
69 * as to limit adversarially triggerable memory consumption.
71 * Note that right now we have "max_pending_messages = 4" hard-coded in
72 * the logic below, so a value of 4 would suffice here. But we plan to
73 * allow larger windows in the future...
75 #define MAX_OUT_OF_ORDER_DISTANCE 1024
79 * All the states a channel can be in.
81 enum CadetChannelState
84 * Uninitialized status, should never appear in operation.
89 * Channel is to a port that is not open, we're waiting for the
95 * CHANNEL_OPEN message sent, waiting for CHANNEL_OPEN_ACK.
97 CADET_CHANNEL_OPEN_SENT,
100 * Connection confirmed, ready to carry traffic.
107 * Info needed to retry a message in case it gets lost.
108 * Note that we DO use this structure also for unreliable
111 struct CadetReliableMessage
114 * Double linked list, FIFO style
116 struct CadetReliableMessage *next;
119 * Double linked list, FIFO style
121 struct CadetReliableMessage *prev;
124 * Which channel is this message in?
126 struct CadetChannel *ch;
129 * Entry in the tunnels queue for this message, NULL if it has left
130 * the tunnel. Used to cancel transmission in case we receive an
133 struct CadetTunnelQueueEntry *qe;
136 * Data message we are trying to send.
138 struct GNUNET_CADET_ChannelAppDataMessage *data_message;
141 * How soon should we retry if we fail to get an ACK?
142 * Messages in the queue are sorted by this value.
144 struct GNUNET_TIME_Absolute next_retry;
147 * How long do we wait for an ACK after transmission?
148 * Use for the back-off calculation.
150 struct GNUNET_TIME_Relative retry_delay;
153 * Time when we first successfully transmitted the message
154 * (that is, set @e num_transmissions to 1).
156 struct GNUNET_TIME_Absolute first_transmission_time;
159 * Identifier of the connection that this message took when it
160 * was first transmitted. Only useful if @e num_transmissions is 1.
162 struct GNUNET_CADET_ConnectionTunnelIdentifier connection_taken;
165 * How often was this message transmitted? #GNUNET_SYSERR if there
166 * was an error transmitting the message, #GNUNET_NO if it was not
167 * yet transmitted ever, otherwise the number of (re) transmissions.
169 int num_transmissions;
175 * List of received out-of-order data messages.
177 struct CadetOutOfOrderMessage
180 * Double linked list, FIFO style
182 struct CadetOutOfOrderMessage *next;
185 * Double linked list, FIFO style
187 struct CadetOutOfOrderMessage *prev;
190 * ID of the message (messages up to this point needed
191 * before we give this one to the client).
193 struct ChannelMessageIdentifier mid;
196 * The envelope with the payload of the out-of-order message
198 struct GNUNET_MQ_Envelope *env;
204 * Client endpoint of a `struct CadetChannel`. A channel may be a
205 * loopback channel, in which case it has two of these endpoints.
206 * Note that flow control also is required in both directions.
208 struct CadetChannelClient
211 * Client handle. Not by itself sufficient to designate
212 * the client endpoint, as the same client handle may
213 * be used for both the owner and the destination, and
214 * we thus also need the channel ID to identify the client.
216 struct CadetClient *c;
219 * Head of DLL of messages received out of order or while client was unready.
221 struct CadetOutOfOrderMessage *head_recv;
224 * Tail DLL of messages received out of order or while client was unready.
226 struct CadetOutOfOrderMessage *tail_recv;
229 * Local tunnel number for this client.
230 * (if owner >= #GNUNET_CADET_LOCAL_CHANNEL_ID_CLI,
231 * otherwise < #GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
233 struct GNUNET_CADET_ClientChannelNumber ccn;
236 * Number of entries currently in @a head_recv DLL.
238 unsigned int num_recv;
241 * Can we send data to the client?
249 * Struct containing all information regarding a channel to a remote client.
254 * Tunnel this channel is in.
256 struct CadetTunnel *t;
259 * Client owner of the tunnel, if any.
260 * (Used if this channel represends the initiating end of the tunnel.)
262 struct CadetChannelClient *owner;
265 * Client destination of the tunnel, if any.
266 * (Used if this channel represents the listening end of the tunnel.)
268 struct CadetChannelClient *dest;
271 * Last entry in the tunnel's queue relating to control messages
272 * (#GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN or
273 * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK). Used to cancel
274 * transmission in case we receive updated information.
276 struct CadetTunnelQueueEntry *last_control_qe;
279 * Head of DLL of messages sent and not yet ACK'd.
281 struct CadetReliableMessage *head_sent;
284 * Tail of DLL of messages sent and not yet ACK'd.
286 struct CadetReliableMessage *tail_sent;
289 * Task to resend/poll in case no ACK is received.
291 struct GNUNET_SCHEDULER_Task *retry_control_task;
294 * Task to resend/poll in case no ACK is received.
296 struct GNUNET_SCHEDULER_Task *retry_data_task;
299 * Last time the channel was used
301 struct GNUNET_TIME_Absolute timestamp;
304 * Destination port of the channel.
306 struct GNUNET_HashCode port;
309 * Counter for exponential backoff.
311 struct GNUNET_TIME_Relative retry_time;
314 * Bitfield of already-received messages past @e mid_recv.
316 uint64_t mid_futures;
319 * Next MID expected for incoming traffic.
321 struct ChannelMessageIdentifier mid_recv;
324 * Next MID to use for outgoing traffic.
326 struct ChannelMessageIdentifier mid_send;
329 * Total (reliable) messages pending ACK for this channel.
331 unsigned int pending_messages;
334 * Maximum (reliable) messages pending ACK for this channel
335 * before we throttle the client.
337 unsigned int max_pending_messages;
340 * Number identifying this channel in its tunnel.
342 struct GNUNET_CADET_ChannelTunnelNumber ctn;
347 enum CadetChannelState state;
350 * Count how many ACKs we skipped, used to prevent long
351 * sequences of ACK skipping.
353 unsigned int skip_ack_series;
356 * Is the tunnel bufferless (minimum latency)?
361 * Is the tunnel reliable?
366 * Is the tunnel out-of-order?
371 * Is this channel a loopback channel, where the destination is us again?
376 * Flag to signal the destruction of the channel. If this is set to
377 * #GNUNET_YES the channel will be destroyed once the queue is
386 * Get the static string for identification of the channel.
390 * @return Static string with the channel IDs.
393 GCCH_2s (const struct CadetChannel *ch)
395 static char buf[128];
397 GNUNET_snprintf (buf,
399 "Channel %s:%s ctn:%X(%X/%X)",
400 (GNUNET_YES == ch->is_loopback)
402 : GNUNET_i2s (GCP_get_id (GCT_get_destination (ch->t))),
403 GNUNET_h2s (&ch->port),
405 (NULL == ch->owner) ? 0 : ntohl (ch->owner->ccn.channel_of_client),
406 (NULL == ch->dest) ? 0 : ntohl (ch->dest->ccn.channel_of_client));
412 * Get the channel's public ID.
416 * @return ID used to identify the channel with the remote peer.
418 struct GNUNET_CADET_ChannelTunnelNumber
419 GCCH_get_id (const struct CadetChannel *ch)
426 * Release memory associated with @a ccc
428 * @param ccc data structure to clean up
431 free_channel_client (struct CadetChannelClient *ccc)
433 struct CadetOutOfOrderMessage *com;
435 while (NULL != (com = ccc->head_recv))
437 GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
441 GNUNET_MQ_discard (com->env);
449 * Destroy the given channel.
451 * @param ch channel to destroy
454 channel_destroy (struct CadetChannel *ch)
456 struct CadetReliableMessage *crm;
458 while (NULL != (crm = ch->head_sent))
460 GNUNET_assert (ch == crm->ch);
463 GCT_send_cancel (crm->qe);
466 GNUNET_CONTAINER_DLL_remove (ch->head_sent,
469 GNUNET_free (crm->data_message);
472 if (NULL != ch->owner)
474 free_channel_client (ch->owner);
477 if (NULL != ch->dest)
479 free_channel_client (ch->dest);
482 if (NULL != ch->last_control_qe)
484 GCT_send_cancel (ch->last_control_qe);
485 ch->last_control_qe = NULL;
487 if (NULL != ch->retry_data_task)
489 GNUNET_SCHEDULER_cancel (ch->retry_data_task);
490 ch->retry_data_task = NULL;
492 if (NULL != ch->retry_control_task)
494 GNUNET_SCHEDULER_cancel (ch->retry_control_task);
495 ch->retry_control_task = NULL;
497 if (GNUNET_NO == ch->is_loopback)
499 GCT_remove_channel (ch->t,
509 * Send a channel create message.
511 * @param cls Channel for which to send.
514 send_channel_open (void *cls);
518 * Function called once the tunnel confirms that we sent the
519 * create message. Delays for a bit until we retry.
521 * @param cls our `struct CadetChannel`.
522 * @param cid identifier of the connection within the tunnel, NULL
523 * if transmission failed
526 channel_open_sent_cb (void *cls,
527 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
529 struct CadetChannel *ch = cls;
531 GNUNET_assert (NULL != ch->last_control_qe);
532 ch->last_control_qe = NULL;
533 ch->retry_time = GNUNET_TIME_STD_BACKOFF (ch->retry_time);
534 LOG (GNUNET_ERROR_TYPE_DEBUG,
535 "Sent CADET_CHANNEL_OPEN on %s, retrying in %s\n",
537 GNUNET_STRINGS_relative_time_to_string (ch->retry_time,
539 ch->retry_control_task
540 = GNUNET_SCHEDULER_add_delayed (ch->retry_time,
547 * Send a channel open message.
549 * @param cls Channel for which to send.
552 send_channel_open (void *cls)
554 struct CadetChannel *ch = cls;
555 struct GNUNET_CADET_ChannelOpenMessage msgcc;
558 ch->retry_control_task = NULL;
559 LOG (GNUNET_ERROR_TYPE_DEBUG,
560 "Sending CHANNEL_OPEN message for %s\n",
564 options |= GNUNET_CADET_OPTION_NOBUFFER;
566 options |= GNUNET_CADET_OPTION_RELIABLE;
567 if (ch->out_of_order)
568 options |= GNUNET_CADET_OPTION_OUT_OF_ORDER;
569 msgcc.header.size = htons (sizeof (msgcc));
570 msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN);
571 msgcc.opt = htonl (options);
572 msgcc.port = ch->port;
574 ch->state = CADET_CHANNEL_OPEN_SENT;
575 if (NULL != ch->last_control_qe)
576 GCT_send_cancel (ch->last_control_qe);
577 ch->last_control_qe = GCT_send (ch->t,
579 &channel_open_sent_cb,
581 GNUNET_assert (NULL == ch->retry_control_task);
586 * Function called once and only once after a channel was bound
587 * to its tunnel via #GCT_add_channel() is ready for transmission.
588 * Note that this is only the case for channels that this peer
589 * initiates, as for incoming channels we assume that they are
590 * ready for transmission immediately upon receiving the open
591 * message. Used to bootstrap the #GCT_send() process.
593 * @param ch the channel for which the tunnel is now ready
596 GCCH_tunnel_up (struct CadetChannel *ch)
598 GNUNET_assert (NULL == ch->retry_control_task);
599 LOG (GNUNET_ERROR_TYPE_DEBUG,
600 "Tunnel up, sending CHANNEL_OPEN on %s now\n",
602 ch->retry_control_task
603 = GNUNET_SCHEDULER_add_now (&send_channel_open,
609 * Create a new channel.
611 * @param owner local client owning the channel
612 * @param ccn local number of this channel at the @a owner
613 * @param destination peer to which we should build the channel
614 * @param port desired port at @a destination
615 * @param options options for the channel
616 * @return handle to the new channel
618 struct CadetChannel *
619 GCCH_channel_local_new (struct CadetClient *owner,
620 struct GNUNET_CADET_ClientChannelNumber ccn,
621 struct CadetPeer *destination,
622 const struct GNUNET_HashCode *port,
625 struct CadetChannel *ch;
626 struct CadetChannelClient *ccco;
628 ccco = GNUNET_new (struct CadetChannelClient);
631 ccco->client_ready = GNUNET_YES;
633 ch = GNUNET_new (struct CadetChannel);
634 ch->mid_recv.mid = htonl (1); /* The OPEN_ACK counts as message 0! */
635 ch->nobuffer = (0 != (options & GNUNET_CADET_OPTION_NOBUFFER));
636 ch->reliable = (0 != (options & GNUNET_CADET_OPTION_RELIABLE));
637 ch->out_of_order = (0 != (options & GNUNET_CADET_OPTION_OUT_OF_ORDER));
638 ch->max_pending_messages = (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */
641 if (0 == memcmp (&my_full_id,
642 GCP_get_id (destination),
643 sizeof (struct GNUNET_PeerIdentity)))
645 struct CadetClient *c;
647 ch->is_loopback = GNUNET_YES;
648 c = GNUNET_CONTAINER_multihashmap_get (open_ports,
652 /* port closed, wait for it to possibly open */
653 ch->state = CADET_CHANNEL_LOOSE;
654 (void) GNUNET_CONTAINER_multihashmap_put (loose_channels,
657 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
658 LOG (GNUNET_ERROR_TYPE_DEBUG,
659 "Created loose incoming loopback channel to port %s\n",
660 GNUNET_h2s (&ch->port));
664 ch->dest = GNUNET_new (struct CadetChannelClient);
666 ch->dest->client_ready = GNUNET_YES;
673 ch->t = GCP_get_tunnel (destination,
675 ch->retry_time = CADET_INITIAL_RETRANSMIT_TIME;
676 ch->ctn = GCT_add_channel (ch->t,
679 GNUNET_STATISTICS_update (stats,
683 LOG (GNUNET_ERROR_TYPE_DEBUG,
684 "Created channel to port %s at peer %s for %s using %s\n",
686 GCP_2s (destination),
688 (GNUNET_YES == ch->is_loopback) ? "loopback" : GCT_2s (ch->t));
694 * We had an incoming channel to a port that is closed.
695 * It has not been opened for a while, drop it.
697 * @param cls the channel to drop
700 timeout_closed_cb (void *cls)
702 struct CadetChannel *ch = cls;
704 ch->retry_control_task = NULL;
705 LOG (GNUNET_ERROR_TYPE_DEBUG,
706 "Closing incoming channel to port %s from peer %s due to timeout\n",
707 GNUNET_h2s (&ch->port),
708 GCP_2s (GCT_get_destination (ch->t)));
709 channel_destroy (ch);
714 * Create a new channel based on a request coming in over the network.
716 * @param t tunnel to the remote peer
717 * @param ctn identifier of this channel in the tunnel
718 * @param port desired local port
719 * @param options options for the channel
720 * @return handle to the new channel
722 struct CadetChannel *
723 GCCH_channel_incoming_new (struct CadetTunnel *t,
724 struct GNUNET_CADET_ChannelTunnelNumber ctn,
725 const struct GNUNET_HashCode *port,
728 struct CadetChannel *ch;
729 struct CadetClient *c;
731 ch = GNUNET_new (struct CadetChannel);
735 ch->retry_time = CADET_INITIAL_RETRANSMIT_TIME;
736 ch->nobuffer = (0 != (options & GNUNET_CADET_OPTION_NOBUFFER));
737 ch->reliable = (0 != (options & GNUNET_CADET_OPTION_RELIABLE));
738 ch->out_of_order = (0 != (options & GNUNET_CADET_OPTION_OUT_OF_ORDER));
739 ch->max_pending_messages = (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */
740 GNUNET_STATISTICS_update (stats,
745 c = GNUNET_CONTAINER_multihashmap_get (open_ports,
749 /* port closed, wait for it to possibly open */
750 ch->state = CADET_CHANNEL_LOOSE;
751 (void) GNUNET_CONTAINER_multihashmap_put (loose_channels,
754 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
755 ch->retry_control_task
756 = GNUNET_SCHEDULER_add_delayed (TIMEOUT_CLOSED_PORT,
759 LOG (GNUNET_ERROR_TYPE_DEBUG,
760 "Created loose incoming channel to port %s from peer %s\n",
761 GNUNET_h2s (&ch->port),
762 GCP_2s (GCT_get_destination (ch->t)));
769 GNUNET_STATISTICS_update (stats,
778 * Function called once the tunnel confirms that we sent the
779 * ACK message. Just remembers it was sent, we do not expect
782 * @param cls our `struct CadetChannel`.
783 * @param cid identifier of the connection within the tunnel, NULL
784 * if transmission failed
787 send_ack_cb (void *cls,
788 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
790 struct CadetChannel *ch = cls;
792 GNUNET_assert (NULL != ch->last_control_qe);
793 ch->last_control_qe = NULL;
798 * Compute and send the current #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK to the other peer.
800 * @param ch channel to send the #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK for
803 send_channel_data_ack (struct CadetChannel *ch)
805 struct GNUNET_CADET_ChannelDataAckMessage msg;
807 if (GNUNET_NO == ch->reliable)
808 return; /* no ACKs */
809 msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK);
810 msg.header.size = htons (sizeof (msg));
812 msg.mid.mid = htonl (ntohl (ch->mid_recv.mid));
813 msg.futures = GNUNET_htonll (ch->mid_futures);
814 LOG (GNUNET_ERROR_TYPE_DEBUG,
815 "Sending DATA_ACK %u:%llX via %s\n",
816 (unsigned int) ntohl (msg.mid.mid),
817 (unsigned long long) ch->mid_futures,
819 if (NULL != ch->last_control_qe)
820 GCT_send_cancel (ch->last_control_qe);
821 ch->last_control_qe = GCT_send (ch->t,
829 * Send our initial #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK to the client confirming that the
832 * @param cls the `struct CadetChannel`
835 send_open_ack (void *cls)
837 struct CadetChannel *ch = cls;
838 struct GNUNET_CADET_ChannelManageMessage msg;
840 LOG (GNUNET_ERROR_TYPE_DEBUG,
841 "Sending CHANNEL_OPEN_ACK on %s\n",
843 ch->retry_control_task = NULL;
844 msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK);
845 msg.header.size = htons (sizeof (msg));
846 msg.reserved = htonl (0);
848 if (NULL != ch->last_control_qe)
849 GCT_send_cancel (ch->last_control_qe);
850 ch->last_control_qe = GCT_send (ch->t,
858 * We got a #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN message again for
859 * this channel. If the binding was successful, (re)transmit the
860 * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK.
862 * @param ch channel that got the duplicate open
863 * @param cti identifier of the connection that delivered the message
866 GCCH_handle_duplicate_open (struct CadetChannel *ch,
867 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
869 if (NULL == ch->dest)
871 LOG (GNUNET_ERROR_TYPE_DEBUG,
872 "Ignoring duplicate CHANNEL_OPEN on %s: port is closed\n",
876 if (NULL != ch->retry_control_task)
878 LOG (GNUNET_ERROR_TYPE_DEBUG,
879 "Ignoring duplicate CHANNEL_OPEN on %s: control message is pending\n",
883 LOG (GNUNET_ERROR_TYPE_DEBUG,
884 "Retransmitting CHANNEL_OPEN_ACK on %s\n",
886 ch->retry_control_task
887 = GNUNET_SCHEDULER_add_now (&send_open_ack,
893 * Send a #GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK to the client to solicit more messages.
895 * @param ch channel the ack is for
896 * @param to_owner #GNUNET_YES to send to owner,
897 * #GNUNET_NO to send to dest
900 send_ack_to_client (struct CadetChannel *ch,
903 struct GNUNET_MQ_Envelope *env;
904 struct GNUNET_CADET_LocalAck *ack;
905 struct CadetChannelClient *ccc;
907 ccc = (GNUNET_YES == to_owner) ? ch->owner : ch->dest;
910 /* This can happen if we are just getting ACKs after
911 our local client already disconnected. */
912 GNUNET_assert (GNUNET_YES == ch->destroy);
915 env = GNUNET_MQ_msg (ack,
916 GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
918 LOG (GNUNET_ERROR_TYPE_DEBUG,
919 "Sending CADET_LOCAL_ACK to %s (%s) at ccn %X (%u/%u pending)\n",
921 (GNUNET_YES == to_owner) ? "owner" : "dest",
922 ntohl (ack->ccn.channel_of_client),
923 ch->pending_messages,
924 ch->max_pending_messages);
925 GSC_send_to_client (ccc->c,
931 * A client is bound to the port that we have a channel
932 * open to. Send the acknowledgement for the connection
933 * request and establish the link with the client.
935 * @param ch open incoming channel
936 * @param c client listening on the respective port
939 GCCH_bind (struct CadetChannel *ch,
940 struct CadetClient *c)
943 struct CadetChannelClient *cccd;
945 LOG (GNUNET_ERROR_TYPE_DEBUG,
946 "Binding %s from %s to port %s of %s\n",
949 GNUNET_h2s (&ch->port),
951 if (NULL != ch->retry_control_task)
953 /* there might be a timeout task here */
954 GNUNET_SCHEDULER_cancel (ch->retry_control_task);
955 ch->retry_control_task = NULL;
959 options |= GNUNET_CADET_OPTION_NOBUFFER;
961 options |= GNUNET_CADET_OPTION_RELIABLE;
962 if (ch->out_of_order)
963 options |= GNUNET_CADET_OPTION_OUT_OF_ORDER;
964 cccd = GNUNET_new (struct CadetChannelClient);
967 cccd->client_ready = GNUNET_YES;
968 cccd->ccn = GSC_bind (c,
970 (GNUNET_YES == ch->is_loopback)
971 ? GCP_get (&my_full_id,
973 : GCT_get_destination (ch->t),
976 GNUNET_assert (ntohl (cccd->ccn.channel_of_client) <
977 GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
978 ch->mid_recv.mid = htonl (1); /* The OPEN counts as message 0! */
979 if (GNUNET_YES == ch->is_loopback)
981 ch->state = CADET_CHANNEL_OPEN_SENT;
982 GCCH_handle_channel_open_ack (ch,
987 /* notify other peer that we accepted the connection */
988 ch->state = CADET_CHANNEL_READY;
989 ch->retry_control_task
990 = GNUNET_SCHEDULER_add_now (&send_open_ack,
993 /* give client it's initial supply of ACKs */
994 GNUNET_assert (ntohl (cccd->ccn.channel_of_client) <
995 GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
996 for (unsigned int i=0;i<ch->max_pending_messages;i++)
997 send_ack_to_client (ch,
1003 * Destroy locally created channel. Called by the local client, so no
1004 * need to tell the client.
1006 * @param ch channel to destroy
1007 * @param c client that caused the destruction
1008 * @param ccn client number of the client @a c
1011 GCCH_channel_local_destroy (struct CadetChannel *ch,
1012 struct CadetClient *c,
1013 struct GNUNET_CADET_ClientChannelNumber ccn)
1015 LOG (GNUNET_ERROR_TYPE_DEBUG,
1016 "%s asks for destruction of %s\n",
1019 GNUNET_assert (NULL != c);
1020 if ( (NULL != ch->owner) &&
1021 (c == ch->owner->c) &&
1022 (ccn.channel_of_client == ch->owner->ccn.channel_of_client) )
1024 free_channel_client (ch->owner);
1027 else if ( (NULL != ch->dest) &&
1028 (c == ch->dest->c) &&
1029 (ccn.channel_of_client == ch->dest->ccn.channel_of_client) )
1031 free_channel_client (ch->dest);
1039 if (GNUNET_YES == ch->destroy)
1041 /* other end already destroyed, with the local client gone, no need
1042 to finish transmissions, just destroy immediately. */
1043 channel_destroy (ch);
1046 if ( (NULL != ch->head_sent) &&
1047 ( (NULL != ch->owner) ||
1048 (NULL != ch->dest) ) )
1050 /* Wait for other end to destroy us as well,
1051 and otherwise allow send queue to be transmitted first */
1052 ch->destroy = GNUNET_YES;
1055 if (GNUNET_YES == ch->is_loopback)
1057 struct CadetChannelClient *ccc;
1059 /* Find which end is left... */
1060 ccc = (NULL != ch->owner) ? ch->owner : ch->dest;
1061 GSC_handle_remote_channel_destroy (ccc->c,
1064 channel_destroy (ch);
1067 /* If the we ever sent the CHANNEL_CREATE, we need to send a destroy message. */
1070 case CADET_CHANNEL_NEW:
1071 /* We gave up on a channel that we created as a client to a remote
1072 target, but that never went anywhere. Nothing to do here. */
1074 case CADET_CHANNEL_LOOSE:
1075 GSC_drop_loose_channel (&ch->port,
1079 GCT_send_channel_destroy (ch->t,
1082 /* Nothing left to do, just finish destruction */
1083 channel_destroy (ch);
1088 * We got an acknowledgement for the creation of the channel
1089 * (the port is open on the other side). Begin transmissions.
1091 * @param ch channel to destroy
1092 * @param cti identifier of the connection that delivered the message
1095 GCCH_handle_channel_open_ack (struct CadetChannel *ch,
1096 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
1100 case CADET_CHANNEL_NEW:
1101 /* this should be impossible */
1104 case CADET_CHANNEL_LOOSE:
1105 /* This makes no sense. */
1106 GNUNET_break_op (0);
1108 case CADET_CHANNEL_OPEN_SENT:
1109 if (NULL == ch->owner)
1111 /* We're not the owner, wrong direction! */
1112 GNUNET_break_op (0);
1115 LOG (GNUNET_ERROR_TYPE_DEBUG,
1116 "Received CHANNEL_OPEN_ACK for waiting %s, entering READY state\n",
1118 if (NULL != ch->retry_control_task) /* can be NULL if ch->is_loopback */
1120 GNUNET_SCHEDULER_cancel (ch->retry_control_task);
1121 ch->retry_control_task = NULL;
1123 ch->state = CADET_CHANNEL_READY;
1124 /* On first connect, send client as many ACKs as we allow messages
1126 for (unsigned int i=0;i<ch->max_pending_messages;i++)
1127 send_ack_to_client (ch,
1130 case CADET_CHANNEL_READY:
1131 /* duplicate ACK, maybe we retried the CREATE. Ignore. */
1132 LOG (GNUNET_ERROR_TYPE_DEBUG,
1133 "Received duplicate channel OPEN_ACK for %s\n",
1135 GNUNET_STATISTICS_update (stats,
1136 "# duplicate CREATE_ACKs",
1145 * Test if element @a e1 comes before element @a e2.
1147 * @param cls closure, to a flag where we indicate duplicate packets
1148 * @param m1 a message of to sort
1149 * @param m2 another message to sort
1150 * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO
1153 is_before (void *cls,
1154 struct CadetOutOfOrderMessage *m1,
1155 struct CadetOutOfOrderMessage *m2)
1157 int *duplicate = cls;
1158 uint32_t v1 = ntohl (m1->mid.mid);
1159 uint32_t v2 = ntohl (m2->mid.mid);
1164 *duplicate = GNUNET_YES;
1165 if (delta > (uint32_t) INT_MAX)
1167 /* in overflow range, we can safely assume we wrapped around */
1172 /* result is small, thus v2 > v1, thus m1 < m2 */
1179 * We got payload data for a channel. Pass it on to the client
1180 * and send an ACK to the other end (once flow control allows it!)
1182 * @param ch channel that got data
1183 * @param cti identifier of the connection that delivered the message
1184 * @param msg message that was received
1187 GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
1188 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
1189 const struct GNUNET_CADET_ChannelAppDataMessage *msg)
1191 struct GNUNET_MQ_Envelope *env;
1192 struct GNUNET_CADET_LocalData *ld;
1193 struct CadetChannelClient *ccc;
1194 size_t payload_size;
1195 struct CadetOutOfOrderMessage *com;
1202 GNUNET_assert (GNUNET_NO == ch->is_loopback);
1203 if ( (GNUNET_YES == ch->destroy) &&
1204 (NULL == ch->owner) &&
1205 (NULL == ch->dest) )
1207 /* This client is gone, but we still have messages to send to
1208 the other end (which is why @a ch is not yet dead). However,
1209 we cannot pass messages to our client anymore. */
1210 LOG (GNUNET_ERROR_TYPE_DEBUG,
1211 "Dropping incoming payload on %s as this end is already closed\n",
1213 /* send back DESTROY notification to stop further retransmissions! */
1214 GCT_send_channel_destroy (ch->t,
1218 payload_size = ntohs (msg->header.size) - sizeof (*msg);
1219 env = GNUNET_MQ_msg_extra (ld,
1221 GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA);
1222 ld->ccn = (NULL == ch->dest) ? ch->owner->ccn : ch->dest->ccn;
1223 GNUNET_memcpy (&ld[1],
1226 ccc = (NULL != ch->owner) ? ch->owner : ch->dest;
1227 if ( (GNUNET_YES == ccc->client_ready) &&
1228 ( (GNUNET_YES == ch->out_of_order) ||
1229 (msg->mid.mid == ch->mid_recv.mid) ) )
1231 LOG (GNUNET_ERROR_TYPE_DEBUG,
1232 "Giving %u bytes of payload with MID %u from %s to client %s\n",
1233 (unsigned int) payload_size,
1234 ntohl (msg->mid.mid),
1237 ccc->client_ready = GNUNET_NO;
1238 GSC_send_to_client (ccc->c,
1240 ch->mid_recv.mid = htonl (1 + ntohl (ch->mid_recv.mid));
1241 ch->mid_futures >>= 1;
1242 send_channel_data_ack (ch);
1246 if (GNUNET_YES == ch->reliable)
1248 /* check if message ought to be dropped because it is ancient/too distant/duplicate */
1249 mid_min = ntohl (ch->mid_recv.mid);
1250 mid_max = mid_min + ch->max_pending_messages;
1251 mid_msg = ntohl (msg->mid.mid);
1252 if ( ( (uint32_t) (mid_msg - mid_min) > ch->max_pending_messages) ||
1253 ( (uint32_t) (mid_max - mid_msg) > ch->max_pending_messages) )
1255 LOG (GNUNET_ERROR_TYPE_DEBUG,
1256 "%s at %u drops ancient or far-future message %u\n",
1258 (unsigned int) mid_min,
1259 ntohl (msg->mid.mid));
1261 GNUNET_STATISTICS_update (stats,
1262 "# duplicate DATA (ancient or future)",
1265 GNUNET_MQ_discard (env);
1266 send_channel_data_ack (ch);
1269 /* mark bit for future ACKs */
1270 delta = mid_msg - mid_min - 1; /* overflow/underflow are OK here */
1273 if (0 != (ch->mid_futures & (1LLU << delta)))
1275 /* Duplicate within the queue, drop also */
1276 LOG (GNUNET_ERROR_TYPE_DEBUG,
1277 "Duplicate payload of %u bytes on %s (mid %u) dropped\n",
1278 (unsigned int) payload_size,
1280 ntohl (msg->mid.mid));
1281 GNUNET_STATISTICS_update (stats,
1285 GNUNET_MQ_discard (env);
1286 send_channel_data_ack (ch);
1289 ch->mid_futures |= (1LLU << delta);
1290 LOG (GNUNET_ERROR_TYPE_DEBUG,
1291 "Marked bit %llX for mid %u (base: %u); now: %llX\n",
1298 else /* ! ch->reliable */
1300 /* Channel is unreliable, so we do not ACK. But we also cannot
1301 allow buffering everything, so check if we have space... */
1302 if (ccc->num_recv >= ch->max_pending_messages)
1304 struct CadetOutOfOrderMessage *drop;
1306 /* Yep, need to drop. Drop the oldest message in
1308 LOG (GNUNET_ERROR_TYPE_DEBUG,
1309 "Queue full due slow client on %s, dropping oldest message\n",
1311 GNUNET_STATISTICS_update (stats,
1312 "# messages dropped due to slow client",
1315 drop = ccc->head_recv;
1316 GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
1320 GNUNET_MQ_discard (drop->env);
1325 /* Insert message into sorted out-of-order queue */
1326 com = GNUNET_new (struct CadetOutOfOrderMessage);
1327 com->mid = msg->mid;
1329 duplicate = GNUNET_NO;
1330 GNUNET_CONTAINER_DLL_insert_sorted (struct CadetOutOfOrderMessage,
1337 if (GNUNET_YES == duplicate)
1339 /* Duplicate within the queue, drop also (this is not covered by
1340 the case above if "delta" >= 64, which could be the case if
1341 max_pending_messages is also >= 64 or if our client is unready
1342 and we are seeing retransmissions of the message our client is
1344 LOG (GNUNET_ERROR_TYPE_DEBUG,
1345 "Duplicate payload of %u bytes on %s (mid %u) dropped\n",
1346 (unsigned int) payload_size,
1348 ntohl (msg->mid.mid));
1349 GNUNET_STATISTICS_update (stats,
1353 GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
1357 GNUNET_MQ_discard (com->env);
1359 send_channel_data_ack (ch);
1362 LOG (GNUNET_ERROR_TYPE_DEBUG,
1363 "Queued %s payload of %u bytes on %s-%X(%p) (mid %u, need %u first)\n",
1364 (GNUNET_YES == ccc->client_ready)
1366 : "client-not-ready",
1367 (unsigned int) payload_size,
1369 ntohl (ccc->ccn.channel_of_client),
1371 ntohl (msg->mid.mid),
1372 ntohl (ch->mid_recv.mid));
1373 /* NOTE: this ACK we _could_ skip, as the packet is out-of-order and
1374 the sender may already be transmitting the previous one. Needs
1375 experimental evaluation to see if/when this ACK helps or
1376 hurts. (We might even want another option.) */
1377 send_channel_data_ack (ch);
1382 * Function called once the tunnel has sent one of our messages.
1383 * If the message is unreliable, simply frees the `crm`. If the
1384 * message was reliable, calculate retransmission time and
1385 * wait for ACK (or retransmit).
1387 * @param cls the `struct CadetReliableMessage` that was sent
1388 * @param cid identifier of the connection within the tunnel, NULL
1389 * if transmission failed
1392 data_sent_cb (void *cls,
1393 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid);
1397 * We need to retry a transmission, the last one took too long to
1400 * @param cls the `struct CadetChannel` where we need to retransmit
1403 retry_transmission (void *cls)
1405 struct CadetChannel *ch = cls;
1406 struct CadetReliableMessage *crm = ch->head_sent;
1408 ch->retry_data_task = NULL;
1409 GNUNET_assert (NULL == crm->qe);
1410 LOG (GNUNET_ERROR_TYPE_DEBUG,
1411 "Retrying transmission on %s of message %u\n",
1413 (unsigned int) ntohl (crm->data_message->mid.mid));
1414 crm->qe = GCT_send (ch->t,
1415 &crm->data_message->header,
1418 GNUNET_assert (NULL == ch->retry_data_task);
1423 * We got an PLAINTEXT_DATA_ACK for a message in our queue, remove it from
1424 * the queue and tell our client that it can send more.
1426 * @param ch the channel that got the PLAINTEXT_DATA_ACK
1427 * @param cti identifier of the connection that delivered the message
1428 * @param crm the message that got acknowledged
1431 handle_matching_ack (struct CadetChannel *ch,
1432 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
1433 struct CadetReliableMessage *crm)
1435 GNUNET_CONTAINER_DLL_remove (ch->head_sent,
1438 ch->pending_messages--;
1439 GNUNET_assert (ch->pending_messages < ch->max_pending_messages);
1440 LOG (GNUNET_ERROR_TYPE_DEBUG,
1441 "Received DATA_ACK on %s for message %u (%u ACKs pending)\n",
1443 (unsigned int) ntohl (crm->data_message->mid.mid),
1444 ch->pending_messages);
1445 if (NULL != crm->qe)
1447 GCT_send_cancel (crm->qe);
1450 if ( (1 == crm->num_transmissions) &&
1453 GCC_ack_observed (cti);
1454 if (0 == memcmp (cti,
1455 &crm->connection_taken,
1456 sizeof (struct GNUNET_CADET_ConnectionTunnelIdentifier)))
1458 GCC_latency_observed (cti,
1459 GNUNET_TIME_absolute_get_duration (crm->first_transmission_time));
1462 GNUNET_free (crm->data_message);
1464 send_ack_to_client (ch,
1472 * We got an acknowledgement for payload data for a channel.
1473 * Possibly resume transmissions.
1475 * @param ch channel that got the ack
1476 * @param cti identifier of the connection that delivered the message
1477 * @param ack details about what was received
1480 GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
1481 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
1482 const struct GNUNET_CADET_ChannelDataAckMessage *ack)
1484 struct CadetReliableMessage *crm;
1485 struct CadetReliableMessage *crmn;
1491 GNUNET_break (GNUNET_NO == ch->is_loopback);
1492 if (GNUNET_NO == ch->reliable)
1494 /* not expecting ACKs on unreliable channel, odd */
1495 GNUNET_break_op (0);
1498 /* mid_base is the MID of the next message that the
1499 other peer expects (i.e. that is missing!), everything
1500 LOWER (but excluding mid_base itself) was received. */
1501 mid_base = ntohl (ack->mid.mid);
1502 mid_mask = GNUNET_htonll (ack->futures);
1504 for (crm = ch->head_sent;
1509 delta = (unsigned int) (ntohl (crm->data_message->mid.mid) - mid_base);
1510 if (delta >= UINT_MAX - ch->max_pending_messages)
1512 /* overflow, means crm was a bit in the past, so this ACK counts for it. */
1513 LOG (GNUNET_ERROR_TYPE_DEBUG,
1514 "Got DATA_ACK with base %u satisfying past message %u on %s\n",
1515 (unsigned int) mid_base,
1516 ntohl (crm->data_message->mid.mid),
1518 handle_matching_ack (ch,
1527 LOG (GNUNET_ERROR_TYPE_DEBUG,
1528 "Testing bit %llX for mid %u (base: %u)\n",
1530 ntohl (crm->data_message->mid.mid),
1532 if (0 != (mid_mask & (1LLU << delta)))
1534 LOG (GNUNET_ERROR_TYPE_DEBUG,
1535 "Got DATA_ACK with mask for %u on %s\n",
1536 ntohl (crm->data_message->mid.mid),
1538 handle_matching_ack (ch,
1544 if (GNUNET_NO == found)
1546 /* ACK for message we already dropped, might have been a
1547 duplicate ACK? Ignore. */
1548 LOG (GNUNET_ERROR_TYPE_DEBUG,
1549 "Duplicate DATA_ACK on %s, ignoring\n",
1551 GNUNET_STATISTICS_update (stats,
1552 "# duplicate DATA_ACKs",
1557 if (NULL != ch->retry_data_task)
1559 GNUNET_SCHEDULER_cancel (ch->retry_data_task);
1560 ch->retry_data_task = NULL;
1562 if ( (NULL != ch->head_sent) &&
1563 (NULL == ch->head_sent->qe) )
1565 = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry,
1566 &retry_transmission,
1572 * Destroy channel, based on the other peer closing the
1573 * connection. Also needs to remove this channel from
1576 * @param ch channel to destroy
1577 * @param cti identifier of the connection that delivered the message,
1578 * NULL if we are simulating receiving a destroy due to shutdown
1581 GCCH_handle_remote_destroy (struct CadetChannel *ch,
1582 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
1584 struct CadetChannelClient *ccc;
1586 GNUNET_assert (GNUNET_NO == ch->is_loopback);
1587 LOG (GNUNET_ERROR_TYPE_DEBUG,
1588 "Received remote channel DESTROY for %s\n",
1590 if (GNUNET_YES == ch->destroy)
1592 /* Local client already gone, this is instant-death. */
1593 channel_destroy (ch);
1596 ccc = (NULL != ch->owner) ? ch->owner : ch->dest;
1597 if (NULL != ccc->head_recv)
1599 LOG (GNUNET_ERROR_TYPE_WARNING,
1600 "Lost end of transmission due to remote shutdown on %s\n",
1602 /* FIXME: change API to notify client about truncated transmission! */
1604 ch->destroy = GNUNET_YES;
1605 GSC_handle_remote_channel_destroy (ccc->c,
1608 channel_destroy (ch);
1613 * Test if element @a e1 comes before element @a e2.
1615 * @param cls closure, to a flag where we indicate duplicate packets
1616 * @param crm1 an element of to sort
1617 * @param crm2 another element to sort
1618 * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO
1621 cmp_crm_by_next_retry (void *cls,
1622 struct CadetReliableMessage *crm1,
1623 struct CadetReliableMessage *crm2)
1625 if (crm1->next_retry.abs_value_us <
1626 crm2->next_retry.abs_value_us)
1633 * Function called once the tunnel has sent one of our messages.
1634 * If the message is unreliable, simply frees the `crm`. If the
1635 * message was reliable, calculate retransmission time and
1636 * wait for ACK (or retransmit).
1638 * @param cls the `struct CadetReliableMessage` that was sent
1639 * @param cid identifier of the connection within the tunnel, NULL
1640 * if transmission failed
1643 data_sent_cb (void *cls,
1644 const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
1646 struct CadetReliableMessage *crm = cls;
1647 struct CadetChannel *ch = crm->ch;
1649 GNUNET_assert (GNUNET_NO == ch->is_loopback);
1650 GNUNET_assert (NULL != crm->qe);
1652 GNUNET_CONTAINER_DLL_remove (ch->head_sent,
1655 if (GNUNET_NO == ch->reliable)
1657 GNUNET_free (crm->data_message);
1659 ch->pending_messages--;
1660 send_ack_to_client (ch,
1668 /* There was an error sending. */
1669 crm->num_transmissions = GNUNET_SYSERR;
1671 else if (GNUNET_SYSERR != crm->num_transmissions)
1673 /* Increment transmission counter, and possibly store @a cid
1674 if this was the first transmission. */
1675 crm->num_transmissions++;
1676 if (1 == crm->num_transmissions)
1678 crm->first_transmission_time = GNUNET_TIME_absolute_get ();
1679 crm->connection_taken = *cid;
1680 GCC_ack_expected (cid);
1683 if ( (0 == crm->retry_delay.rel_value_us) &&
1686 struct CadetConnection *cc = GCC_lookup (cid);
1689 crm->retry_delay = GCC_get_metrics (cc)->aged_latency;
1691 crm->retry_delay = ch->retry_time;
1693 crm->retry_delay = GNUNET_TIME_STD_BACKOFF (crm->retry_delay);
1694 crm->retry_delay = GNUNET_TIME_relative_max (crm->retry_delay,
1696 crm->next_retry = GNUNET_TIME_relative_to_absolute (crm->retry_delay);
1698 GNUNET_CONTAINER_DLL_insert_sorted (struct CadetReliableMessage,
1699 cmp_crm_by_next_retry,
1704 LOG (GNUNET_ERROR_TYPE_DEBUG,
1705 "Message %u sent, next transmission on %s in %s\n",
1706 (unsigned int) ntohl (crm->data_message->mid.mid),
1708 GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (ch->head_sent->next_retry),
1710 if (NULL == ch->head_sent->qe)
1712 if (NULL != ch->retry_data_task)
1713 GNUNET_SCHEDULER_cancel (ch->retry_data_task);
1715 = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry,
1716 &retry_transmission,
1723 * Handle data given by a client.
1725 * Check whether the client is allowed to send in this tunnel, save if
1726 * channel is reliable and send an ACK to the client if there is still
1727 * buffer space in the tunnel.
1729 * @param ch Channel.
1730 * @param sender_ccn ccn of the sender
1731 * @param buf payload to transmit.
1732 * @param buf_len number of bytes in @a buf
1733 * @return #GNUNET_OK if everything goes well,
1734 * #GNUNET_SYSERR in case of an error.
1737 GCCH_handle_local_data (struct CadetChannel *ch,
1738 struct GNUNET_CADET_ClientChannelNumber sender_ccn,
1742 struct CadetReliableMessage *crm;
1744 if (ch->pending_messages > ch->max_pending_messages)
1747 return GNUNET_SYSERR;
1749 if (GNUNET_YES == ch->destroy)
1751 /* we are going down, drop messages */
1754 ch->pending_messages++;
1756 if (GNUNET_YES == ch->is_loopback)
1758 struct CadetChannelClient *receiver;
1759 struct GNUNET_MQ_Envelope *env;
1760 struct GNUNET_CADET_LocalData *ld;
1763 env = GNUNET_MQ_msg_extra (ld,
1765 GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA);
1766 if ( (NULL != ch->owner) &&
1767 (sender_ccn.channel_of_client ==
1768 ch->owner->ccn.channel_of_client) )
1770 receiver = ch->dest;
1771 to_owner = GNUNET_NO;
1773 else if ( (NULL != ch->dest) &&
1774 (sender_ccn.channel_of_client ==
1775 ch->dest->ccn.channel_of_client) )
1777 receiver = ch->owner;
1778 to_owner = GNUNET_YES;
1783 return GNUNET_SYSERR;
1785 ld->ccn = receiver->ccn;
1786 GNUNET_memcpy (&ld[1],
1789 if (GNUNET_YES == receiver->client_ready)
1791 GSC_send_to_client (receiver->c,
1793 send_ack_to_client (ch,
1798 struct CadetOutOfOrderMessage *oom;
1800 oom = GNUNET_new (struct CadetOutOfOrderMessage);
1802 GNUNET_CONTAINER_DLL_insert_tail (receiver->head_recv,
1803 receiver->tail_recv,
1805 receiver->num_recv++;
1810 /* Everything is correct, send the message. */
1811 crm = GNUNET_malloc (sizeof (*crm));
1813 crm->data_message = GNUNET_malloc (sizeof (struct GNUNET_CADET_ChannelAppDataMessage)
1815 crm->data_message->header.size = htons (sizeof (struct GNUNET_CADET_ChannelAppDataMessage) + buf_len);
1816 crm->data_message->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA);
1817 ch->mid_send.mid = htonl (ntohl (ch->mid_send.mid) + 1);
1818 crm->data_message->mid = ch->mid_send;
1819 crm->data_message->ctn = ch->ctn;
1820 GNUNET_memcpy (&crm->data_message[1],
1823 GNUNET_CONTAINER_DLL_insert_tail (ch->head_sent,
1826 LOG (GNUNET_ERROR_TYPE_DEBUG,
1827 "Sending message %u from local client to %s with %u bytes\n",
1828 ntohl (crm->data_message->mid.mid),
1831 if (NULL != ch->retry_data_task)
1833 GNUNET_SCHEDULER_cancel (ch->retry_data_task);
1834 ch->retry_data_task = NULL;
1836 crm->qe = GCT_send (ch->t,
1837 &crm->data_message->header,
1840 GNUNET_assert (NULL == ch->retry_data_task);
1846 * Handle ACK from client on local channel. Means the client is ready
1847 * for more data, see if we have any for it.
1849 * @param ch channel to destroy
1850 * @param client_ccn ccn of the client sending the ack
1853 GCCH_handle_local_ack (struct CadetChannel *ch,
1854 struct GNUNET_CADET_ClientChannelNumber client_ccn)
1856 struct CadetChannelClient *ccc;
1857 struct CadetOutOfOrderMessage *com;
1859 if ( (NULL != ch->owner) &&
1860 (ch->owner->ccn.channel_of_client == client_ccn.channel_of_client) )
1862 else if ( (NULL != ch->dest) &&
1863 (ch->dest->ccn.channel_of_client == client_ccn.channel_of_client) )
1867 ccc->client_ready = GNUNET_YES;
1868 com = ccc->head_recv;
1871 LOG (GNUNET_ERROR_TYPE_DEBUG,
1872 "Got LOCAL_ACK, %s-%X ready to receive more data, but none pending on %s-%X(%p)!\n",
1874 ntohl (client_ccn.channel_of_client),
1876 ntohl (ccc->ccn.channel_of_client),
1878 return; /* none pending */
1880 if (GNUNET_YES == ch->is_loopback)
1884 /* Messages are always in-order, just send */
1885 GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
1889 GSC_send_to_client (ccc->c,
1891 /* Notify sender that we can receive more */
1892 if (ccc->ccn.channel_of_client ==
1893 ch->owner->ccn.channel_of_client)
1895 to_owner = GNUNET_NO;
1899 GNUNET_assert (ccc->ccn.channel_of_client ==
1900 ch->dest->ccn.channel_of_client);
1901 to_owner = GNUNET_YES;
1903 send_ack_to_client (ch,
1909 if ( (com->mid.mid != ch->mid_recv.mid) &&
1910 (GNUNET_NO == ch->out_of_order) &&
1911 (GNUNET_YES == ch->reliable) )
1913 LOG (GNUNET_ERROR_TYPE_DEBUG,
1914 "Got LOCAL_ACK, %s-%X ready to receive more data (but next one is out-of-order %u vs. %u)!\n",
1916 ntohl (ccc->ccn.channel_of_client),
1917 ntohl (com->mid.mid),
1918 ntohl (ch->mid_recv.mid));
1919 return; /* missing next one in-order */
1922 LOG (GNUNET_ERROR_TYPE_DEBUG,
1923 "Got LOCAL_ACK, giving payload message %u to %s-%X on %s\n",
1924 ntohl (com->mid.mid),
1926 ntohl (ccc->ccn.channel_of_client),
1929 /* all good, pass next message to client */
1930 GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
1934 /* FIXME: if unreliable, this is not aggressive
1935 enough, as it would be OK to have lost some! */
1937 ch->mid_recv.mid = htonl (1 + ntohl (com->mid.mid));
1938 ch->mid_futures >>= 1; /* equivalent to division by 2 */
1939 ccc->client_ready = GNUNET_NO;
1940 GSC_send_to_client (ccc->c,
1943 send_channel_data_ack (ch);
1944 if (NULL != ccc->head_recv)
1946 if (GNUNET_NO == ch->destroy)
1948 GCT_send_channel_destroy (ch->t,
1950 channel_destroy (ch);
1954 #define LOG2(level, ...) GNUNET_log_from_nocheck(level,"cadet-chn",__VA_ARGS__)
1960 * @param ch Channel.
1961 * @param level Debug level to use.
1964 GCCH_debug (struct CadetChannel *ch,
1965 enum GNUNET_ErrorType level)
1969 do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
1971 __FILE__, __FUNCTION__, __LINE__);
1977 LOG2 (level, "CHN *** DEBUG NULL CHANNEL ***\n");
1985 if (NULL != ch->owner)
1988 "CHN origin %s ready %s local-id: %u\n",
1989 GSC_2s (ch->owner->c),
1990 ch->owner->client_ready ? "YES" : "NO",
1991 ntohl (ch->owner->ccn.channel_of_client));
1993 if (NULL != ch->dest)
1996 "CHN destination %s ready %s local-id: %u\n",
1997 GSC_2s (ch->dest->c),
1998 ch->dest->client_ready ? "YES" : "NO",
1999 ntohl (ch->dest->ccn.channel_of_client));
2002 "CHN Message IDs recv: %d (%LLX), send: %d\n",
2003 ntohl (ch->mid_recv.mid),
2004 (unsigned long long) ch->mid_futures,
2005 ntohl (ch->mid_send.mid));
2010 /* end of gnunet-service-cadet-new_channel.c */