aboutsummaryrefslogtreecommitdiff
path: root/src/cadet/gnunet-service-cadet-new.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/cadet/gnunet-service-cadet-new.c')
-rw-r--r--src/cadet/gnunet-service-cadet-new.c1428
1 files changed, 0 insertions, 1428 deletions
diff --git a/src/cadet/gnunet-service-cadet-new.c b/src/cadet/gnunet-service-cadet-new.c
deleted file mode 100644
index 97489f3fd..000000000
--- a/src/cadet/gnunet-service-cadet-new.c
+++ /dev/null
@@ -1,1428 +0,0 @@
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2001-2013, 2017 GNUnet e.V.
4
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.
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 General Public License for more details.
14
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.
19*/
20
21/**
22 * @file cadet/gnunet-service-cadet-new.c
23 * @brief GNUnet CADET service with encryption
24 * @author Bartlomiej Polot
25 * @author Christian Grothoff
26 *
27 * Dictionary:
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.
34 */
35
36#include "platform.h"
37#include "gnunet_util_lib.h"
38#include "cadet.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_core.h"
44#include "gnunet-service-cadet-new_dht.h"
45#include "gnunet-service-cadet-new_hello.h"
46#include "gnunet-service-cadet-new_tunnels.h"
47#include "gnunet-service-cadet-new_peer.h"
48#include "gnunet-service-cadet-new_paths.h"
49
50#define LOG(level, ...) GNUNET_log (level,__VA_ARGS__)
51
52
53/**
54 * Struct containing information about a client of the service
55 */
56struct CadetClient
57{
58 /**
59 * Linked list next
60 */
61 struct CadetClient *next;
62
63 /**
64 * Linked list prev
65 */
66 struct CadetClient *prev;
67
68 /**
69 * Tunnels that belong to this client, indexed by local id,
70 * value is a `struct CadetChannel`.
71 */
72 struct GNUNET_CONTAINER_MultiHashMap32 *channels;
73
74 /**
75 * Handle to communicate with the client
76 */
77 struct GNUNET_MQ_Handle *mq;
78
79 /**
80 * Client handle.
81 */
82 struct GNUNET_SERVICE_Client *client;
83
84 /**
85 * Ports that this client has declared interest in.
86 * Indexed by port, contains *Client.
87 */
88 struct GNUNET_CONTAINER_MultiHashMap *ports;
89
90 /**
91 * Channel ID to use for the next incoming channel for this client.
92 * Wraps around (in theory).
93 */
94 struct GNUNET_CADET_ClientChannelNumber next_ccn;
95
96 /**
97 * ID of the client, mainly for debug messages. Purely internal to this file.
98 */
99 unsigned int id;
100};
101
102/******************************************************************************/
103/*********************** GLOBAL VARIABLES ****************************/
104/******************************************************************************/
105
106/****************************** Global variables ******************************/
107
108/**
109 * Handle to our configuration.
110 */
111const struct GNUNET_CONFIGURATION_Handle *cfg;
112
113/**
114 * Handle to the statistics service.
115 */
116struct GNUNET_STATISTICS_Handle *stats;
117
118/**
119 * Handle to communicate with ATS.
120 */
121struct GNUNET_ATS_ConnectivityHandle *ats_ch;
122
123/**
124 * Local peer own ID.
125 */
126struct GNUNET_PeerIdentity my_full_id;
127
128/**
129 * Own private key.
130 */
131struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
132
133/**
134 * Signal that shutdown is happening: prevent recovery measures.
135 */
136int shutting_down;
137
138/**
139 * DLL with all the clients, head.
140 */
141static struct CadetClient *clients_head;
142
143/**
144 * DLL with all the clients, tail.
145 */
146static struct CadetClient *clients_tail;
147
148/**
149 * Next ID to assign to a client.
150 */
151static unsigned int next_client_id;
152
153/**
154 * All ports clients of this peer have opened.
155 */
156struct GNUNET_CONTAINER_MultiHashMap *open_ports;
157
158/**
159 * Map from ports to channels where the ports were closed at the
160 * time we got the inbound connection.
161 * Indexed by port, contains `struct CadetChannel`.
162 */
163struct GNUNET_CONTAINER_MultiHashMap *loose_channels;
164
165/**
166 * Map from PIDs to `struct CadetPeer` entries.
167 */
168struct GNUNET_CONTAINER_MultiPeerMap *peers;
169
170/**
171 * Map from `struct GNUNET_CADET_ConnectionTunnelIdentifier`
172 * hash codes to `struct CadetConnection` objects.
173 */
174struct GNUNET_CONTAINER_MultiShortmap *connections;
175
176/**
177 * How many messages are needed to trigger an AXOLOTL ratchet advance.
178 */
179unsigned long long ratchet_messages;
180
181/**
182 * How long until we trigger a ratched advance due to time.
183 */
184struct GNUNET_TIME_Relative ratchet_time;
185
186
187/**
188 * Send a message to a client.
189 *
190 * @param c client to get the message
191 * @param env envelope with the message
192 */
193void
194GSC_send_to_client (struct CadetClient *c,
195 struct GNUNET_MQ_Envelope *env)
196{
197 GNUNET_MQ_send (c->mq,
198 env);
199}
200
201
202/**
203 * Return identifier for a client as a string.
204 *
205 * @param c client to identify
206 * @return string for debugging
207 */
208const char *
209GSC_2s (struct CadetClient *c)
210{
211 static char buf[32];
212
213 GNUNET_snprintf (buf,
214 sizeof (buf),
215 "Client(%u)",
216 c->id);
217 return buf;
218}
219
220
221/**
222 * Lookup channel of client @a c by @a ccn.
223 *
224 * @param c client to look in
225 * @param ccn channel ID to look up
226 * @return NULL if no such channel exists
227 */
228static struct CadetChannel *
229lookup_channel (struct CadetClient *c,
230 struct GNUNET_CADET_ClientChannelNumber ccn)
231{
232 return GNUNET_CONTAINER_multihashmap32_get (c->channels,
233 ntohl (ccn.channel_of_client));
234}
235
236
237/**
238 * Obtain the next LID to use for incoming connections to
239 * the given client.
240 *
241 * @param c client handle
242 */
243static struct GNUNET_CADET_ClientChannelNumber
244client_get_next_ccn (struct CadetClient *c)
245{
246 struct GNUNET_CADET_ClientChannelNumber ccn = c->next_ccn;
247
248 /* increment until we have a free one... */
249 while (NULL !=
250 lookup_channel (c,
251 ccn))
252 {
253 ccn.channel_of_client
254 = htonl (1 + (ntohl (ccn.channel_of_client)));
255 if (ntohl (ccn.channel_of_client) >=
256 GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
257 ccn.channel_of_client = htonl (0);
258 }
259 c->next_ccn.channel_of_client
260 = htonl (1 + (ntohl (ccn.channel_of_client)));
261 return ccn;
262}
263
264
265/**
266 * Bind incoming channel to this client, and notify client about
267 * incoming connection. Caller is responsible for notifying the other
268 * peer about our acceptance of the channel.
269 *
270 * @param c client to bind to
271 * @param ch channel to be bound
272 * @param dest peer that establishes the connection
273 * @param port port number
274 * @param options options
275 * @return local channel number assigned to the new client
276 */
277struct GNUNET_CADET_ClientChannelNumber
278GSC_bind (struct CadetClient *c,
279 struct CadetChannel *ch,
280 struct CadetPeer *dest,
281 const struct GNUNET_HashCode *port,
282 uint32_t options)
283{
284 struct GNUNET_MQ_Envelope *env;
285 struct GNUNET_CADET_LocalChannelCreateMessage *cm;
286 struct GNUNET_CADET_ClientChannelNumber ccn;
287
288 ccn = client_get_next_ccn (c);
289 GNUNET_assert (GNUNET_YES ==
290 GNUNET_CONTAINER_multihashmap32_put (c->channels,
291 ntohl (ccn.channel_of_client),
292 ch,
293 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
294 LOG (GNUNET_ERROR_TYPE_DEBUG,
295 "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n",
296 GCCH_2s (ch),
297 GCP_2s (dest),
298 GNUNET_h2s (port),
299 ntohl (options),
300 ntohl (ccn.channel_of_client));
301 /* notify local client about incoming connection! */
302 env = GNUNET_MQ_msg (cm,
303 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
304 cm->ccn = ccn;
305 cm->port = *port;
306 cm->opt = htonl (options);
307 cm->peer = *GCP_get_id (dest);
308 GSC_send_to_client (c,
309 env);
310 return ccn;
311}
312
313
314/**
315 * Callback invoked on all peers to destroy all tunnels
316 * that may still exist.
317 *
318 * @param cls NULL
319 * @param pid identify of a peer
320 * @param value a `struct CadetPeer` that may still have a tunnel
321 * @return #GNUNET_OK (iterate over all entries)
322 */
323static int
324destroy_tunnels_now (void *cls,
325 const struct GNUNET_PeerIdentity *pid,
326 void *value)
327{
328 struct CadetPeer *cp = value;
329 struct CadetTunnel *t = GCP_get_tunnel (cp,
330 GNUNET_NO);
331
332 if (NULL != t)
333 GCT_destroy_tunnel_now (t);
334 return GNUNET_OK;
335}
336
337
338/**
339 * Callback invoked on all peers to destroy all tunnels
340 * that may still exist.
341 *
342 * @param cls NULL
343 * @param pid identify of a peer
344 * @param value a `struct CadetPeer` that may still have a tunnel
345 * @return #GNUNET_OK (iterate over all entries)
346 */
347static int
348destroy_paths_now (void *cls,
349 const struct GNUNET_PeerIdentity *pid,
350 void *value)
351{
352 struct CadetPeer *cp = value;
353
354 GCP_drop_owned_paths (cp);
355 return GNUNET_OK;
356}
357
358
359/**
360 * Shutdown everything once the clients have disconnected.
361 */
362static void
363shutdown_rest ()
364{
365 if (NULL != stats)
366 {
367 GNUNET_STATISTICS_destroy (stats,
368 GNUNET_NO);
369 stats = NULL;
370 }
371 if (NULL != open_ports)
372 {
373 GNUNET_CONTAINER_multihashmap_destroy (open_ports);
374 open_ports = NULL;
375 }
376 if (NULL != loose_channels)
377 {
378 GNUNET_CONTAINER_multihashmap_destroy (loose_channels);
379 loose_channels = NULL;
380 }
381 /* Destroy tunnels. Note that all channels must be destroyed first! */
382 GCP_iterate_all (&destroy_tunnels_now,
383 NULL);
384 /* All tunnels, channels, connections and CORE must be down before this point. */
385 GCP_iterate_all (&destroy_paths_now,
386 NULL);
387 /* All paths, tunnels, channels, connections and CORE must be down before this point. */
388 GCP_destroy_all_peers ();
389 if (NULL != peers)
390 {
391 GNUNET_CONTAINER_multipeermap_destroy (peers);
392 peers = NULL;
393 }
394 if (NULL != connections)
395 {
396 GNUNET_CONTAINER_multishortmap_destroy (connections);
397 connections = NULL;
398 }
399 if (NULL != ats_ch)
400 {
401 GNUNET_ATS_connectivity_done (ats_ch);
402 ats_ch = NULL;
403 }
404 GCD_shutdown ();
405 GCH_shutdown ();
406 GNUNET_free_non_null (my_private_key);
407 my_private_key = NULL;
408}
409
410
411/**
412 * Task run during shutdown.
413 *
414 * @param cls unused
415 */
416static void
417shutdown_task (void *cls)
418{
419 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
420 "Shutting down\n");
421 shutting_down = GNUNET_YES;
422 GCO_shutdown ();
423 if (NULL == clients_head)
424 shutdown_rest ();
425}
426
427
428/**
429 * We had a remote connection @a value to port @a port before
430 * client @a cls opened port @a port. Bind them now.
431 *
432 * @param cls the `struct CadetClient`
433 * @param port the port
434 * @param value the `struct CadetChannel`
435 * @return #GNUNET_YES (iterate over all such channels)
436 */
437static int
438bind_loose_channel (void *cls,
439 const struct GNUNET_HashCode *port,
440 void *value)
441{
442 struct CadetClient *c = cls;
443 struct CadetChannel *ch = value;
444
445 GCCH_bind (ch,
446 c);
447 GNUNET_assert (GNUNET_YES ==
448 GNUNET_CONTAINER_multihashmap_remove (loose_channels,
449 port,
450 value));
451 return GNUNET_YES;
452}
453
454
455/**
456 * Handle port open request. Creates a mapping from the
457 * port to the respective client and checks whether we have
458 * loose channels trying to bind to the port. If so, those
459 * are bound.
460 *
461 * @param cls Identification of the client.
462 * @param pmsg The actual message.
463 */
464static void
465handle_port_open (void *cls,
466 const struct GNUNET_CADET_PortMessage *pmsg)
467{
468 struct CadetClient *c = cls;
469
470 LOG (GNUNET_ERROR_TYPE_DEBUG,
471 "Open port %s requested by %s\n",
472 GNUNET_h2s (&pmsg->port),
473 GSC_2s (c));
474 if (NULL == c->ports)
475 c->ports = GNUNET_CONTAINER_multihashmap_create (4,
476 GNUNET_NO);
477 if (GNUNET_OK !=
478 GNUNET_CONTAINER_multihashmap_put (c->ports,
479 &pmsg->port,
480 c,
481 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
482 {
483 GNUNET_break (0);
484 GNUNET_SERVICE_client_drop (c->client);
485 return;
486 }
487 (void) GNUNET_CONTAINER_multihashmap_put (open_ports,
488 &pmsg->port,
489 c,
490 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
491 GNUNET_CONTAINER_multihashmap_get_multiple (loose_channels,
492 &pmsg->port,
493 &bind_loose_channel,
494 c);
495 GNUNET_SERVICE_client_continue (c->client);
496}
497
498
499/**
500 * Handler for port close requests. Marks this port as closed
501 * (unless of course we have another client with the same port
502 * open). Note that existing channels accepted on the port are
503 * not affected.
504 *
505 * @param cls Identification of the client.
506 * @param pmsg The actual message.
507 */
508static void
509handle_port_close (void *cls,
510 const struct GNUNET_CADET_PortMessage *pmsg)
511{
512 struct CadetClient *c = cls;
513
514 LOG (GNUNET_ERROR_TYPE_DEBUG,
515 "Closing port %s as requested by %s\n",
516 GNUNET_h2s (&pmsg->port),
517 GSC_2s (c));
518 if (GNUNET_YES !=
519 GNUNET_CONTAINER_multihashmap_remove (c->ports,
520 &pmsg->port,
521 c))
522 {
523 GNUNET_break (0);
524 GNUNET_SERVICE_client_drop (c->client);
525 return;
526 }
527 GNUNET_assert (GNUNET_YES ==
528 GNUNET_CONTAINER_multihashmap_remove (open_ports,
529 &pmsg->port,
530 c));
531 GNUNET_SERVICE_client_continue (c->client);
532}
533
534
535/**
536 * Handler for requests for us creating a new channel to another peer and port.
537 *
538 * @param cls Identification of the client.
539 * @param tcm The actual message.
540 */
541static void
542handle_channel_create (void *cls,
543 const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
544{
545 struct CadetClient *c = cls;
546 struct CadetChannel *ch;
547
548 if (ntohl (tcm->ccn.channel_of_client) < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
549 {
550 /* Channel ID not in allowed range. */
551 GNUNET_break (0);
552 GNUNET_SERVICE_client_drop (c->client);
553 return;
554 }
555 ch = lookup_channel (c,
556 tcm->ccn);
557 if (NULL != ch)
558 {
559 /* Channel ID already in use. Not allowed. */
560 GNUNET_break (0);
561 GNUNET_SERVICE_client_drop (c->client);
562 return;
563 }
564 LOG (GNUNET_ERROR_TYPE_DEBUG,
565 "New channel to %s at port %s requested by %s\n",
566 GNUNET_i2s (&tcm->peer),
567 GNUNET_h2s (&tcm->port),
568 GSC_2s (c));
569
570 /* Create channel */
571 ch = GCCH_channel_local_new (c,
572 tcm->ccn,
573 GCP_get (&tcm->peer,
574 GNUNET_YES),
575 &tcm->port,
576 ntohl (tcm->opt));
577 if (NULL == ch)
578 {
579 GNUNET_break (0);
580 GNUNET_SERVICE_client_drop (c->client);
581 return;
582 }
583 GNUNET_assert (GNUNET_YES ==
584 GNUNET_CONTAINER_multihashmap32_put (c->channels,
585 ntohl (tcm->ccn.channel_of_client),
586 ch,
587 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
588
589 GNUNET_SERVICE_client_continue (c->client);
590}
591
592
593/**
594 * Handler for requests of destroying an existing channel.
595 *
596 * @param cls client identification of the client
597 * @param msg the actual message
598 */
599static void
600handle_channel_destroy (void *cls,
601 const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
602{
603 struct CadetClient *c = cls;
604 struct CadetChannel *ch;
605
606 ch = lookup_channel (c,
607 msg->ccn);
608 if (NULL == ch)
609 {
610 /* Client attempted to destroy unknown channel */
611 GNUNET_break (0);
612 GNUNET_SERVICE_client_drop (c->client);
613 return;
614 }
615 LOG (GNUNET_ERROR_TYPE_INFO,
616 "%s is destroying %s\n",
617 GSC_2s(c),
618 GCCH_2s (ch));
619 GNUNET_assert (GNUNET_YES ==
620 GNUNET_CONTAINER_multihashmap32_remove (c->channels,
621 ntohl (msg->ccn.channel_of_client),
622 ch));
623 GCCH_channel_local_destroy (ch,
624 c,
625 msg->ccn);
626 GNUNET_SERVICE_client_continue (c->client);
627}
628
629
630/**
631 * Check for client traffic data message is well-formed.
632 *
633 * @param cls identification of the client
634 * @param msg the actual message
635 * @return #GNUNET_OK if @a msg is OK, #GNUNET_SYSERR if not
636 */
637static int
638check_local_data (void *cls,
639 const struct GNUNET_CADET_LocalData *msg)
640{
641 size_t payload_size;
642 size_t payload_claimed_size;
643 const char *buf;
644 struct GNUNET_MessageHeader pa;
645
646 /* FIXME: what is the format we shall allow for @a msg?
647 ONE payload item or multiple? Seems current cadet_api
648 at least in theory allows more than one. Next-gen
649 cadet_api will likely no more, so we could then
650 simplify this mess again. */
651 /* Sanity check for message size */
652 payload_size = ntohs (msg->header.size) - sizeof (*msg);
653 buf = (const char *) &msg[1];
654 while (payload_size >= sizeof (struct GNUNET_MessageHeader))
655 {
656 /* need to memcpy() for alignment */
657 GNUNET_memcpy (&pa,
658 buf,
659 sizeof (pa));
660 payload_claimed_size = ntohs (pa.size);
661 if ( (payload_size < payload_claimed_size) ||
662 (payload_claimed_size < sizeof (struct GNUNET_MessageHeader)) ||
663 (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size) )
664 {
665 GNUNET_break (0);
666 LOG (GNUNET_ERROR_TYPE_DEBUG,
667 "Local data of %u total size had sub-message %u at %u with %u bytes\n",
668 ntohs (msg->header.size),
669 ntohs (pa.type),
670 (unsigned int) (buf - (const char *) &msg[1]),
671 (unsigned int) payload_claimed_size);
672 return GNUNET_SYSERR;
673 }
674 payload_size -= payload_claimed_size;
675 buf += payload_claimed_size;
676 }
677 if (0 != payload_size)
678 {
679 GNUNET_break_op (0);
680 return GNUNET_SYSERR;
681 }
682 return GNUNET_OK;
683}
684
685
686/**
687 * Handler for client payload traffic to be send on a channel to
688 * another peer.
689 *
690 * @param cls identification of the client
691 * @param msg the actual message
692 */
693static void
694handle_local_data (void *cls,
695 const struct GNUNET_CADET_LocalData *msg)
696{
697 struct CadetClient *c = cls;
698 struct CadetChannel *ch;
699 size_t payload_size;
700 const char *buf;
701
702 ch = lookup_channel (c,
703 msg->ccn);
704 if (NULL == ch)
705 {
706 /* Channel does not exist! */
707 GNUNET_break (0);
708 GNUNET_SERVICE_client_drop (c->client);
709 return;
710 }
711 payload_size = ntohs (msg->header.size) - sizeof (*msg);
712 buf = (const char *) &msg[1];
713 LOG (GNUNET_ERROR_TYPE_DEBUG,
714 "Received %u bytes payload from %s for %s\n",
715 (unsigned int) payload_size,
716 GSC_2s (c),
717 GCCH_2s (ch));
718 if (GNUNET_OK !=
719 GCCH_handle_local_data (ch,
720 msg->ccn,
721 buf,
722 payload_size))
723 {
724 GNUNET_SERVICE_client_drop (c->client);
725 return;
726 }
727 GNUNET_SERVICE_client_continue (c->client);
728}
729
730
731/**
732 * Handler for client's ACKs for payload traffic.
733 *
734 * @param cls identification of the client.
735 * @param msg The actual message.
736 */
737static void
738handle_local_ack (void *cls,
739 const struct GNUNET_CADET_LocalAck *msg)
740{
741 struct CadetClient *c = cls;
742 struct CadetChannel *ch;
743
744 ch = lookup_channel (c,
745 msg->ccn);
746 if (NULL == ch)
747 {
748 /* Channel does not exist! */
749 GNUNET_break (0);
750 GNUNET_SERVICE_client_drop (c->client);
751 return;
752 }
753 LOG (GNUNET_ERROR_TYPE_DEBUG,
754 "Got a local ACK from %s for %s\n",
755 GSC_2s(c),
756 GCCH_2s (ch));
757 GCCH_handle_local_ack (ch,
758 msg->ccn);
759 GNUNET_SERVICE_client_continue (c->client);
760}
761
762
763/**
764 * Iterator over all peers to send a monitoring client info about each peer.
765 *
766 * @param cls Closure ().
767 * @param peer Peer ID (tunnel remote peer).
768 * @param value Peer info.
769 * @return #GNUNET_YES, to keep iterating.
770 */
771static int
772get_all_peers_iterator (void *cls,
773 const struct GNUNET_PeerIdentity *peer,
774 void *value)
775{
776 struct CadetClient *c = cls;
777 struct CadetPeer *p = value;
778 struct GNUNET_MQ_Envelope *env;
779 struct GNUNET_CADET_LocalInfoPeer *msg;
780
781 env = GNUNET_MQ_msg (msg,
782 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
783 msg->destination = *peer;
784 msg->paths = htons (GCP_count_paths (p));
785 msg->tunnel = htons (NULL != GCP_get_tunnel (p,
786 GNUNET_NO));
787 GNUNET_MQ_send (c->mq,
788 env);
789 return GNUNET_YES;
790}
791
792
793/**
794 * Handler for client's INFO PEERS request.
795 *
796 * @param cls Identification of the client.
797 * @param message The actual message.
798 */
799static void
800handle_get_peers (void *cls,
801 const struct GNUNET_MessageHeader *message)
802{
803 struct CadetClient *c = cls;
804 struct GNUNET_MQ_Envelope *env;
805 struct GNUNET_MessageHeader *reply;
806
807 GCP_iterate_all (&get_all_peers_iterator,
808 c);
809 env = GNUNET_MQ_msg (reply,
810 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
811 GNUNET_MQ_send (c->mq,
812 env);
813 GNUNET_SERVICE_client_continue (c->client);
814}
815
816
817/**
818 * Iterator over all paths of a peer to build an InfoPeer message.
819 * Message contains blocks of peers, first not included.
820 *
821 * @param cls message queue for transmission
822 * @param path Path itself
823 * @param off offset of the peer on @a path
824 * @return #GNUNET_YES if should keep iterating.
825 * #GNUNET_NO otherwise.
826 */
827static int
828path_info_iterator (void *cls,
829 struct CadetPeerPath *path,
830 unsigned int off)
831{
832 struct GNUNET_MQ_Handle *mq = cls;
833 struct GNUNET_MQ_Envelope *env;
834 struct GNUNET_MessageHeader *resp;
835 struct GNUNET_PeerIdentity *id;
836 uint16_t path_size;
837 unsigned int i;
838 unsigned int path_length;
839
840 path_length = GCPP_get_length (path);
841 path_size = sizeof (struct GNUNET_PeerIdentity) * (path_length - 1);
842 if (sizeof (*resp) + path_size > UINT16_MAX)
843 {
844 LOG (GNUNET_ERROR_TYPE_WARNING,
845 "Path of %u entries is too long for info message\n",
846 path_length);
847 return GNUNET_YES;
848 }
849 env = GNUNET_MQ_msg_extra (resp,
850 path_size,
851 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER);
852 id = (struct GNUNET_PeerIdentity *) &resp[1];
853
854 /* Don't copy first peer. First peer is always the local one. Last
855 * peer is always the destination (leave as 0, EOL).
856 */
857 for (i = 0; i < off; i++)
858 id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
859 i + 1));
860 GNUNET_MQ_send (mq,
861 env);
862 return GNUNET_YES;
863}
864
865
866/**
867 * Handler for client's SHOW_PEER request.
868 *
869 * @param cls Identification of the client.
870 * @param msg The actual message.
871 */
872static void
873handle_show_peer (void *cls,
874 const struct GNUNET_CADET_LocalInfo *msg)
875{
876 struct CadetClient *c = cls;
877 struct CadetPeer *p;
878 struct GNUNET_MQ_Envelope *env;
879 struct GNUNET_MessageHeader *resp;
880
881 p = GCP_get (&msg->peer,
882 GNUNET_NO);
883 if (NULL != p)
884 GCP_iterate_paths (p,
885 &path_info_iterator,
886 c->mq);
887 /* Send message with 0/0 to indicate the end */
888 env = GNUNET_MQ_msg (resp,
889 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER_END);
890 GNUNET_MQ_send (c->mq,
891 env);
892 GNUNET_SERVICE_client_continue (c->client);
893}
894
895
896/**
897 * Iterator over all tunnels to send a monitoring client info about each tunnel.
898 *
899 * @param cls Closure ().
900 * @param peer Peer ID (tunnel remote peer).
901 * @param value a `struct CadetPeer`
902 * @return #GNUNET_YES, to keep iterating.
903 */
904static int
905get_all_tunnels_iterator (void *cls,
906 const struct GNUNET_PeerIdentity *peer,
907 void *value)
908{
909 struct CadetClient *c = cls;
910 struct CadetPeer *p = value;
911 struct GNUNET_MQ_Envelope *env;
912 struct GNUNET_CADET_LocalInfoTunnel *msg;
913 struct CadetTunnel *t;
914
915 t = GCP_get_tunnel (p,
916 GNUNET_NO);
917 if (NULL == t)
918 return GNUNET_YES;
919 env = GNUNET_MQ_msg (msg,
920 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
921 msg->destination = *peer;
922 msg->channels = htonl (GCT_count_channels (t));
923 msg->connections = htonl (GCT_count_any_connections (t));
924 msg->cstate = htons (0);
925 msg->estate = htons ((uint16_t) GCT_get_estate (t));
926 GNUNET_MQ_send (c->mq,
927 env);
928 return GNUNET_YES;
929}
930
931
932/**
933 * Handler for client's #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS request.
934 *
935 * @param cls client Identification of the client.
936 * @param message The actual message.
937 */
938static void
939handle_info_tunnels (void *cls,
940 const struct GNUNET_MessageHeader *message)
941{
942 struct CadetClient *c = cls;
943 struct GNUNET_MQ_Envelope *env;
944 struct GNUNET_MessageHeader *reply;
945
946 GCP_iterate_all (&get_all_tunnels_iterator,
947 c);
948 env = GNUNET_MQ_msg (reply,
949 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
950 GNUNET_MQ_send (c->mq,
951 env);
952 GNUNET_SERVICE_client_continue (c->client);
953}
954
955
956/**
957 * Update the message with information about the connection.
958 *
959 * @param cls a `struct GNUNET_CADET_LocalInfoTunnel` message to update
960 * @param c a connection about which we should store information in @a cls
961 */
962static void
963iter_connection (void *cls,
964 struct CadetConnection *c)
965{
966 struct GNUNET_CADET_LocalInfoTunnel *msg = cls;
967 struct GNUNET_CADET_ConnectionTunnelIdentifier *h;
968
969 h = (struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
970 h[msg->connections++] = *(GCC_get_id (c));
971}
972
973
974/**
975 * Update the message with information about the channel.
976 *
977 * @param cls a `struct GNUNET_CADET_LocalInfoTunnel` message to update
978 * @param ch a channel about which we should store information in @a cls
979 */
980static void
981iter_channel (void *cls,
982 struct CadetChannel *ch)
983{
984 struct GNUNET_CADET_LocalInfoTunnel *msg = cls;
985 struct GNUNET_CADET_ConnectionTunnelIdentifier *h = (struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
986 struct GNUNET_CADET_ChannelTunnelNumber *chn
987 = (struct GNUNET_CADET_ChannelTunnelNumber *) &h[msg->connections];
988
989 chn[msg->channels++] = GCCH_get_id (ch);
990}
991
992
993/**
994 * Handler for client's #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL request.
995 *
996 * @param cls Identification of the client.
997 * @param msg The actual message.
998 */
999static void
1000handle_info_tunnel (void *cls,
1001 const struct GNUNET_CADET_LocalInfo *msg)
1002{
1003 struct CadetClient *c = cls;
1004 struct GNUNET_MQ_Envelope *env;
1005 struct GNUNET_CADET_LocalInfoTunnel *resp;
1006 struct CadetTunnel *t;
1007 struct CadetPeer *p;
1008 unsigned int ch_n;
1009 unsigned int c_n;
1010
1011 p = GCP_get (&msg->peer,
1012 GNUNET_NO);
1013 t = GCP_get_tunnel (p,
1014 GNUNET_NO);
1015 if (NULL == t)
1016 {
1017 /* We don't know the tunnel */
1018 struct GNUNET_MQ_Envelope *env;
1019 struct GNUNET_CADET_LocalInfoTunnel *warn;
1020
1021 LOG (GNUNET_ERROR_TYPE_INFO,
1022 "Tunnel to %s unknown\n",
1023 GNUNET_i2s_full (&msg->peer));
1024 env = GNUNET_MQ_msg (warn,
1025 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1026 warn->destination = msg->peer;
1027 GNUNET_MQ_send (c->mq,
1028 env);
1029 GNUNET_SERVICE_client_continue (c->client);
1030 return;
1031 }
1032
1033 /* Initialize context */
1034 ch_n = GCT_count_channels (t);
1035 c_n = GCT_count_any_connections (t);
1036 env = GNUNET_MQ_msg_extra (resp,
1037 c_n * sizeof (struct GNUNET_CADET_ConnectionTunnelIdentifier) +
1038 ch_n * sizeof (struct GNUNET_CADET_ChannelTunnelNumber),
1039 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1040 resp->destination = msg->peer;
1041 /* Do not reorder! #iter_channel needs counters in HBO! */
1042 GCT_iterate_connections (t,
1043 &iter_connection,
1044 resp);
1045 GCT_iterate_channels (t,
1046 &iter_channel,
1047 resp);
1048 resp->connections = htonl (resp->connections);
1049 resp->channels = htonl (resp->channels);
1050 resp->cstate = htons (0);
1051 resp->estate = htons (GCT_get_estate (t));
1052 GNUNET_MQ_send (c->mq,
1053 env);
1054 GNUNET_SERVICE_client_continue (c->client);
1055}
1056
1057
1058/**
1059 * Iterator over all peers to dump info for each peer.
1060 *
1061 * @param cls Closure (unused).
1062 * @param peer Peer ID (tunnel remote peer).
1063 * @param value Peer info.
1064 *
1065 * @return #GNUNET_YES, to keep iterating.
1066 */
1067static int
1068show_peer_iterator (void *cls,
1069 const struct GNUNET_PeerIdentity *peer,
1070 void *value)
1071{
1072 struct CadetPeer *p = value;
1073 struct CadetTunnel *t;
1074
1075 t = GCP_get_tunnel (p,
1076 GNUNET_NO);
1077 if (NULL != t)
1078 GCT_debug (t,
1079 GNUNET_ERROR_TYPE_ERROR);
1080 LOG (GNUNET_ERROR_TYPE_ERROR, "\n");
1081 return GNUNET_YES;
1082}
1083
1084
1085/**
1086 * Handler for client's INFO_DUMP request.
1087 *
1088 * @param cls Identification of the client.
1089 * @param message The actual message.
1090 */
1091static void
1092handle_info_dump (void *cls,
1093 const struct GNUNET_MessageHeader *message)
1094{
1095 struct CadetClient *c = cls;
1096
1097 LOG (GNUNET_ERROR_TYPE_INFO,
1098 "Received dump info request from client %u\n",
1099 c->id);
1100
1101 LOG (GNUNET_ERROR_TYPE_ERROR,
1102 "*************************** DUMP START ***************************\n");
1103 for (struct CadetClient *ci = clients_head;
1104 NULL != ci;
1105 ci = ci->next)
1106 {
1107 LOG (GNUNET_ERROR_TYPE_ERROR,
1108 "Client %u (%p), handle: %p, ports: %u, channels: %u\n",
1109 ci->id,
1110 ci,
1111 ci->client,
1112 (NULL != c->ports)
1113 ? GNUNET_CONTAINER_multihashmap_size (ci->ports)
1114 : 0,
1115 GNUNET_CONTAINER_multihashmap32_size (ci->channels));
1116 }
1117 LOG (GNUNET_ERROR_TYPE_ERROR, "***************************\n");
1118 GCP_iterate_all (&show_peer_iterator,
1119 NULL);
1120
1121 LOG (GNUNET_ERROR_TYPE_ERROR,
1122 "**************************** DUMP END ****************************\n");
1123
1124 GNUNET_SERVICE_client_continue (c->client);
1125}
1126
1127
1128
1129/**
1130 * Callback called when a client connects to the service.
1131 *
1132 * @param cls closure for the service
1133 * @param client the new client that connected to the service
1134 * @param mq the message queue used to send messages to the client
1135 * @return @a c
1136 */
1137static void *
1138client_connect_cb (void *cls,
1139 struct GNUNET_SERVICE_Client *client,
1140 struct GNUNET_MQ_Handle *mq)
1141{
1142 struct CadetClient *c;
1143
1144 c = GNUNET_new (struct CadetClient);
1145 c->client = client;
1146 c->mq = mq;
1147 c->id = next_client_id++; /* overflow not important: just for debug */
1148 c->channels
1149 = GNUNET_CONTAINER_multihashmap32_create (32);
1150 GNUNET_CONTAINER_DLL_insert (clients_head,
1151 clients_tail,
1152 c);
1153 GNUNET_STATISTICS_update (stats,
1154 "# clients",
1155 +1,
1156 GNUNET_NO);
1157 LOG (GNUNET_ERROR_TYPE_DEBUG,
1158 "%s connected\n",
1159 GSC_2s (c));
1160 return c;
1161}
1162
1163
1164/**
1165 * A channel was destroyed by the other peer. Tell our client.
1166 *
1167 * @param c client that lost a channel
1168 * @param ccn channel identification number for the client
1169 * @param ch the channel object
1170 */
1171void
1172GSC_handle_remote_channel_destroy (struct CadetClient *c,
1173 struct GNUNET_CADET_ClientChannelNumber ccn,
1174 struct CadetChannel *ch)
1175{
1176 struct GNUNET_MQ_Envelope *env;
1177 struct GNUNET_CADET_LocalChannelDestroyMessage *tdm;
1178
1179 env = GNUNET_MQ_msg (tdm,
1180 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
1181 tdm->ccn = ccn;
1182 GSC_send_to_client (c,
1183 env);
1184 GNUNET_assert (GNUNET_YES ==
1185 GNUNET_CONTAINER_multihashmap32_remove (c->channels,
1186 ntohl (ccn.channel_of_client),
1187 ch));
1188}
1189
1190
1191/**
1192 * Iterator for deleting each channel whose client endpoint disconnected.
1193 *
1194 * @param cls Closure (client that has disconnected).
1195 * @param key The local channel id in host byte order
1196 * @param value The value stored at the key (channel to destroy).
1197 * @return #GNUNET_OK, keep iterating.
1198 */
1199static int
1200channel_destroy_iterator (void *cls,
1201 uint32_t key,
1202 void *value)
1203{
1204 struct CadetClient *c = cls;
1205 struct GNUNET_CADET_ClientChannelNumber ccn;
1206 struct CadetChannel *ch = value;
1207
1208 LOG (GNUNET_ERROR_TYPE_DEBUG,
1209 "Destroying %s, due to %s disconnecting.\n",
1210 GCCH_2s (ch),
1211 GSC_2s (c));
1212 GNUNET_assert (GNUNET_YES ==
1213 GNUNET_CONTAINER_multihashmap32_remove (c->channels,
1214 key,
1215 ch));
1216 ccn.channel_of_client = htonl (key);
1217 GCCH_channel_local_destroy (ch,
1218 c,
1219 ccn);
1220 return GNUNET_OK;
1221}
1222
1223
1224/**
1225 * Remove client's ports from the global hashmap on disconnect.
1226 *
1227 * @param cls Closure (unused).
1228 * @param key the port.
1229 * @param value the `struct CadetClient` to remove
1230 * @return #GNUNET_OK, keep iterating.
1231 */
1232static int
1233client_release_ports (void *cls,
1234 const struct GNUNET_HashCode *key,
1235 void *value)
1236{
1237 struct CadetClient *c = value;
1238
1239 LOG (GNUNET_ERROR_TYPE_DEBUG,
1240 "Closing port %s due to %s disconnect.\n",
1241 GNUNET_h2s (key),
1242 GSC_2s (c));
1243 GNUNET_assert (GNUNET_YES ==
1244 GNUNET_CONTAINER_multihashmap_remove (open_ports,
1245 key,
1246 value));
1247 GNUNET_assert (GNUNET_YES ==
1248 GNUNET_CONTAINER_multihashmap_remove (c->ports,
1249 key,
1250 value));
1251 return GNUNET_OK;
1252}
1253
1254
1255/**
1256 * Callback called when a client disconnected from the service
1257 *
1258 * @param cls closure for the service
1259 * @param client the client that disconnected
1260 * @param internal_cls should be equal to @a c
1261 */
1262static void
1263client_disconnect_cb (void *cls,
1264 struct GNUNET_SERVICE_Client *client,
1265 void *internal_cls)
1266{
1267 struct CadetClient *c = internal_cls;
1268
1269 GNUNET_assert (c->client == client);
1270 LOG (GNUNET_ERROR_TYPE_DEBUG,
1271 "%s is disconnecting.\n",
1272 GSC_2s (c));
1273 if (NULL != c->channels)
1274 {
1275 GNUNET_CONTAINER_multihashmap32_iterate (c->channels,
1276 &channel_destroy_iterator,
1277 c);
1278 GNUNET_CONTAINER_multihashmap32_destroy (c->channels);
1279 }
1280 if (NULL != c->ports)
1281 {
1282 GNUNET_CONTAINER_multihashmap_iterate (c->ports,
1283 &client_release_ports,
1284 c);
1285 GNUNET_CONTAINER_multihashmap_destroy (c->ports);
1286 }
1287 GNUNET_CONTAINER_DLL_remove (clients_head,
1288 clients_tail,
1289 c);
1290 GNUNET_STATISTICS_update (stats,
1291 "# clients",
1292 -1,
1293 GNUNET_NO);
1294 GNUNET_free (c);
1295 if ( (NULL == clients_head) &&
1296 (GNUNET_YES == shutting_down) )
1297 shutdown_rest ();
1298}
1299
1300
1301/**
1302 * Setup CADET internals.
1303 *
1304 * @param cls closure
1305 * @param server the initialized server
1306 * @param c configuration to use
1307 */
1308static void
1309run (void *cls,
1310 const struct GNUNET_CONFIGURATION_Handle *c,
1311 struct GNUNET_SERVICE_Handle *service)
1312{
1313 cfg = c;
1314 if (GNUNET_OK !=
1315 GNUNET_CONFIGURATION_get_value_number (c,
1316 "CADET",
1317 "RATCHET_MESSAGES",
1318 &ratchet_messages))
1319 {
1320 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1321 "CADET",
1322 "RATCHET_MESSAGES",
1323 "needs to be a number");
1324 ratchet_messages = 64;
1325 }
1326 if (GNUNET_OK !=
1327 GNUNET_CONFIGURATION_get_value_time (c,
1328 "CADET",
1329 "RATCHET_TIME",
1330 &ratchet_time))
1331 {
1332 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1333 "CADET",
1334 "RATCHET_TIME",
1335 "need delay value");
1336 ratchet_time = GNUNET_TIME_UNIT_HOURS;
1337 }
1338
1339 my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
1340 if (NULL == my_private_key)
1341 {
1342 GNUNET_break (0);
1343 GNUNET_SCHEDULER_shutdown ();
1344 return;
1345 }
1346 GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
1347 &my_full_id.public_key);
1348 stats = GNUNET_STATISTICS_create ("cadet",
1349 c);
1350 GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
1351 NULL);
1352 ats_ch = GNUNET_ATS_connectivity_init (c);
1353 /* FIXME: optimize code to allow GNUNET_YES here! */
1354 open_ports = GNUNET_CONTAINER_multihashmap_create (16,
1355 GNUNET_NO);
1356 loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
1357 GNUNET_NO);
1358 peers = GNUNET_CONTAINER_multipeermap_create (16,
1359 GNUNET_YES);
1360 connections = GNUNET_CONTAINER_multishortmap_create (256,
1361 GNUNET_YES);
1362 GCH_init (c);
1363 GCD_init (c);
1364 GCO_init (c);
1365 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1366 "CADET started for peer %s\n",
1367 GNUNET_i2s (&my_full_id));
1368
1369}
1370
1371
1372/**
1373 * Define "main" method using service macro.
1374 */
1375GNUNET_SERVICE_MAIN
1376("cadet",
1377 GNUNET_SERVICE_OPTION_NONE,
1378 &run,
1379 &client_connect_cb,
1380 &client_disconnect_cb,
1381 NULL,
1382 GNUNET_MQ_hd_fixed_size (port_open,
1383 GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN,
1384 struct GNUNET_CADET_PortMessage,
1385 NULL),
1386 GNUNET_MQ_hd_fixed_size (port_close,
1387 GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE,
1388 struct GNUNET_CADET_PortMessage,
1389 NULL),
1390 GNUNET_MQ_hd_fixed_size (channel_create,
1391 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
1392 struct GNUNET_CADET_LocalChannelCreateMessage,
1393 NULL),
1394 GNUNET_MQ_hd_fixed_size (channel_destroy,
1395 GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
1396 struct GNUNET_CADET_LocalChannelDestroyMessage,
1397 NULL),
1398 GNUNET_MQ_hd_var_size (local_data,
1399 GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
1400 struct GNUNET_CADET_LocalData,
1401 NULL),
1402 GNUNET_MQ_hd_fixed_size (local_ack,
1403 GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
1404 struct GNUNET_CADET_LocalAck,
1405 NULL),
1406 GNUNET_MQ_hd_fixed_size (get_peers,
1407 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS,
1408 struct GNUNET_MessageHeader,
1409 NULL),
1410 GNUNET_MQ_hd_fixed_size (show_peer,
1411 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER,
1412 struct GNUNET_CADET_LocalInfo,
1413 NULL),
1414 GNUNET_MQ_hd_fixed_size (info_tunnels,
1415 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS,
1416 struct GNUNET_MessageHeader,
1417 NULL),
1418 GNUNET_MQ_hd_fixed_size (info_tunnel,
1419 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL,
1420 struct GNUNET_CADET_LocalInfo,
1421 NULL),
1422 GNUNET_MQ_hd_fixed_size (info_dump,
1423 GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_DUMP,
1424 struct GNUNET_MessageHeader,
1425 NULL),
1426 GNUNET_MQ_handler_end ());
1427
1428/* end of gnunet-service-cadet-new.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-18 03:12:58 +0000