GNUnet 0.22.2
gnunet-service-messenger_room.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2020--2024 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
26#include "platform.h"
28
39
40#include "messenger_api_util.h"
41
42static void
44
47 const struct GNUNET_HashCode *key)
48{
49 struct GNUNET_MESSENGER_SrvRoom *room;
50
51 GNUNET_assert ((handle) && (key));
52
54
55 room->service = handle->service;
56 room->host = handle;
57 room->port = NULL;
58
59 GNUNET_memcpy (&(room->key), key, sizeof(struct GNUNET_HashCode));
60
62
67
68 init_list_tunnels (&(room->basement));
69 init_message_state (&(room->state));
70
71 room->peer_message = NULL;
72
74 room->idle = NULL;
75
76 if (room->service->dir)
77 load_srv_room (room);
78
81
82 return room;
83}
84
85
88 const struct GNUNET_PeerIdentity *key,
89 void *value)
90{
91 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
92
94
95 tunnel = value;
96
97 destroy_tunnel (tunnel);
98 return GNUNET_YES;
99}
100
101
102static void
104
105static void
107
108void
110 enum GNUNET_GenericReturnValue deletion)
111{
113
114 if (room->idle)
115 {
117 room->idle = NULL;
118 }
119
121
123 NULL);
125
126 if (! (room->service->dir))
127 goto skip_saving;
128
129 if (GNUNET_YES == deletion)
131 else
133
134skip_saving:
139
143
144 if (room->peer_message)
146
148}
149
150
153{
154 GNUNET_assert (room);
155
156 return &(room->peer_store);
157}
158
159
162{
164
165 return &(room->member_store);
166}
167
168
171{
172 GNUNET_assert (room);
173
174 return &(room->message_store);
175}
176
177
180{
182
183 return &(room->operation_store);
184}
185
186
190 struct GNUNET_MESSENGER_SrvTunnel *tunnel)
191{
192 if ((! handle) || (! is_tunnel_connected (tunnel)))
193 return GNUNET_NO;
194
196 room->service));
197}
198
199
200static void*
202 struct GNUNET_CADET_Channel *channel,
203 const struct GNUNET_PeerIdentity *source)
204{
205 struct GNUNET_MESSENGER_SrvRoom *room;
206 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
207
208 GNUNET_assert ((cls) && (channel) && (source));
209
210 room = cls;
211
213 "New incoming connection to room (%s) from peer: %s\n",
215
216 tunnel = create_tunnel (room, source);
217
218 if ((tunnel) &&
220 tunnel,
222 {
223 destroy_tunnel (tunnel);
224 tunnel = NULL;
225 }
226
227 if (! tunnel)
228 {
230 return NULL;
231 }
232
233 bind_tunnel (tunnel, channel);
234
236 "New tunnel in room (%s) established to peer: %s\n",
238
239 if (GNUNET_YES == send_room_info (room, room->host, tunnel))
240 return tunnel;
241
242 disconnect_tunnel (tunnel);
243
245 tunnel))
246 destroy_tunnel (tunnel);
247
248 return NULL;
249}
250
251
255 struct GNUNET_MESSENGER_Member *member,
256 const struct GNUNET_ShortHashCode *id)
257{
258 const struct GNUNET_ShortHashCode *member_id;
259
260 GNUNET_assert ((room) && (handle) && (member));
261
262 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s (
263 get_srv_room_key (room)),
264 GNUNET_sh2s (get_member_id (member)));
265
266 member_id = get_member_id (member);
267
269 member_id))
270 return GNUNET_NO;
271
272 {
274 if ((! id) || (0 != GNUNET_memcmp (id, member_id)))
276 else
278
279 notify_srv_handle_member_id (handle, room, member_id, reset);
280 }
281
282 return GNUNET_YES;
283}
284
285
289{
290 struct GNUNET_MESSENGER_MemberStore *member_store;
291 const struct GNUNET_ShortHashCode *member_id;
292 struct GNUNET_MESSENGER_Member *member;
293
294 member_store = get_srv_room_member_store (room);
296 member = add_store_member (member_store, member_id);
297
298 if (GNUNET_NO == join_room (room, handle, member, member_id))
299 return GNUNET_NO;
300
301 return GNUNET_YES;
302}
303
304
308{
309 GNUNET_assert (room);
310
311 if (handle)
312 room->host = handle;
313
314 if (room->port)
315 {
316 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Port of room (%s) was already open!\n",
318
319 if (! handle)
320 return GNUNET_YES;
321
322 return join_room_locally (room, handle);
323 }
324
325 {
327 const struct GNUNET_HashCode *key;
328 struct GNUNET_HashCode port;
329
331 tunnel_message,
333 struct
336
337 cadet = get_srv_room_cadet (room);
338 key = get_srv_room_key (room);
339
341 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to open CADET port: %s\n",
342 GNUNET_h2s (&port));
343
345 room, NULL, callback_tunnel_disconnect,
346 handlers);
347 }
348
349 if (room->port)
350 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Port of room (%s) was opened!\n",
352 else
354 "Port of room (%s) could not be opened!\n",
356
357 if (! handle)
358 goto complete_opening;
359
360 {
361 struct GNUNET_MESSENGER_MemberStore *member_store;
362 const struct GNUNET_ShortHashCode *member_id;
363 struct GNUNET_MESSENGER_Member *member;
364
365 member_store = get_srv_room_member_store (room);
367 member = add_store_member (member_store, member_id);
368
369 if ((GNUNET_NO == join_room (room, handle, member, member_id)) &&
370 (room->port))
371 {
373 "You could not join the room, therefore it keeps closed!\n");
374
375 close_srv_room (room);
376 return GNUNET_NO;
377 }
378 }
379
380complete_opening:
381 if (! room->port)
382 return GNUNET_NO;
383
384 {
385 struct GNUNET_MESSENGER_Message *message;
386 message = create_message_peer (room->service);
387
388 if (! message)
389 {
391 "Peer message could not be sent!\n");
392 return GNUNET_NO;
393 }
394
395 return send_srv_room_message (room, handle, message);
396 }
397}
398
399
400static void
402{
403 struct GNUNET_PeerIdentity peer;
404
405 GNUNET_assert (room);
406
407 if (! room->port)
408 return;
409
410 if ((room->peer_message) &&
411 (GNUNET_OK == get_service_peer_identity (room->service, &peer)))
412 send_srv_room_message (room, room->host, create_message_miss (&peer));
413
415 room->port = NULL;
416}
417
418
422 const struct GNUNET_PeerIdentity *door)
423{
424 struct GNUNET_PeerIdentity peer;
425 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
426
427 GNUNET_assert ((room) && (handle) && (door));
428
430 (0 == GNUNET_memcmp (&peer, door)))
431 return join_room_locally (room, handle);
432
434
435 if (! tunnel)
436 {
437 tunnel = create_tunnel (room, door);
438
440 tunnel,
442 {
444 "You could not connect to that door!\n");
445 destroy_tunnel (tunnel);
446 return GNUNET_NO;
447 }
448 }
449
450 if (GNUNET_SYSERR == connect_tunnel (tunnel))
451 {
453 "Connection failure during entrance!\n");
455 destroy_tunnel (tunnel);
456 return GNUNET_NO;
457 }
458
459 return join_room_locally (room, handle);
460}
461
462
463static void
465 struct GNUNET_MESSENGER_Message *message,
466 uint16_t length,
467 char *buffer,
468 const struct GNUNET_HashCode *hash)
469{
471
472 GNUNET_assert ((cls) && (message) && (buffer) && (hash));
473
474 handle = cls;
475
476 GNUNET_assert (handle->service);
477
478 sign_message_by_peer (message, length, buffer, hash, handle->service->config);
479}
480
481
482struct GNUNET_MQ_Envelope*
485 struct GNUNET_MESSENGER_Message *message,
486 struct GNUNET_HashCode *hash,
488{
489 struct GNUNET_PeerIdentity peer;
490
491 GNUNET_assert ((room) && (handle) && (message) && (hash));
492
493 if (GNUNET_YES != is_peer_message (message))
494 return pack_message (message, hash, NULL, mode, NULL);
495
498
499 if (GNUNET_OK != get_service_peer_identity (handle->service, &peer))
500 return NULL;
501
502 convert_peer_identity_to_id (&peer, &(message->header.sender_id));
503 get_message_state_chain_hash (&(room->state), &(message->header.previous));
504
506 "Packing message with peer signature: %s\n",
507 GNUNET_sh2s (&(message->header.sender_id)));
508
510 return pack_message (message, hash, sign_srv_room_message_by_peer, mode,
511 handle);
512}
513
514
516{
523};
524
527 const struct GNUNET_PeerIdentity *key,
528 void *value)
529{
530 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
531 struct GNUNET_MESSENGER_ClosureSendRoom *closure;
532 struct GNUNET_MQ_Envelope *env;
533
534 GNUNET_assert ((cls) && (value));
535
536 tunnel = value;
537
538 if ((! is_tunnel_connected (tunnel)) ||
540 return GNUNET_YES;
541
542 closure = cls;
543
544 if (tunnel == closure->exclude)
545 return GNUNET_YES;
546
547 env = NULL;
548
549 if (closure->packed == GNUNET_NO)
550 {
551 env = pack_srv_room_message (closure->room, closure->handle,
552 closure->message, closure->hash,
554
555 if (env)
556 closure->packed = GNUNET_YES;
557 }
558 else
559 env = pack_message (closure->message, NULL, NULL,
561
562 if (env)
563 send_tunnel_envelope (tunnel, env, closure->hash);
564
565 return GNUNET_YES;
566}
567
568
571 struct GNUNET_MESSENGER_Message *message,
572 const struct GNUNET_HashCode *hash);
573
574void
576 const struct GNUNET_MESSENGER_Message *message,
577 const struct GNUNET_HashCode *hash);
578
582 struct GNUNET_MESSENGER_Message *message)
583{
584 struct GNUNET_HashCode hash;
585
586 GNUNET_assert ((room) && (handle));
587
588 if (! message)
589 return GNUNET_NO;
590
592 "Sending message from handle in room: %s (%s)\n",
593 GNUNET_h2s (&(room->key)),
595
596 {
598
599 closure.room = room;
600 closure.handle = handle;
601 closure.exclude = NULL;
602 closure.message = message;
603 closure.hash = &hash;
604 closure.packed = GNUNET_NO;
605
607 iterate_send_room_message, &closure);
608
609 if (GNUNET_NO == closure.packed)
612 }
613
614 {
615 enum GNUNET_GenericReturnValue new_message;
616 new_message = update_room_message (room, message, &hash);
617
618 if (GNUNET_YES != new_message)
619 {
620 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sending duplicate message failed!\n");
621 return GNUNET_SYSERR;
622 }
623 }
624
625 switch (message->header.kind)
626 {
629 break;
632 break;
635 break;
638 break;
641 break;
642 default:
643 break;
644 }
645
647 return GNUNET_YES;
648}
649
650
651void
653 struct GNUNET_MESSENGER_SrvTunnel *tunnel,
655 const struct GNUNET_HashCode *hash)
656{
658 struct GNUNET_HashCode message_hash;
659
660 GNUNET_assert ((room) && (tunnel));
661
662 if (! message)
663 return;
664
665 GNUNET_memcpy (&message_hash, hash, sizeof(struct GNUNET_HashCode));
666
667 closure.room = room;
668 closure.handle = NULL;
669 closure.exclude = tunnel;
670 closure.message = message;
671 closure.hash = &message_hash;
672 closure.packed = GNUNET_YES;
673
675 iterate_send_room_message, &closure);
676}
677
678
679void
681 struct GNUNET_MESSENGER_SrvTunnel *tunnel)
682{
683 struct GNUNET_MESSENGER_MessageStore *message_store;
684 const struct GNUNET_MESSENGER_Message *message;
685
686 if (! room->peer_message)
687 return;
688
689 message_store = get_srv_room_message_store (room);
690 message = get_store_message (message_store, room->peer_message);
691
692 if (! message)
693 {
695 room->peer_message = NULL;
696 return;
697 }
698
699 if (tunnel)
700 forward_tunnel_message (tunnel, message, room->peer_message);
701}
702
703
704void
707{
708 const struct GNUNET_HashCode *hash;
709
710 GNUNET_assert (room);
711
712 if (! handle)
713 return;
714
716 "Merging messages by handle in room: %s\n",
717 GNUNET_h2s (&(room->key)));
718
719 do
720 {
721 struct GNUNET_MESSENGER_Message *message;
722
723 hash = get_message_state_merge_hash (&(room->state));
724
725 if (! hash)
726 break;
727
728 message = create_message_merge (hash);
729
730 if (! message)
731 {
733 "Merging messages failed: %s\n",
734 GNUNET_h2s (&(room->key)));
735 }
736
737 send_srv_room_message (room, handle, message);
738 }
739 while (hash);
740}
741
742
745 struct GNUNET_MESSENGER_MemberSession *session,
746 const struct GNUNET_HashCode *hash,
747 const struct GNUNET_TIME_Relative delay)
748{
749 const struct GNUNET_MESSENGER_Message *message;
750 struct GNUNET_TIME_Relative forever;
751
752 GNUNET_assert ((room) && (session) && (hash));
753
755
756 if (0 == GNUNET_memcmp (&forever, &delay))
757 {
759 "Deletion is delayed forever: operation is impossible!\n");
760 return GNUNET_SYSERR;
761 }
762
763 {
764 struct GNUNET_MESSENGER_MessageStore *message_store;
765
766 message_store = get_srv_room_message_store (room);
767 message = get_store_message (message_store, hash);
768 }
769
770 if (! message)
771 return GNUNET_YES;
772
773 if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_YES))
774 {
776 "Unpermitted request for deletion by member (%s) of message (%s)!\n",
778 hash));
779
780 return GNUNET_NO;
781 }
782
783 {
784 struct GNUNET_MESSENGER_OperationStore *operation_store;
785
786 operation_store = get_srv_room_operation_store (room);
787
788 if (GNUNET_OK != use_store_operation (operation_store, hash,
790 {
792 "Deletion has failed: operation denied!\n");
793 return GNUNET_SYSERR;
794 }
795 }
796
797 return GNUNET_YES;
798}
799
800
803{
804 GNUNET_assert (room);
805
806 return room->service->cadet;
807}
808
809
810const struct GNUNET_HashCode*
812{
813 GNUNET_assert (room);
814
815 return &(room->key);
816}
817
818
819const struct GNUNET_MESSENGER_SrvTunnel*
821 const struct GNUNET_PeerIdentity *peer)
822{
823 GNUNET_assert ((room) && (peer));
824
826}
827
828
831 const struct GNUNET_HashCode *hash,
832 const struct GNUNET_MESSENGER_MemberSession *session,
834 void *cls)
835{
836 struct GNUNET_MESSENGER_MessageStore *message_store;
837 const struct GNUNET_MESSENGER_MessageLink *link;
838 const struct GNUNET_MESSENGER_Message *message;
839
840 GNUNET_assert ((room) && (hash) && (session));
841
842 message_store = get_srv_room_message_store (room);
843 link = get_store_message_link (message_store, hash, GNUNET_YES);
844
845 if (! link)
846 goto forward;
847
849 "Requesting link of message with hash: %s\n",
850 GNUNET_h2s (hash));
851
852 {
854 result = request_room_message_step (room, &(link->first), session,
855 callback, cls);
856
857 if ((GNUNET_YES == link->multiple) &&
858 (GNUNET_YES == request_room_message_step (room, &(link->second), session,
859 callback, cls)))
860 return GNUNET_YES;
861 else
862 return result;
863 }
864
865forward:
866 message = get_store_message (message_store, hash);
867
868 if (! message)
869 {
871 "Requested message is missing in local storage: %s\n",
872 GNUNET_h2s (hash));
873 return GNUNET_NO;
874 }
875
876 if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_NO))
878 "Unpermitted request for access by member (%s) of message (%s)!\n",
880 hash));
881 else if (callback)
882 callback (cls, room, message, hash);
883
884 return GNUNET_YES;
885}
886
887
890 const struct GNUNET_HashCode *hash,
891 const struct GNUNET_MESSENGER_MemberSession *session,
893 void *cls)
894{
896
897 GNUNET_assert ((room) && (hash));
898
899 result = request_room_message_step (room, hash, session, callback, cls);
900
901 if ((GNUNET_NO == result) && (callback))
902 callback (cls, room, NULL, hash);
903
904 return result;
905}
906
907
908static void
910{
911 struct GNUNET_MESSENGER_SrvRoom *room;
912 struct GNUNET_MESSENGER_OperationStore *operation_store;
913 const struct GNUNET_HashCode *hash;
914
915 GNUNET_assert (cls);
916
917 room = cls;
918 room->idle = NULL;
919
920 operation_store = get_srv_room_operation_store (room);
921 hash = get_message_state_merge_hash (&(room->state));
922
923 if ((hash) &&
925 hash)))
927 operation_store,
928 hash,
931 );
932
937 cls
938 );
939}
940
941
942void
944 const struct
945 GNUNET_CRYPTO_PublicKey *public_key,
946 const struct GNUNET_ShortHashCode *member_id,
948{
949 struct GNUNET_MESSENGER_MemberStore *member_store;
950 struct GNUNET_MESSENGER_Member *member;
951 struct GNUNET_MESSENGER_ListHandles *handles;
952 struct GNUNET_MESSENGER_ListHandle *element;
953
954 GNUNET_assert ((room) && (public_key) && (member_id));
955
956 member_store = get_srv_room_member_store (room);
957 member = get_store_member (member_store, member_id);
958
959 if ((! member) || (1 >= GNUNET_CONTAINER_multihashmap_size (
960 member->sessions)))
961 return;
962
963 handles = &(room->service->handles);
964
965 for (element = handles->head; element; element = element->next)
966 {
967 const struct GNUNET_CRYPTO_PublicKey *pubkey;
968 struct GNUNET_MESSENGER_MemberSession *session;
969
970 if (0 != GNUNET_memcmp (member_id, get_srv_handle_member_id (
971 element->handle, get_srv_room_key (room))))
972 continue;
973
974 pubkey = get_srv_handle_key (element->handle);
975
976 if (0 == GNUNET_memcmp (public_key, pubkey))
977 continue;
978
979 session = get_member_session (member, pubkey);
980
981 if (! session)
982 continue;
983
984 {
987
988 if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
990 continue;
991 }
992
993 {
994 struct GNUNET_ShortHashCode random_id;
995 generate_free_member_id (&random_id, member_store->members);
996
997 notify_srv_handle_member_id (element->handle, room, &random_id, GNUNET_NO);
998 }
999 }
1000}
1001
1002
1003void
1005{
1006 struct GNUNET_MESSENGER_ListTunnel *element;
1007 struct GNUNET_PeerIdentity peer;
1008 size_t count;
1009 size_t src;
1010 size_t dst;
1011
1012 GNUNET_assert (room);
1013
1014 if (GNUNET_OK != get_service_peer_identity (room->service, &peer))
1015 return;
1016
1017 count = count_of_tunnels (&(room->basement));
1018
1019 if (! find_list_tunnels (&(room->basement), &peer, &src))
1020 return;
1021
1022 if ((count > room->service->min_routers) &&
1023 (GNUNET_NO == is_srv_handle_routing (room->host, &(room->key))) &&
1025 &peer,
1027 {
1028 close_srv_room (room);
1029 return;
1030 }
1031
1032 element = room->basement.head;
1033 dst = 0;
1034
1035 while (element)
1036 {
1037 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
1038
1039 GNUNET_PEER_resolve (element->peer, &peer);
1040
1042
1043 if (! tunnel)
1044 {
1045 element = remove_from_list_tunnels (&(room->basement), element);
1046 continue;
1047 }
1048
1049 if (GNUNET_YES == required_connection_between (count, src, dst))
1050 {
1051 if (GNUNET_SYSERR == connect_tunnel (tunnel))
1052 {
1053 element = remove_from_list_tunnels (&(room->basement), element);
1054 continue;
1055 }
1056 }
1057 else
1058 disconnect_tunnel (tunnel);
1059
1060 element = element->next;
1061 dst++;
1062 }
1063}
1064
1065
1066uint32_t
1068{
1070
1072}
1073
1074
1075uint32_t
1077{
1078 uint32_t flags;
1079
1081
1083
1086
1087 return flags;
1088}
1089
1090
1091static void
1093{
1094 struct GNUNET_MESSENGER_MessageStore *message_store;
1095 struct GNUNET_MESSENGER_MemberStore *member_store;
1096 struct GNUNET_MESSENGER_PeerStore *peer_store;
1097 const struct GNUNET_HashCode *key;
1098
1099 message_store = get_srv_room_message_store (room);
1100 member_store = get_srv_room_member_store (room);
1101 peer_store = get_srv_room_peer_store (room);
1102
1103 key = get_srv_room_key (room);
1104
1106 "Handling room messages: %s\n", GNUNET_h2s (key));
1107
1108 while (room->handling.head)
1109 {
1110 struct GNUNET_MESSENGER_ListMessage *element;
1111 struct GNUNET_MESSENGER_SenderSession session;
1112 const struct GNUNET_MESSENGER_Message *message;
1113
1114 element = room->handling.head;
1115 message = get_store_message (
1116 message_store, &(element->hash));
1117
1118 if (! message)
1119 goto finish_handling;
1120
1121 if (GNUNET_YES == is_peer_message (message))
1122 {
1123 session.peer = get_store_peer_of (peer_store, message, &(element->hash));
1124
1125 if (! session.peer)
1126 goto finish_handling;
1127 }
1128 else
1129 {
1130 struct GNUNET_MESSENGER_Member *member;
1131
1132 member = get_store_member_of (member_store, message);
1133
1134 if (! member)
1135 goto finish_handling;
1136
1137 session.member = get_member_session_of (member, message,
1138 &(element->hash));
1139
1140 if (! session.member)
1141 goto finish_handling;
1142 }
1143
1144 handle_service_message (room->service, room, &session, message,
1145 &(element->hash));
1146
1147finish_handling:
1149 element);
1150 GNUNET_free (element);
1151 }
1152}
1153
1154
1157 struct GNUNET_MESSENGER_Message *message,
1158 const struct GNUNET_HashCode *hash)
1159{
1160 struct GNUNET_MESSENGER_OperationStore *operation_store;
1161 struct GNUNET_MESSENGER_MessageStore *message_store;
1162 enum GNUNET_GenericReturnValue requested;
1163
1164 GNUNET_assert ((room) && (message) && (hash));
1165
1166 operation_store = get_srv_room_operation_store (room);
1167
1168 requested = (GNUNET_MESSENGER_OP_REQUEST ==
1169 get_store_operation_type (operation_store, hash)?
1171
1172 if (GNUNET_YES == requested)
1173 cancel_store_operation (operation_store, hash);
1174
1175 message_store = get_srv_room_message_store (room);
1176
1177 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n",
1178 GNUNET_h2s (get_srv_room_key (room)));
1179
1180 if (GNUNET_YES == contains_store_message (message_store, hash))
1181 {
1182 destroy_message (message);
1183
1184 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
1185 return GNUNET_NO;
1186 }
1187
1188 if (GNUNET_OK != put_store_message (message_store, hash, message))
1189 {
1190 destroy_message (message);
1191
1192 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing message failed!\n");
1193 return GNUNET_NO;
1194 }
1195
1196 update_message_state (&(room->state), requested, message, hash);
1197
1198 if ((GNUNET_YES == requested) ||
1199 (GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
1201 return GNUNET_YES;
1202
1203 if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
1205 &(message->body.
1206 merge.previous))))
1207 cancel_store_operation (operation_store, &(message->body.merge.previous));
1208
1210 &(message->header.
1211 previous)))
1212 cancel_store_operation (operation_store, &(message->header.previous));
1213
1214 return GNUNET_YES;
1215}
1216
1217
1219{
1222};
1223
1224static enum GNUNET_GenericReturnValue
1226 const struct GNUNET_CRYPTO_PublicKey *public_key,
1227 struct GNUNET_MESSENGER_MemberSession *session)
1228{
1230 struct GNUNET_MESSENGER_Member *member;
1231 struct GNUNET_MESSENGER_Subscription *subscribtion;
1232
1233 GNUNET_assert ((cls) && (session));
1234
1235 it = cls;
1236 member = session->member;
1237
1238 subscribtion = get_member_subscription (member, it->discourse);
1239
1240 if (! subscribtion)
1241 return GNUNET_YES;
1242
1243 if (GNUNET_TIME_absolute_cmp (subscribtion->start, <, it->start))
1244 it->start = subscribtion->start;
1245
1246 return GNUNET_YES;
1247}
1248
1249void
1251 const struct GNUNET_ShortHashCode *discourse)
1252{
1254 struct GNUNET_MESSENGER_MemberStore *member_store;
1255 struct GNUNET_MESSENGER_MessageStore *message_store;
1256
1257 GNUNET_assert ((room) && (discourse));
1258
1259 it.discourse = discourse;
1261
1262 member_store = get_srv_room_member_store (room);
1263
1265
1266 message_store = get_srv_room_message_store (room);
1267
1269 discourse,
1270 it.start);
1271}
1272
1273
1275{
1278
1280};
1281
1283{
1285 const struct GNUNET_HashCode *hash;
1286
1289};
1290
1291static enum GNUNET_GenericReturnValue
1293 const struct
1294 GNUNET_CRYPTO_PublicKey *public_key,
1296{
1297 struct GNUNET_MESSENGER_MemberUpdate *update;
1298
1299 GNUNET_assert ((cls) && (session));
1300
1301 update = cls;
1302
1303 update_member_session_history (session, update->message, update->hash);
1304
1305 if (GNUNET_YES == is_member_session_completed (session))
1306 {
1308
1310 element->session = session;
1311
1312 GNUNET_CONTAINER_DLL_insert_tail (update->head, update->tail, element);
1313 }
1314
1315 return GNUNET_YES;
1316}
1317
1318
1319static void
1322
1323void
1325 const struct GNUNET_MESSENGER_Message *message,
1326 const struct GNUNET_HashCode *hash)
1327{
1328 struct GNUNET_MESSENGER_PeerStore *peer_store;
1329 struct GNUNET_MESSENGER_MemberStore *member_store;
1330 struct GNUNET_MESSENGER_SenderSession session;
1331 enum GNUNET_GenericReturnValue start_handle;
1332
1333 GNUNET_assert ((room) && (message) && (hash));
1334
1335 peer_store = get_srv_room_peer_store (room);
1336 member_store = get_srv_room_member_store (room);
1337
1338 if (GNUNET_YES == is_peer_message (message))
1339 {
1340 session.peer = get_store_peer_of (peer_store, message, hash);
1341
1342 if (! session.peer)
1343 {
1345 "Message handling dropped: Peer is missing!\n");
1346 return;
1347 }
1348 }
1349 else
1350 {
1351 struct GNUNET_MESSENGER_Member *member;
1352 member = get_store_member_of (member_store, message);
1353
1354 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n",
1355 GNUNET_h2s (hash));
1356
1357 if (! member)
1358 {
1360 "Message handling dropped: Member is missing!\n");
1361 return;
1362 }
1363
1364 session.member = get_member_session_of (member, message, hash);
1365
1366 if (! session.member)
1367 {
1369 "Message handling dropped: Session is missing!\n");
1370 return;
1371 }
1372 }
1373
1374 {
1375 struct GNUNET_MESSENGER_MemberUpdate update;
1376 update.message = message;
1377 update.hash = hash;
1378
1379 update.head = NULL;
1380 update.tail = NULL;
1381
1383
1384 while (update.head)
1385 {
1386 struct GNUNET_MESSENGER_MemberSessionCompletion *element = update.head;
1387
1388 remove_room_member_session (room, element->session);
1389
1390 GNUNET_CONTAINER_DLL_remove (update.head, update.tail, element);
1391 GNUNET_free (element);
1392 }
1393 }
1394
1395 start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
1396
1397 add_to_list_messages (&(room->handling), hash);
1398
1399 switch (message->header.kind)
1400 {
1402 handle_message_join (room, &session, message, hash);
1403 break;
1405 handle_message_leave (room, &session, message, hash);
1406 break;
1408 handle_message_key (room, &session, message, hash);
1409 break;
1411 handle_message_peer (room, &session, message, hash);
1412 break;
1414 handle_message_id (room, &session, message, hash);
1415 break;
1417 handle_message_miss (room, &session, message, hash);
1418 break;
1420 handle_message_delete (room, &session, message, hash);
1421 break;
1423 handle_message_connection (room, &session, message, hash);
1424 break;
1426 handle_message_subscribe (room, &session, message, hash);
1427 break;
1428 default:
1429 break;
1430 }
1431
1432 if (GNUNET_YES == start_handle)
1433 handle_room_messages (room);
1434}
1435
1436
1437static void
1439 char **dir)
1440{
1441 GNUNET_assert ((room) && (dir));
1442
1443 GNUNET_asprintf (dir, "%s%s%c%s%c", room->service->dir, "rooms",
1446}
1447
1448
1449void
1451{
1452 char *room_dir;
1453
1454 GNUNET_assert (room);
1455
1456 get_room_data_subdir (room, &room_dir);
1457
1458 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load room from directory: %s\n",
1459 room_dir);
1460
1462 {
1463 char *peers_file;
1464 GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
1465
1466 load_peer_store (get_srv_room_peer_store (room), peers_file);
1467 GNUNET_free (peers_file);
1468
1472
1473 {
1474 char *basement_file;
1475 GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
1476
1477 load_list_tunnels (&(room->basement), basement_file);
1478 GNUNET_free (basement_file);
1479 }
1480
1481 load_message_state (&(room->state), room_dir);
1482 }
1483
1484 GNUNET_free (room_dir);
1485}
1486
1487
1488void
1490{
1491 char *room_dir;
1492
1493 GNUNET_assert (room);
1494
1495 get_room_data_subdir (room, &room_dir);
1496
1497 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save room to directory: %s\n",
1498 room_dir);
1499
1500 if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
1502 {
1503 char *peers_file;
1504 GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
1505
1506 save_peer_store (get_srv_room_peer_store (room), peers_file);
1507 GNUNET_free (peers_file);
1508
1512
1513 {
1514 char *basement_file;
1515 GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
1516
1517 save_list_tunnels (&(room->basement), basement_file);
1518 GNUNET_free (basement_file);
1519 }
1520
1521 save_message_state (&(room->state), room_dir);
1522 }
1523
1524 GNUNET_free (room_dir);
1525}
1526
1527
1528void
1530{
1531 char *room_dir;
1532
1533 GNUNET_assert (room);
1534
1535 get_room_data_subdir (room, &room_dir);
1536
1537 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Remove room from directory: %s\n",
1538 room_dir);
1539
1542
1543 GNUNET_free (room_dir);
1544}
1545
1546
1547static void
1550{
1551 struct GNUNET_HashCode hash;
1552 char *session_dir;
1553 char *room_dir;
1554
1555 GNUNET_assert ((room) && (session));
1556
1558 "Remove member session from room: %s (%s)\n",
1560 GNUNET_h2s (get_srv_room_key (room)));
1561
1562 remove_member_session (session->member, session);
1563
1564 {
1565 const struct GNUNET_CRYPTO_PublicKey *public_key;
1566 public_key = get_member_session_public_key (session);
1567
1568 GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
1569 }
1570
1571
1572 get_room_data_subdir (room, &room_dir);
1573
1575 &session_dir, "%s%s%c%s%c%s%c%s%c", room_dir,
1576 "members", DIR_SEPARATOR,
1578 "sessions", DIR_SEPARATOR,
1579 GNUNET_h2s (&hash), DIR_SEPARATOR
1580 );
1581
1582 GNUNET_free (room_dir);
1583
1584 GNUNET_DISK_directory_remove (session_dir);
1585 GNUNET_free (session_dir);
1586
1587 destroy_member_session (session);
1588}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static int forward
Search direction: forward.
Definition: gnunet-abd.c:163
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:38
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:88
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static uint64_t timestamp(void)
Get current timestamp.
struct GNUNET_HashCode key
The key used in the DHT.
static GstElement * source
Appsrc instance into which we write data for the pipeline.
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
static int reset
Reset argument.
static char * value
Value of the record to add/remove.
static int result
Global testing status.
static void destroy_tunnel(void *cls)
This tunnel is no longer used, destroy it.
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
enum GNUNET_GenericReturnValue required_connection_between(size_t count, size_t src, size_t dst)
Returns GNUNET_YES or GNUNET_NO to determine if the peers of index src and index dst should be connec...
size_t count_of_tunnels(const struct GNUNET_MESSENGER_ListTunnels *tunnels)
Returns the count of peers in a list (typically from the basement of a room).
enum GNUNET_GenericReturnValue change_srv_handle_member_id(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK...
void notify_srv_handle_member_id(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *member_id, enum GNUNET_GenericReturnValue reset)
Notifies the handle that a new member id needs to be used.
const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the public key of a given handle.
const struct GNUNET_ShortHashCode * get_srv_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns the member id of a given handle in a specific room.
enum GNUNET_GenericReturnValue is_srv_handle_routing(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns whether a given handle has enabled routing for a room using a specific key by opening that ro...
void init_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Initializes list of message hashes as empty list.
void add_to_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash)
Adds a specific hash from a message to the end of the list.
const struct GNUNET_ShortHashCode * get_member_id(const struct GNUNET_MESSENGER_Member *member)
Returns the current id of a given member.
void remove_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Removes a given member session from its member.
struct GNUNET_MESSENGER_MemberSession * get_member_session_of(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Returns the member session of a member using a public key which can verify the signature of a given m...
struct GNUNET_MESSENGER_MemberSession * get_member_session(const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *public_key)
Returns the member session of a member identified by a given public key.
struct GNUNET_MESSENGER_Subscription * get_member_subscription(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_ShortHashCode *discourse)
Returns the active subscription of a given member to a selected discourse.
void destroy_member_session(struct GNUNET_MESSENGER_MemberSession *session)
Destroys a member session and frees its memory fully.
const struct GNUNET_CRYPTO_PublicKey * get_member_session_public_key(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the public key of a given member session.
struct GNUNET_TIME_Absolute get_member_session_start(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the timestamp of the member session's start.
void update_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Adds a given message to the history of a session using the messages hash.
const struct GNUNET_ShortHashCode * get_member_session_id(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member id of a given member session.
enum GNUNET_GenericReturnValue check_member_session_history(const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue ownership)
Checks the history of a session for a specific message which is identified by its hash and if the own...
enum GNUNET_GenericReturnValue is_member_session_completed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been completed.
struct GNUNET_MESSENGER_Member * get_store_member_of(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_MESSENGER_Message *message)
Returns the member of a store using a sender id of a given message.
int iterate_store_members(struct GNUNET_MESSENGER_MemberStore *store, GNUNET_MESSENGER_MemberIteratorCallback it, void *cls)
Iterate through all member sessions currently connected to the members of the given member store and ...
void save_member_store(struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
Saves members from a member store into a directory.
void load_member_store(struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
Loads members from a directory into a member store.
struct GNUNET_MESSENGER_Member * add_store_member(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Adds a member to a store under a specific id and returns it on success.
void init_member_store(struct GNUNET_MESSENGER_MemberStore *store, struct GNUNET_MESSENGER_SrvRoom *room)
Initializes a member store as fully empty connected to a room.
void clear_member_store(struct GNUNET_MESSENGER_MemberStore *store)
Clears a member store, wipes its content and deallocates its memory.
struct GNUNET_MESSENGER_Member * get_store_member(const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Returns the member in a store identified by a given id.
void handle_message_id(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent id message to change a members id.
void handle_message_delete(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent delete message to delete a specific message from the store.
void handle_message_peer(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent peer message to make changes of the basement in the room.
void handle_message_join(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent join message to make changes of current member information.
void handle_message_key(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent key message to change the key of a member and rearrange the contacts accor...
void handle_message_leave(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent leave message to make changes of current member information.
void handle_message_subscribe(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent subscribe message to subscribe a member to a discourse.
void handle_message_connection(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent connection message to update connection information about a peer.
void handle_message_miss(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent miss message to drop a peer from the basement in the room.
struct GNUNET_MESSENGER_Message * create_message_info(struct GNUNET_MESSENGER_Service *service)
Creates and allocates a new info message containing the hosts service peer identity and version.
struct GNUNET_MESSENGER_Message * create_message_miss(const struct GNUNET_PeerIdentity *peer)
Creates and allocates a new miss message containing the missing peer identity.
struct GNUNET_MESSENGER_Message * create_message_peer(struct GNUNET_MESSENGER_Service *service)
Creates and allocates a new peer message containing a services peer identity.
struct GNUNET_MESSENGER_Message * create_message_merge(const struct GNUNET_HashCode *previous)
Creates and allocates a new merge message containing the hash of a second previous message besides th...
void send_message_id(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent id message to update the handles member id in the room.
void send_message_request(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent request message to trigger the request operation for this service.
void send_message_join(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent join message to ensure growth of the decentralized room structure.
void send_message_key(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent key message to ensure changes to the public key of the sending handle.
void send_message_peer(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent peer message to update the rooms peer message of this service.
const struct GNUNET_HashCode * get_message_state_merge_hash(const struct GNUNET_MESSENGER_MessageState *state)
void save_message_state(const struct GNUNET_MESSENGER_MessageState *state, const char *path)
void clear_message_state(struct GNUNET_MESSENGER_MessageState *state)
void get_message_state_chain_hash(const struct GNUNET_MESSENGER_MessageState *state, struct GNUNET_HashCode *hash)
void init_message_state(struct GNUNET_MESSENGER_MessageState *state)
void update_message_state(struct GNUNET_MESSENGER_MessageState *state, enum GNUNET_GenericReturnValue requested, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
void load_message_state(struct GNUNET_MESSENGER_MessageState *state, const char *path)
enum GNUNET_GenericReturnValue contains_store_message(const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
Checks if a message matching a given hash is stored in a message store.
void save_message_store(struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
Saves messages from a message store into a directory.
enum GNUNET_GenericReturnValue put_store_message(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_Message *message)
Stores a message into the message store.
void clear_message_store(struct GNUNET_MESSENGER_MessageStore *store)
Clears a message store, wipes its content and deallocates its memory.
void init_message_store(struct GNUNET_MESSENGER_MessageStore *store)
Initializes a message store as fully empty.
void cleanup_store_discourse_messages_before(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_ShortHashCode *discourse, const struct GNUNET_TIME_Absolute timestamp)
Cleans up and deletes all discourse messages existing in the message store memory before a certain ti...
void load_message_store(struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
Loads messages from a directory into a message store.
const struct GNUNET_MESSENGER_MessageLink * get_store_message_link(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue deleted_only)
Returns the message link from a message store matching a given hash.
const struct GNUNET_MESSENGER_Message * get_store_message(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
Returns the message from a message store matching a given hash.
void cancel_store_operation(struct GNUNET_MESSENGER_OperationStore *store, const struct GNUNET_HashCode *hash)
Stops any active operation under a given hash in a specific operation store.
void save_operation_store(const struct GNUNET_MESSENGER_OperationStore *store, const char *directory)
Saves operations from an operation store into a directory.
void clear_operation_store(struct GNUNET_MESSENGER_OperationStore *store)
Clears an operation store, stops all operations and deallocates its memory.
void load_operation_store(struct GNUNET_MESSENGER_OperationStore *store, const char *directory)
Loads operations from a directory into an operation store.
enum GNUNET_MESSENGER_OperationType get_store_operation_type(const struct GNUNET_MESSENGER_OperationStore *store, const struct GNUNET_HashCode *hash)
Returns the type of the active operation under a given hash in a specific operation store.
void init_operation_store(struct GNUNET_MESSENGER_OperationStore *store, struct GNUNET_MESSENGER_SrvRoom *room)
Initializes an operation store as fully empty with a given room.
enum GNUNET_GenericReturnValue use_store_operation(struct GNUNET_MESSENGER_OperationStore *store, const struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_OperationType type, struct GNUNET_TIME_Relative delay)
Tries to use an operation under a given hash in a specific operation store.
struct GNUNET_PeerIdentity * get_store_peer_of(struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Returns the peer identity inside the store which verifies the signature of a given message as valid.
void load_peer_store(struct GNUNET_MESSENGER_PeerStore *store, const char *path)
Loads peer identities from a file into a peer store.
void clear_peer_store(struct GNUNET_MESSENGER_PeerStore *store)
Clears a peer store, wipes its content and deallocates its memory.
void save_peer_store(const struct GNUNET_MESSENGER_PeerStore *store, const char *path)
Saves peer identities from a peer store into a file.
void init_peer_store(struct GNUNET_MESSENGER_PeerStore *store, struct GNUNET_MESSENGER_Service *service)
Initializes a peer store as fully empty.
uint32_t get_srv_room_amount_of_tunnels(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the amount of active tunnels of a given room.
static enum GNUNET_GenericReturnValue request_room_message_step(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)
static enum GNUNET_GenericReturnValue iterate_destroy_tunnels(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
const struct GNUNET_MESSENGER_SrvTunnel * get_srv_room_tunnel(const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer)
Returns a tunnel inside of a room leading towards a given peer if such a tunnel exists,...
static void get_room_data_subdir(struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
static enum GNUNET_GenericReturnValue join_room(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Member *member, const struct GNUNET_ShortHashCode *id)
enum GNUNET_GenericReturnValue update_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
struct GNUNET_MESSENGER_SrvRoom * create_srv_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Creates and allocates a new room for a handle with a given key.
void save_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
Saves the configuration for a given room of a service which contains the last messages hash and the r...
void rebuild_srv_room_basement_structure(struct GNUNET_MESSENGER_SrvRoom *room)
Rebuilds the decentralized structure for a room by ensuring all required connections are made dependi...
struct GNUNET_MESSENGER_MessageStore * get_srv_room_message_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used message store of a given room.
static void * callback_room_connect(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
static enum GNUNET_GenericReturnValue send_room_info(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
static void remove_room_member_session(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session)
static enum GNUNET_GenericReturnValue iterate_member_for_subscription(void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
static enum GNUNET_GenericReturnValue join_room_locally(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
enum GNUNET_GenericReturnValue enter_srv_room_at(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door)
Connects a tunnel to a hosting peer of a room through a so called door which is represented by a peer...
struct GNUNET_MESSENGER_PeerStore * get_srv_room_peer_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used peer store of a given room.
static void idle_request_room_messages(void *cls)
void merge_srv_room_last_messages(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
Reduces all current forks inside of the message history of a room to one remaining last message by me...
struct GNUNET_MQ_Envelope * pack_srv_room_message(const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_PackMode mode)
Packs a message depending on the selected mode into a newly allocated envelope.
void check_srv_room_peer_status(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Checks the current state of opening a given room from this peer and re-publishes it if necessary to a...
void remove_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
Removes the configuration for a given room of a service.
enum GNUNET_GenericReturnValue open_srv_room(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
Tries to open a room for a given handle.
void destroy_srv_room(struct GNUNET_MESSENGER_SrvRoom *room, enum GNUNET_GenericReturnValue deletion)
Destroys a room and frees its memory fully.
static void sign_srv_room_message_by_peer(const void *cls, struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash)
void forward_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Forwards a message with a given hash to a specific tunnel inside of a room.
void cleanup_srv_room_discourse_messages(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *discourse)
Cleanup discourse messages outside of current subscriptions from a specific discourse of all the memb...
uint32_t get_srv_room_connection_flags(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns connection flags about connection information of a given room and the service managing it.
enum GNUNET_GenericReturnValue request_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)
Requests a message from a room identified by a given hash.
static void handle_room_messages(struct GNUNET_MESSENGER_SrvRoom *room)
void callback_room_handle_message(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
enum GNUNET_GenericReturnValue send_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle into a room.
struct GNUNET_MESSENGER_OperationStore * get_srv_room_operation_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used operation store of a given room.
static enum GNUNET_GenericReturnValue iterate_send_room_message(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
static void close_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
void solve_srv_room_member_collisions(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_CRYPTO_PublicKey *public_key, const struct GNUNET_ShortHashCode *member_id, struct GNUNET_TIME_Absolute timestamp)
Checks for potential collisions with member ids and solves them changing active handles ids if they u...
struct GNUNET_CADET_Handle * get_srv_room_cadet(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the CADET handle from a rooms service.
enum GNUNET_GenericReturnValue delete_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
Deletes a message from the room with a given hash in a specific delay if the provided member by its s...
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
static enum GNUNET_GenericReturnValue iterate_update_member_sessions(void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
struct GNUNET_MESSENGER_MemberStore * get_srv_room_member_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used member store of a given room.
void load_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
Loads the local configuration for a given room of a service which contains the last messages hash and...
#define GNUNET_MESSENGER_MERGE_DELAY
#define GNUNET_MESSENGER_IDLE_DELAY
void() GNUNET_MESSENGER_MessageRequestCallback(void *cls, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Method called whenever a message is found during a request in a room.
enum GNUNET_GenericReturnValue get_service_peer_identity(struct GNUNET_MESSENGER_Service *service, struct GNUNET_PeerIdentity *peer)
Tries to write the peer identity of the peer running a service on to the peer parameter.
void handle_service_message(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Sends a received or sent message with a given hash to each handle of a service which is currently mem...
void forward_tunnel_message(struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Forwards a given message with a known hash through a tunnel.
void send_tunnel_envelope(struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MQ_Envelope *env, const struct GNUNET_HashCode *hash)
Sends an envelope containing a message with a given hash through a tunnel.
enum GNUNET_GenericReturnValue is_tunnel_connected(const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Returns the status of a currently bound channel of a tunnel.
void bind_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_CADET_Channel *channel)
Binds a CADET channel to a tunnel and replaces its channel the tunnel is currently bound to if necess...
uint32_t get_tunnel_messenger_version(const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Returns the current messenger version the peer connected via a given tunnel has reported to be using ...
void callback_tunnel_disconnect(void *cls, const struct GNUNET_CADET_Channel *channel)
Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its cl...
struct GNUNET_MESSENGER_SrvTunnel * create_tunnel(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *door)
Creates and allocates a tunnel of a room to a specific peer identity (called door).
void disconnect_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Disconnects and unbinds a channel from a tunnel.
enum GNUNET_GenericReturnValue connect_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Tries to connect a tunnel by creating a new CADET channel and binding it.
enum GNUNET_GenericReturnValue send_tunnel_message(struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message)
Sends a message by packing it automatically into an envelope and passing it through the tunnel.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
static enum @44 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:954
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:801
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1063
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:426
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:519
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:44
#define GNUNET_MESSENGER_VERSION
Version number of GNUnet Messenger API.
@ GNUNET_MESSENGER_KIND_INFO
The info kind.
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
@ GNUNET_MESSENGER_KIND_SUBSCRIBE
The subscribe kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
@ GNUNET_MESSENGER_KIND_DELETE
The delete kind.
@ GNUNET_MESSENGER_KIND_CONNECTION
The connection kind.
@ GNUNET_MESSENGER_KIND_MERGE
The merge kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
@ GNUNET_MESSENGER_FLAG_CONNECTION_AUTO
The auto flag.
@ GNUNET_MESSENGER_FLAG_CONNECTION_NONE
The none flag.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1207
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1231
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_zero_(void)
Return relative time of 0ms.
Definition: time.c:133
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_forever_(void)
Return "forever".
Definition: time.c:205
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_forever_(void)
Return "forever".
Definition: time.c:196
#define GNUNET_TIME_absolute_cmp(t1, op, t2)
Compare two absolute times.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:423
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:640
void load_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path)
Loads the list of tunnels peer identities from a file under a given path.
void init_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Initializes list of tunnels peer identities as empty list.
void save_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path)
Saves the list of tunnels peer identities to a file under a given path.
enum GNUNET_GenericReturnValue verify_list_tunnels_flag_token(const struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer, enum GNUNET_MESSENGER_ConnectionFlags flag)
Verifies that a specific tunnel selected by its peer identity in a list of tunnels is the first in or...
struct GNUNET_MESSENGER_ListTunnel * find_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer, size_t *index)
Searches linearly through the list of tunnels peer identities for matching a specific peer identity a...
void clear_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Clears the list of tunnels peer identities.
struct GNUNET_MESSENGER_ListTunnel * remove_from_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, struct GNUNET_MESSENGER_ListTunnel *element)
Removes a specific element from the list of tunnels peer identities and returns the next element in t...
enum GNUNET_GenericReturnValue is_peer_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message can be sent by the service without usage of a clients priv...
struct GNUNET_MQ_Envelope * pack_message(struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, const GNUNET_MESSENGER_SignFunction sign, enum GNUNET_MESSENGER_PackMode mode, const void *cls)
Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_P...
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.
void sign_message_by_peer(struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash, const struct GNUNET_CONFIGURATION_Handle *cfg)
Signs the hash of a message with the peer identity of a given config and writes the signature into th...
GNUNET_MESSENGER_PackMode
@ GNUNET_MESSENGER_PACK_MODE_UNKNOWN
@ GNUNET_MESSENGER_PACK_MODE_ENVELOPE
enum GNUNET_GenericReturnValue generate_free_member_id(struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members)
Tries to generate an unused member id and store it into the id parameter.
void convert_messenger_key_to_port(const struct GNUNET_HashCode *key, struct GNUNET_HashCode *port)
Converts a Messenger service key of a room to the specific port which gets used for the CADET channel...
void convert_peer_identity_to_id(const struct GNUNET_PeerIdentity *identity, struct GNUNET_ShortHashCode *id)
Converts a peers identity to a short hash code which can be used as id to refer to a peer via sender ...
void delayed_disconnect_channel(struct GNUNET_CADET_Channel *channel)
Starts an urgent task to close a CADET channel asynchronously.
#define DIR_SEPARATOR
Definition: platform.h:165
Opaque handle to a channel.
Definition: cadet.h:116
Opaque handle to the service.
Definition: cadet_api.c:39
An identity key as per LSD0001.
uint32_t type
Type of signature.
A 512-bit hashcode.
struct GNUNET_MESSENGER_SrvHandle * handle
struct GNUNET_MESSENGER_Message * message
struct GNUNET_MESSENGER_SrvTunnel * exclude
struct GNUNET_MESSENGER_SrvRoom * room
struct GNUNET_MESSENGER_ListHandle * next
struct GNUNET_MESSENGER_SrvHandle * handle
struct GNUNET_MESSENGER_ListHandle * head
struct GNUNET_MESSENGER_ListMessage * head
struct GNUNET_MESSENGER_ListMessage * tail
struct GNUNET_MESSENGER_ListTunnel * next
struct GNUNET_MESSENGER_ListTunnel * head
struct GNUNET_MESSENGER_MemberSessionCompletion * prev
struct GNUNET_MESSENGER_MemberSession * session
struct GNUNET_MESSENGER_MemberSessionCompletion * next
struct GNUNET_CONTAINER_MultiShortmap * members
struct GNUNET_MESSENGER_MemberSessionCompletion * head
const struct GNUNET_MESSENGER_Message * message
struct GNUNET_MESSENGER_MemberSessionCompletion * tail
struct GNUNET_CONTAINER_MultiHashMap * sessions
struct GNUNET_MESSENGER_MessageMerge merge
struct GNUNET_HashCode previous
The hash of the previous message from the senders perspective.
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_CRYPTO_Signature signature
The signature of the senders private key.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_HashCode previous
The hash of a second previous message.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.
struct GNUNET_MESSENGER_MemberSession * member
enum GNUNET_GenericReturnValue auto_routing
struct GNUNET_CADET_Handle * cadet
struct GNUNET_MESSENGER_ListHandles handles
struct GNUNET_HashCode * peer_message
struct GNUNET_MESSENGER_PeerStore peer_store
struct GNUNET_CONTAINER_MultiPeerMap * tunnels
struct GNUNET_MESSENGER_MemberStore member_store
struct GNUNET_MESSENGER_Service * service
struct GNUNET_CADET_Port * port
struct GNUNET_MESSENGER_ListTunnels basement
struct GNUNET_SCHEDULER_Task * idle
struct GNUNET_MESSENGER_MessageStore message_store
struct GNUNET_MESSENGER_MessageState state
struct GNUNET_MESSENGER_ListMessages handling
struct GNUNET_MESSENGER_OperationStore operation_store
struct GNUNET_MESSENGER_SrvHandle * host
struct GNUNET_CADET_Channel * channel
struct GNUNET_MESSENGER_SrvRoom * room
Message handler for a specific message type.
Header for all communications.
The identity of the host (wraps the signing key of the peer).
A 256-bit hashcode.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.