2 This file is part of GNUnet.
3 Copyright (C) 2001-2013, 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.
22 * @file cadet/gnunet-service-cadet.c
23 * @brief GNUnet CADET service with encryption
24 * @author Bartlomiej Polot
25 * @author Christian Grothoff
28 * - peer: other cadet instance. If there is direct connection it's a neighbor.
29 * - path: series of directly connected peer from one peer to another.
30 * - connection: path which is being used in a tunnel.
31 * - tunnel: encrypted connection to a peer, neighbor or not.
32 * - channel: logical link between two clients, on the same or different peers.
33 * have properties like reliability.
37 #include "gnunet_util_lib.h"
39 #include "gnunet_statistics_service.h"
40 #include "gnunet-service-cadet.h"
41 #include "gnunet-service-cadet_channel.h"
42 #include "gnunet-service-cadet_connection.h"
43 #include "gnunet-service-cadet_core.h"
44 #include "gnunet-service-cadet_dht.h"
45 #include "gnunet-service-cadet_hello.h"
46 #include "gnunet-service-cadet_tunnels.h"
47 #include "gnunet-service-cadet_peer.h"
48 #include "gnunet-service-cadet_paths.h"
50 #define LOG(level, ...) GNUNET_log (level,__VA_ARGS__)
54 * Struct containing information about a client of the service
61 struct CadetClient *next;
66 struct CadetClient *prev;
69 * Tunnels that belong to this client, indexed by local id,
70 * value is a `struct CadetChannel`.
72 struct GNUNET_CONTAINER_MultiHashMap32 *channels;
75 * Handle to communicate with the client
77 struct GNUNET_MQ_Handle *mq;
82 struct GNUNET_SERVICE_Client *client;
85 * Ports that this client has declared interest in.
86 * Indexed by port, contains `struct OpenPort`
88 struct GNUNET_CONTAINER_MultiHashMap *ports;
91 * Channel ID to use for the next incoming channel for this client.
92 * Wraps around (in theory).
94 struct GNUNET_CADET_ClientChannelNumber next_ccn;
97 * ID of the client, mainly for debug messages. Purely internal to this file.
103 /******************************************************************************/
104 /*********************** GLOBAL VARIABLES ****************************/
105 /******************************************************************************/
107 /****************************** Global variables ******************************/
110 * Handle to our configuration.
112 const struct GNUNET_CONFIGURATION_Handle *cfg;
115 * Handle to the statistics service.
117 struct GNUNET_STATISTICS_Handle *stats;
120 * Handle to communicate with ATS.
122 struct GNUNET_ATS_ConnectivityHandle *ats_ch;
127 struct GNUNET_PeerIdentity my_full_id;
132 struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
135 * Signal that shutdown is happening: prevent recovery measures.
140 * DLL with all the clients, head.
142 static struct CadetClient *clients_head;
145 * DLL with all the clients, tail.
147 static struct CadetClient *clients_tail;
150 * Next ID to assign to a client.
152 static unsigned int next_client_id;
155 * All ports clients of this peer have opened. Maps from
156 * a hashed port to a `struct OpenPort`.
158 struct GNUNET_CONTAINER_MultiHashMap *open_ports;
161 * Map from ports to channels where the ports were closed at the
162 * time we got the inbound connection.
163 * Indexed by h_port, contains `struct CadetChannel`.
165 struct GNUNET_CONTAINER_MultiHashMap *loose_channels;
168 * Map from PIDs to `struct CadetPeer` entries.
170 struct GNUNET_CONTAINER_MultiPeerMap *peers;
173 * Map from `struct GNUNET_CADET_ConnectionTunnelIdentifier`
174 * hash codes to `struct CadetConnection` objects.
176 struct GNUNET_CONTAINER_MultiShortmap *connections;
179 * How many messages are needed to trigger an AXOLOTL ratchet advance.
181 unsigned long long ratchet_messages;
184 * How long until we trigger a ratched advance due to time.
186 struct GNUNET_TIME_Relative ratchet_time;
189 * How frequently do we send KEEPALIVE messages on idle connections?
191 struct GNUNET_TIME_Relative keepalive_period;
194 * Set to non-zero values to create random drops to test retransmissions.
196 unsigned long long drop_percent;
200 * Send a message to a client.
202 * @param c client to get the message
203 * @param env envelope with the message
206 GSC_send_to_client (struct CadetClient *c,
207 struct GNUNET_MQ_Envelope *env)
209 GNUNET_MQ_send (c->mq,
215 * Return identifier for a client as a string.
217 * @param c client to identify
218 * @return string for debugging
221 GSC_2s (struct CadetClient *c)
225 GNUNET_snprintf (buf,
234 * Lookup channel of client @a c by @a ccn.
236 * @param c client to look in
237 * @param ccn channel ID to look up
238 * @return NULL if no such channel exists
240 static struct CadetChannel *
241 lookup_channel (struct CadetClient *c,
242 struct GNUNET_CADET_ClientChannelNumber ccn)
244 return GNUNET_CONTAINER_multihashmap32_get (c->channels,
245 ntohl (ccn.channel_of_client));
250 * Obtain the next LID to use for incoming connections to
253 * @param c client handle
255 static struct GNUNET_CADET_ClientChannelNumber
256 client_get_next_ccn (struct CadetClient *c)
258 struct GNUNET_CADET_ClientChannelNumber ccn = c->next_ccn;
260 /* increment until we have a free one... */
265 ccn.channel_of_client
266 = htonl (1 + (ntohl (ccn.channel_of_client)));
267 if (ntohl (ccn.channel_of_client) >=
268 GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
269 ccn.channel_of_client = htonl (0);
271 c->next_ccn.channel_of_client
272 = htonl (1 + (ntohl (ccn.channel_of_client)));
278 * Bind incoming channel to this client, and notify client about
279 * incoming connection. Caller is responsible for notifying the other
280 * peer about our acceptance of the channel.
282 * @param c client to bind to
283 * @param ch channel to be bound
284 * @param dest peer that establishes the connection
285 * @param port port number
286 * @param options options
287 * @return local channel number assigned to the new client
289 struct GNUNET_CADET_ClientChannelNumber
290 GSC_bind (struct CadetClient *c,
291 struct CadetChannel *ch,
292 struct CadetPeer *dest,
293 const struct GNUNET_HashCode *port,
296 struct GNUNET_MQ_Envelope *env;
297 struct GNUNET_CADET_LocalChannelCreateMessage *cm;
298 struct GNUNET_CADET_ClientChannelNumber ccn;
300 ccn = client_get_next_ccn (c);
301 GNUNET_assert (GNUNET_YES ==
302 GNUNET_CONTAINER_multihashmap32_put (c->channels,
303 ntohl (ccn.channel_of_client),
305 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
306 LOG (GNUNET_ERROR_TYPE_DEBUG,
307 "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n",
311 (uint32_t) ntohl (options),
312 (uint32_t) ntohl (ccn.channel_of_client));
313 /* notify local client about incoming connection! */
314 env = GNUNET_MQ_msg (cm,
315 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
318 cm->opt = htonl (options);
319 cm->peer = *GCP_get_id (dest);
320 GSC_send_to_client (c,
327 * Callback invoked on all peers to destroy all tunnels
328 * that may still exist.
331 * @param pid identify of a peer
332 * @param value a `struct CadetPeer` that may still have a tunnel
333 * @return #GNUNET_OK (iterate over all entries)
336 destroy_tunnels_now (void *cls,
337 const struct GNUNET_PeerIdentity *pid,
340 struct CadetPeer *cp = value;
341 struct CadetTunnel *t = GCP_get_tunnel (cp,
345 GCT_destroy_tunnel_now (t);
351 * Callback invoked on all peers to destroy all tunnels
352 * that may still exist.
355 * @param pid identify of a peer
356 * @param value a `struct CadetPeer` that may still have a tunnel
357 * @return #GNUNET_OK (iterate over all entries)
360 destroy_paths_now (void *cls,
361 const struct GNUNET_PeerIdentity *pid,
364 struct CadetPeer *cp = value;
366 GCP_drop_owned_paths (cp);
372 * Shutdown everything once the clients have disconnected.
379 GNUNET_STATISTICS_destroy (stats,
383 if (NULL != open_ports)
385 GNUNET_CONTAINER_multihashmap_destroy (open_ports);
388 if (NULL != loose_channels)
390 GNUNET_CONTAINER_multihashmap_destroy (loose_channels);
391 loose_channels = NULL;
393 /* Destroy tunnels. Note that all channels must be destroyed first! */
394 GCP_iterate_all (&destroy_tunnels_now,
396 /* All tunnels, channels, connections and CORE must be down before this point. */
397 GCP_iterate_all (&destroy_paths_now,
399 /* All paths, tunnels, channels, connections and CORE must be down before this point. */
400 GCP_destroy_all_peers ();
403 GNUNET_CONTAINER_multipeermap_destroy (peers);
406 if (NULL != connections)
408 GNUNET_CONTAINER_multishortmap_destroy (connections);
413 GNUNET_ATS_connectivity_done (ats_ch);
418 GNUNET_free_non_null (my_private_key);
419 my_private_key = NULL;
424 * Task run during shutdown.
429 shutdown_task (void *cls)
431 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
433 shutting_down = GNUNET_YES;
435 if (NULL == clients_head)
441 * We had a remote connection @a value to port @a h_port before
442 * client @a cls opened port @a port. Bind them now.
444 * @param cls the `struct CadetClient`
445 * @param h_port the hashed port
446 * @param value the `struct CadetChannel`
447 * @return #GNUNET_YES (iterate over all such channels)
450 bind_loose_channel (void *cls,
451 const struct GNUNET_HashCode *port,
454 struct OpenPort *op = cls;
455 struct CadetChannel *ch = value;
460 GNUNET_assert (GNUNET_YES ==
461 GNUNET_CONTAINER_multihashmap_remove (loose_channels,
469 * Handle port open request. Creates a mapping from the
470 * port to the respective client and checks whether we have
471 * loose channels trying to bind to the port. If so, those
474 * @param cls Identification of the client.
475 * @param pmsg The actual message.
478 handle_port_open (void *cls,
479 const struct GNUNET_CADET_PortMessage *pmsg)
481 struct CadetClient *c = cls;
484 LOG (GNUNET_ERROR_TYPE_DEBUG,
485 "Open port %s requested by %s\n",
486 GNUNET_h2s (&pmsg->port),
488 if (NULL == c->ports)
489 c->ports = GNUNET_CONTAINER_multihashmap_create (4,
491 op = GNUNET_new (struct OpenPort);
493 op->port = pmsg->port;
494 GCCH_hash_port (&op->h_port,
498 GNUNET_CONTAINER_multihashmap_put (c->ports,
501 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
504 GNUNET_SERVICE_client_drop (c->client);
507 (void) GNUNET_CONTAINER_multihashmap_put (open_ports,
510 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
511 GNUNET_CONTAINER_multihashmap_get_multiple (loose_channels,
515 GNUNET_SERVICE_client_continue (c->client);
520 * Handler for port close requests. Marks this port as closed
521 * (unless of course we have another client with the same port
522 * open). Note that existing channels accepted on the port are
525 * @param cls Identification of the client.
526 * @param pmsg The actual message.
529 handle_port_close (void *cls,
530 const struct GNUNET_CADET_PortMessage *pmsg)
532 struct CadetClient *c = cls;
535 LOG (GNUNET_ERROR_TYPE_DEBUG,
536 "Closing port %s as requested by %s\n",
537 GNUNET_h2s (&pmsg->port),
539 op = GNUNET_CONTAINER_multihashmap_get (c->ports,
544 GNUNET_SERVICE_client_drop (c->client);
547 GNUNET_assert (GNUNET_YES ==
548 GNUNET_CONTAINER_multihashmap_remove (c->ports,
551 GNUNET_assert (GNUNET_YES ==
552 GNUNET_CONTAINER_multihashmap_remove (open_ports,
556 GNUNET_SERVICE_client_continue (c->client);
561 * Handler for requests for us creating a new channel to another peer and port.
563 * @param cls Identification of the client.
564 * @param tcm The actual message.
567 handle_channel_create (void *cls,
568 const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
570 struct CadetClient *c = cls;
571 struct CadetChannel *ch;
573 if (ntohl (tcm->ccn.channel_of_client) < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
575 /* Channel ID not in allowed range. */
577 GNUNET_SERVICE_client_drop (c->client);
580 ch = lookup_channel (c,
584 /* Channel ID already in use. Not allowed. */
586 GNUNET_SERVICE_client_drop (c->client);
589 LOG (GNUNET_ERROR_TYPE_DEBUG,
590 "New channel to %s at port %s requested by %s\n",
591 GNUNET_i2s (&tcm->peer),
592 GNUNET_h2s (&tcm->port),
596 ch = GCCH_channel_local_new (c,
605 GNUNET_SERVICE_client_drop (c->client);
608 GNUNET_assert (GNUNET_YES ==
609 GNUNET_CONTAINER_multihashmap32_put (c->channels,
610 ntohl (tcm->ccn.channel_of_client),
612 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
614 GNUNET_SERVICE_client_continue (c->client);
619 * Handler for requests of destroying an existing channel.
621 * @param cls client identification of the client
622 * @param msg the actual message
625 handle_channel_destroy (void *cls,
626 const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
628 struct CadetClient *c = cls;
629 struct CadetChannel *ch;
631 ch = lookup_channel (c,
635 /* Client attempted to destroy unknown channel.
636 Can happen if the other side went down at the same time.*/
637 LOG (GNUNET_ERROR_TYPE_DEBUG,
638 "%s tried to destroy unknown channel %X\n",
640 (uint32_t) ntohl (msg->ccn.channel_of_client));
641 GNUNET_SERVICE_client_continue (c->client);
644 LOG (GNUNET_ERROR_TYPE_DEBUG,
645 "%s is destroying %s\n",
648 GNUNET_assert (GNUNET_YES ==
649 GNUNET_CONTAINER_multihashmap32_remove (c->channels,
650 ntohl (msg->ccn.channel_of_client),
652 GCCH_channel_local_destroy (ch,
655 GNUNET_SERVICE_client_continue (c->client);
660 * Check for client traffic data message is well-formed.
662 * @param cls identification of the client
663 * @param msg the actual message
664 * @return #GNUNET_OK if @a msg is OK, #GNUNET_SYSERR if not
667 check_local_data (void *cls,
668 const struct GNUNET_CADET_LocalData *msg)
671 size_t payload_claimed_size;
673 struct GNUNET_MessageHeader pa;
675 /* FIXME: what is the format we shall allow for @a msg?
676 ONE payload item or multiple? Seems current cadet_api
677 at least in theory allows more than one. Next-gen
678 cadet_api will likely no more, so we could then
679 simplify this mess again. */
680 /* Sanity check for message size */
681 payload_size = ntohs (msg->header.size) - sizeof (*msg);
682 buf = (const char *) &msg[1];
683 while (payload_size >= sizeof (struct GNUNET_MessageHeader))
685 /* need to memcpy() for alignment */
689 payload_claimed_size = ntohs (pa.size);
690 if ( (payload_size < payload_claimed_size) ||
691 (payload_claimed_size < sizeof (struct GNUNET_MessageHeader)) ||
692 (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size) )
695 LOG (GNUNET_ERROR_TYPE_DEBUG,
696 "Local data of %u total size had sub-message %u at %u with %u bytes\n",
697 ntohs (msg->header.size),
699 (unsigned int) (buf - (const char *) &msg[1]),
700 (unsigned int) payload_claimed_size);
701 return GNUNET_SYSERR;
703 payload_size -= payload_claimed_size;
704 buf += payload_claimed_size;
706 if (0 != payload_size)
709 return GNUNET_SYSERR;
716 * Handler for client payload traffic to be send on a channel to
719 * @param cls identification of the client
720 * @param msg the actual message
723 handle_local_data (void *cls,
724 const struct GNUNET_CADET_LocalData *msg)
726 struct CadetClient *c = cls;
727 struct CadetChannel *ch;
731 ch = lookup_channel (c,
735 /* Channel does not exist (anymore) */
736 LOG (GNUNET_ERROR_TYPE_WARNING,
737 "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
738 (unsigned int) ntohl (msg->ccn.channel_of_client));
739 GNUNET_SERVICE_client_continue (c->client);
742 payload_size = ntohs (msg->header.size) - sizeof (*msg);
743 GNUNET_STATISTICS_update (stats,
744 "# payload received from clients",
747 buf = (const char *) &msg[1];
748 LOG (GNUNET_ERROR_TYPE_DEBUG,
749 "Received %u bytes payload from %s for %s\n",
750 (unsigned int) payload_size,
754 GCCH_handle_local_data (ch,
759 GNUNET_SERVICE_client_drop (c->client);
762 GNUNET_SERVICE_client_continue (c->client);
767 * Handler for client's ACKs for payload traffic.
769 * @param cls identification of the client.
770 * @param msg The actual message.
773 handle_local_ack (void *cls,
774 const struct GNUNET_CADET_LocalAck *msg)
776 struct CadetClient *c = cls;
777 struct CadetChannel *ch;
779 ch = lookup_channel (c,
783 /* Channel does not exist (anymore) */
784 LOG (GNUNET_ERROR_TYPE_WARNING,
785 "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
786 (unsigned int) ntohl (msg->ccn.channel_of_client));
787 GNUNET_SERVICE_client_continue (c->client);
790 LOG (GNUNET_ERROR_TYPE_DEBUG,
791 "Got a local ACK from %s for %s\n",
794 GCCH_handle_local_ack (ch,
796 GNUNET_SERVICE_client_continue (c->client);
801 * Iterator over all peers to send a monitoring client info about each peer.
803 * @param cls Closure ().
804 * @param peer Peer ID (tunnel remote peer).
805 * @param value Peer info.
806 * @return #GNUNET_YES, to keep iterating.
809 get_all_peers_iterator (void *cls,
810 const struct GNUNET_PeerIdentity *peer,
813 struct CadetClient *c = cls;
814 struct CadetPeer *p = value;
815 struct GNUNET_MQ_Envelope *env;
816 struct GNUNET_CADET_LocalInfoPeer *msg;
818 env = GNUNET_MQ_msg (msg,
819 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
820 msg->destination = *peer;
821 msg->paths = htons (GCP_count_paths (p));
822 msg->tunnel = htons (NULL != GCP_get_tunnel (p,
824 GNUNET_MQ_send (c->mq,
831 * Handler for client's INFO PEERS request.
833 * @param cls Identification of the client.
834 * @param message The actual message.
837 handle_get_peers (void *cls,
838 const struct GNUNET_MessageHeader *message)
840 struct CadetClient *c = cls;
841 struct GNUNET_MQ_Envelope *env;
842 struct GNUNET_MessageHeader *reply;
844 GCP_iterate_all (&get_all_peers_iterator,
846 env = GNUNET_MQ_msg (reply,
847 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
848 GNUNET_MQ_send (c->mq,
850 GNUNET_SERVICE_client_continue (c->client);
855 * Iterator over all paths of a peer to build an InfoPeer message.
856 * Message contains blocks of peers, first not included.
858 * @param cls message queue for transmission
859 * @param path Path itself
860 * @param off offset of the peer on @a path
861 * @return #GNUNET_YES if should keep iterating.
862 * #GNUNET_NO otherwise.
865 path_info_iterator (void *cls,
866 struct CadetPeerPath *path,
869 struct GNUNET_MQ_Handle *mq = cls;
870 struct GNUNET_MQ_Envelope *env;
871 struct GNUNET_MessageHeader *resp;
872 struct GNUNET_PeerIdentity *id;
875 unsigned int path_length;
877 path_length = GCPP_get_length (path);
878 path_size = sizeof (struct GNUNET_PeerIdentity) * (path_length - 1);
879 if (sizeof (*resp) + path_size > UINT16_MAX)
881 LOG (GNUNET_ERROR_TYPE_WARNING,
882 "Path of %u entries is too long for info message\n",
886 env = GNUNET_MQ_msg_extra (resp,
888 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER);
889 id = (struct GNUNET_PeerIdentity *) &resp[1];
891 /* Don't copy first peer. First peer is always the local one. Last
892 * peer is always the destination (leave as 0, EOL).
894 for (i = 0; i < off; i++)
895 id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
904 * Handler for client's SHOW_PEER request.
906 * @param cls Identification of the client.
907 * @param msg The actual message.
910 handle_show_peer (void *cls,
911 const struct GNUNET_CADET_LocalInfo *msg)
913 struct CadetClient *c = cls;
915 struct GNUNET_MQ_Envelope *env;
916 struct GNUNET_MessageHeader *resp;
918 p = GCP_get (&msg->peer,
921 GCP_iterate_paths (p,
924 /* Send message with 0/0 to indicate the end */
925 env = GNUNET_MQ_msg (resp,
926 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER_END);
927 GNUNET_MQ_send (c->mq,
929 GNUNET_SERVICE_client_continue (c->client);
934 * Iterator over all tunnels to send a monitoring client info about each tunnel.
936 * @param cls Closure ().
937 * @param peer Peer ID (tunnel remote peer).
938 * @param value a `struct CadetPeer`
939 * @return #GNUNET_YES, to keep iterating.
942 get_all_tunnels_iterator (void *cls,
943 const struct GNUNET_PeerIdentity *peer,
946 struct CadetClient *c = cls;
947 struct CadetPeer *p = value;
948 struct GNUNET_MQ_Envelope *env;
949 struct GNUNET_CADET_LocalInfoTunnel *msg;
950 struct CadetTunnel *t;
952 t = GCP_get_tunnel (p,
956 env = GNUNET_MQ_msg (msg,
957 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
958 msg->destination = *peer;
959 msg->channels = htonl (GCT_count_channels (t));
960 msg->connections = htonl (GCT_count_any_connections (t));
961 msg->cstate = htons (0);
962 msg->estate = htons ((uint16_t) GCT_get_estate (t));
963 GNUNET_MQ_send (c->mq,
970 * Handler for client's #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS request.
972 * @param cls client Identification of the client.
973 * @param message The actual message.
976 handle_info_tunnels (void *cls,
977 const struct GNUNET_MessageHeader *message)
979 struct CadetClient *c = cls;
980 struct GNUNET_MQ_Envelope *env;
981 struct GNUNET_MessageHeader *reply;
983 GCP_iterate_all (&get_all_tunnels_iterator,
985 env = GNUNET_MQ_msg (reply,
986 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
987 GNUNET_MQ_send (c->mq,
989 GNUNET_SERVICE_client_continue (c->client);
994 * Update the message with information about the connection.
996 * @param cls a `struct GNUNET_CADET_LocalInfoTunnel` message to update
997 * @param ct a connection about which we should store information in @a cls
1000 iter_connection (void *cls,
1001 struct CadetTConnection *ct)
1003 struct GNUNET_CADET_LocalInfoTunnel *msg = cls;
1004 struct CadetConnection *cc = ct->cc;
1005 struct GNUNET_CADET_ConnectionTunnelIdentifier *h;
1007 h = (struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
1008 h[msg->connections++] = *(GCC_get_id (cc));
1013 * Update the message with information about the channel.
1015 * @param cls a `struct GNUNET_CADET_LocalInfoTunnel` message to update
1016 * @param ch a channel about which we should store information in @a cls
1019 iter_channel (void *cls,
1020 struct CadetChannel *ch)
1022 struct GNUNET_CADET_LocalInfoTunnel *msg = cls;
1023 struct GNUNET_CADET_ConnectionTunnelIdentifier *h = (struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
1024 struct GNUNET_CADET_ChannelTunnelNumber *chn
1025 = (struct GNUNET_CADET_ChannelTunnelNumber *) &h[msg->connections];
1027 chn[msg->channels++] = GCCH_get_id (ch);
1032 * Handler for client's #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL request.
1034 * @param cls Identification of the client.
1035 * @param msg The actual message.
1038 handle_info_tunnel (void *cls,
1039 const struct GNUNET_CADET_LocalInfo *msg)
1041 struct CadetClient *c = cls;
1042 struct GNUNET_MQ_Envelope *env;
1043 struct GNUNET_CADET_LocalInfoTunnel *resp;
1044 struct CadetTunnel *t;
1045 struct CadetPeer *p;
1049 p = GCP_get (&msg->peer,
1051 t = GCP_get_tunnel (p,
1055 /* We don't know the tunnel */
1056 struct GNUNET_MQ_Envelope *env;
1057 struct GNUNET_CADET_LocalInfoTunnel *warn;
1059 LOG (GNUNET_ERROR_TYPE_INFO,
1060 "Tunnel to %s unknown\n",
1061 GNUNET_i2s_full (&msg->peer));
1062 env = GNUNET_MQ_msg (warn,
1063 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1064 warn->destination = msg->peer;
1065 GNUNET_MQ_send (c->mq,
1067 GNUNET_SERVICE_client_continue (c->client);
1071 /* Initialize context */
1072 ch_n = GCT_count_channels (t);
1073 c_n = GCT_count_any_connections (t);
1074 env = GNUNET_MQ_msg_extra (resp,
1075 c_n * sizeof (struct GNUNET_CADET_ConnectionTunnelIdentifier) +
1076 ch_n * sizeof (struct GNUNET_CADET_ChannelTunnelNumber),
1077 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1078 resp->destination = msg->peer;
1079 /* Do not reorder! #iter_channel needs counters in HBO! */
1080 GCT_iterate_connections (t,
1083 GCT_iterate_channels (t,
1086 resp->connections = htonl (resp->connections);
1087 resp->channels = htonl (resp->channels);
1088 resp->cstate = htons (0);
1089 resp->estate = htons (GCT_get_estate (t));
1090 GNUNET_MQ_send (c->mq,
1092 GNUNET_SERVICE_client_continue (c->client);
1097 * Iterator over all peers to dump info for each peer.
1099 * @param cls Closure (unused).
1100 * @param peer Peer ID (tunnel remote peer).
1101 * @param value Peer info.
1103 * @return #GNUNET_YES, to keep iterating.
1106 show_peer_iterator (void *cls,
1107 const struct GNUNET_PeerIdentity *peer,
1110 struct CadetPeer *p = value;
1111 struct CadetTunnel *t;
1113 t = GCP_get_tunnel (p,
1117 GNUNET_ERROR_TYPE_ERROR);
1118 LOG (GNUNET_ERROR_TYPE_ERROR, "\n");
1124 * Handler for client's INFO_DUMP request.
1126 * @param cls Identification of the client.
1127 * @param message The actual message.
1130 handle_info_dump (void *cls,
1131 const struct GNUNET_MessageHeader *message)
1133 struct CadetClient *c = cls;
1135 LOG (GNUNET_ERROR_TYPE_INFO,
1136 "Received dump info request from client %u\n",
1139 LOG (GNUNET_ERROR_TYPE_ERROR,
1140 "*************************** DUMP START ***************************\n");
1141 for (struct CadetClient *ci = clients_head;
1145 LOG (GNUNET_ERROR_TYPE_ERROR,
1146 "Client %u (%p), handle: %p, ports: %u, channels: %u\n",
1151 ? GNUNET_CONTAINER_multihashmap_size (ci->ports)
1153 GNUNET_CONTAINER_multihashmap32_size (ci->channels));
1155 LOG (GNUNET_ERROR_TYPE_ERROR, "***************************\n");
1156 GCP_iterate_all (&show_peer_iterator,
1159 LOG (GNUNET_ERROR_TYPE_ERROR,
1160 "**************************** DUMP END ****************************\n");
1162 GNUNET_SERVICE_client_continue (c->client);
1168 * Callback called when a client connects to the service.
1170 * @param cls closure for the service
1171 * @param client the new client that connected to the service
1172 * @param mq the message queue used to send messages to the client
1176 client_connect_cb (void *cls,
1177 struct GNUNET_SERVICE_Client *client,
1178 struct GNUNET_MQ_Handle *mq)
1180 struct CadetClient *c;
1182 c = GNUNET_new (struct CadetClient);
1185 c->id = next_client_id++; /* overflow not important: just for debug */
1187 = GNUNET_CONTAINER_multihashmap32_create (32);
1188 GNUNET_CONTAINER_DLL_insert (clients_head,
1191 GNUNET_STATISTICS_update (stats,
1195 LOG (GNUNET_ERROR_TYPE_DEBUG,
1203 * A channel was destroyed by the other peer. Tell our client.
1205 * @param c client that lost a channel
1206 * @param ccn channel identification number for the client
1207 * @param ch the channel object
1210 GSC_handle_remote_channel_destroy (struct CadetClient *c,
1211 struct GNUNET_CADET_ClientChannelNumber ccn,
1212 struct CadetChannel *ch)
1214 struct GNUNET_MQ_Envelope *env;
1215 struct GNUNET_CADET_LocalChannelDestroyMessage *tdm;
1217 env = GNUNET_MQ_msg (tdm,
1218 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
1220 GSC_send_to_client (c,
1222 GNUNET_assert (GNUNET_YES ==
1223 GNUNET_CONTAINER_multihashmap32_remove (c->channels,
1224 ntohl (ccn.channel_of_client),
1230 * A client that created a loose channel that was not bound to a port
1231 * disconnected, drop it from the #loose_channels list.
1233 * @param h_port the hashed port the channel was trying to bind to
1234 * @param ch the channel that was lost
1237 GSC_drop_loose_channel (const struct GNUNET_HashCode *h_port,
1238 struct CadetChannel *ch)
1240 GNUNET_assert (GNUNET_YES ==
1241 GNUNET_CONTAINER_multihashmap_remove (loose_channels,
1248 * Iterator for deleting each channel whose client endpoint disconnected.
1250 * @param cls Closure (client that has disconnected).
1251 * @param key The local channel id in host byte order
1252 * @param value The value stored at the key (channel to destroy).
1253 * @return #GNUNET_OK, keep iterating.
1256 channel_destroy_iterator (void *cls,
1260 struct CadetClient *c = cls;
1261 struct GNUNET_CADET_ClientChannelNumber ccn;
1262 struct CadetChannel *ch = value;
1264 LOG (GNUNET_ERROR_TYPE_DEBUG,
1265 "Destroying %s, due to %s disconnecting.\n",
1268 ccn.channel_of_client = htonl (key);
1269 GCCH_channel_local_destroy (ch,
1272 GNUNET_assert (GNUNET_YES ==
1273 GNUNET_CONTAINER_multihashmap32_remove (c->channels,
1281 * Remove client's ports from the global hashmap on disconnect.
1283 * @param cls the `struct CadetClient`
1284 * @param port the port.
1285 * @param value the `struct OpenPort` to remove
1286 * @return #GNUNET_OK, keep iterating.
1289 client_release_ports (void *cls,
1290 const struct GNUNET_HashCode *port,
1293 struct CadetClient *c = cls;
1294 struct OpenPort *op = value;
1296 GNUNET_assert (c == op->c);
1297 LOG (GNUNET_ERROR_TYPE_DEBUG,
1298 "Closing port %s due to %s disconnect.\n",
1301 GNUNET_assert (GNUNET_YES ==
1302 GNUNET_CONTAINER_multihashmap_remove (open_ports,
1305 GNUNET_assert (GNUNET_YES ==
1306 GNUNET_CONTAINER_multihashmap_remove (c->ports,
1315 * Callback called when a client disconnected from the service
1317 * @param cls closure for the service
1318 * @param client the client that disconnected
1319 * @param internal_cls should be equal to @a c
1322 client_disconnect_cb (void *cls,
1323 struct GNUNET_SERVICE_Client *client,
1326 struct CadetClient *c = internal_cls;
1328 GNUNET_assert (c->client == client);
1329 LOG (GNUNET_ERROR_TYPE_DEBUG,
1330 "%s is disconnecting.\n",
1332 if (NULL != c->channels)
1334 GNUNET_CONTAINER_multihashmap32_iterate (c->channels,
1335 &channel_destroy_iterator,
1337 GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (c->channels));
1338 GNUNET_CONTAINER_multihashmap32_destroy (c->channels);
1340 if (NULL != c->ports)
1342 GNUNET_CONTAINER_multihashmap_iterate (c->ports,
1343 &client_release_ports,
1345 GNUNET_CONTAINER_multihashmap_destroy (c->ports);
1347 GNUNET_CONTAINER_DLL_remove (clients_head,
1350 GNUNET_STATISTICS_update (stats,
1355 if ( (NULL == clients_head) &&
1356 (GNUNET_YES == shutting_down) )
1362 * Setup CADET internals.
1364 * @param cls closure
1365 * @param server the initialized server
1366 * @param c configuration to use
1370 const struct GNUNET_CONFIGURATION_Handle *c,
1371 struct GNUNET_SERVICE_Handle *service)
1375 GNUNET_CONFIGURATION_get_value_number (c,
1380 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1383 "needs to be a number");
1384 ratchet_messages = 64;
1387 GNUNET_CONFIGURATION_get_value_time (c,
1392 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1395 "need delay value");
1396 ratchet_time = GNUNET_TIME_UNIT_HOURS;
1399 GNUNET_CONFIGURATION_get_value_time (c,
1401 "REFRESH_CONNECTION_TIME",
1404 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1406 "REFRESH_CONNECTION_TIME",
1407 "need delay value");
1408 keepalive_period = GNUNET_TIME_UNIT_MINUTES;
1411 GNUNET_CONFIGURATION_get_value_number (c,
1420 LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1421 LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1422 LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1423 LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1424 LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1426 my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
1427 if (NULL == my_private_key)
1430 GNUNET_SCHEDULER_shutdown ();
1433 GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
1434 &my_full_id.public_key);
1435 stats = GNUNET_STATISTICS_create ("cadet",
1437 GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
1439 ats_ch = GNUNET_ATS_connectivity_init (c);
1440 /* FIXME: optimize code to allow GNUNET_YES here! */
1441 open_ports = GNUNET_CONTAINER_multihashmap_create (16,
1443 loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
1445 peers = GNUNET_CONTAINER_multipeermap_create (16,
1447 connections = GNUNET_CONTAINER_multishortmap_create (256,
1452 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1453 "CADET started for peer %s\n",
1454 GNUNET_i2s (&my_full_id));
1460 * Define "main" method using service macro.
1464 GNUNET_SERVICE_OPTION_NONE,
1467 &client_disconnect_cb,
1469 GNUNET_MQ_hd_fixed_size (port_open,
1470 GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN,
1471 struct GNUNET_CADET_PortMessage,
1473 GNUNET_MQ_hd_fixed_size (port_close,
1474 GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE,
1475 struct GNUNET_CADET_PortMessage,
1477 GNUNET_MQ_hd_fixed_size (channel_create,
1478 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
1479 struct GNUNET_CADET_LocalChannelCreateMessage,
1481 GNUNET_MQ_hd_fixed_size (channel_destroy,
1482 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
1483 struct GNUNET_CADET_LocalChannelDestroyMessage,
1485 GNUNET_MQ_hd_var_size (local_data,
1486 GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
1487 struct GNUNET_CADET_LocalData,
1489 GNUNET_MQ_hd_fixed_size (local_ack,
1490 GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
1491 struct GNUNET_CADET_LocalAck,
1493 GNUNET_MQ_hd_fixed_size (get_peers,
1494 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS,
1495 struct GNUNET_MessageHeader,
1497 GNUNET_MQ_hd_fixed_size (show_peer,
1498 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER,
1499 struct GNUNET_CADET_LocalInfo,
1501 GNUNET_MQ_hd_fixed_size (info_tunnels,
1502 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS,
1503 struct GNUNET_MessageHeader,
1505 GNUNET_MQ_hd_fixed_size (info_tunnel,
1506 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL,
1507 struct GNUNET_CADET_LocalInfo,
1509 GNUNET_MQ_hd_fixed_size (info_dump,
1510 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_DUMP,
1511 struct GNUNET_MessageHeader,
1513 GNUNET_MQ_handler_end ());
1515 /* end of gnunet-service-cadet-new.c */