GNUnet 0.21.2
gnunet-service-messenger_member_session.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2021--2023 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 */
27
30
32
35 const struct GNUNET_CRYPTO_PublicKey *pubkey)
36{
37 if ((! member) || (! pubkey) || (! (member->store)))
38 return NULL;
39
40 struct GNUNET_MESSENGER_MemberSession *session = GNUNET_new (struct
42 session->member = member;
43
44 GNUNET_memcpy (&(session->public_key), pubkey, sizeof(session->public_key));
45
47 get_member_session_key (session),
48 get_member_session_id (session),
49 &(session->context)
50 );
51
53 session->member->store);
54
55 session->contact = get_store_contact (
56 store,
59 );
60
61 if (! (session->contact))
62 {
63 GNUNET_free (session);
64 return NULL;
65 }
66
68
70
71 init_list_messages (&(session->messages));
72
73 session->prev = NULL;
74 session->next = NULL;
75
76 session->start = GNUNET_TIME_absolute_get ();
77
78 session->closed = GNUNET_NO;
79 session->completed = GNUNET_NO;
80
81 return session;
82}
83
84
85static void
87{
88 GNUNET_assert (session);
89
91 "Check session history (%s) for completion.\n",
93
94 if (! session->messages.tail)
95 {
96 session->completed = GNUNET_YES;
97 goto completion;
98 }
99
100 const struct GNUNET_HashCode *start = &(session->messages.head->hash);
101 const struct GNUNET_HashCode *end = &(session->messages.tail->hash);
102
104 init_list_messages (&level);
105
106 add_to_list_messages (&level, end);
107
109 session->member->store->room);
110
113
114 while (level.head)
115 {
116 struct GNUNET_MESSENGER_ListMessage *element;
117
118 for (element = level.head; element; element = element->next)
119 {
121 store, &(element->hash), GNUNET_NO
122 );
123
124 if (! link)
125 continue;
126
127 add_to_list_messages (&list, &(link->first));
128
129 if (GNUNET_YES == link->multiple)
130 add_to_list_messages (&list, &(link->second));
131 }
132
133 clear_list_messages (&level);
134
135 for (element = list.head; element; element = element->next)
136 if (GNUNET_YES == check_member_session_history (session, &(element->hash),
137 GNUNET_YES))
138 break;
139
140 if (element)
141 if (0 != GNUNET_CRYPTO_hash_cmp (&(element->hash), start))
142 add_to_list_messages (&level, &(element->hash));
143 else
144 session->completed = GNUNET_YES;
145 else
146 copy_list_messages (&level, &list);
147
149 }
150
151completion:
153 {
154 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
156
158 session->member->store);
159
160 if ((session->contact) && (GNUNET_YES == decrease_contact_rc (
161 session->contact)))
163 store,
164 session->contact,
166 );
167
168 session->contact = NULL;
169 }
170}
171
172
175 const struct GNUNET_HashCode *key,
176 void *value)
177{
179
182
183 return GNUNET_YES;
184}
185
186
189 const struct GNUNET_MESSENGER_Message *message,
190 const struct GNUNET_HashCode *hash)
191{
192 if ((! session) || (! message) || (! hash))
193 return NULL;
194
197
200
201 if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
203 &(message->body.id.id));
204 else
205 next->member = session->member;
206
207 if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
208 GNUNET_memcpy (&(next->public_key), &(message->body.key.key),
209 sizeof(next->public_key));
210 else
212 sizeof(next->public_key));
213
217 &(next->context)
218 );
219
226 );
227
229
230 if (! (next->contact))
231 {
233 return NULL;
234 }
235
237
240 );
241
243 next);
244
246 copy_list_messages (&(next->messages), &(session->messages));
247
248 session->next = next;
249 next->prev = session;
250 next->next = NULL;
251
253
254 session->closed = GNUNET_YES;
257
259
260 return next;
261}
262
263
264void
266{
267 GNUNET_assert (session);
268
270
271 clear_list_messages (&(session->messages));
272
274 session);
275
276 if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
279 contact,
281 );
282
283 GNUNET_free (session);
284}
285
286
289 const struct GNUNET_HashCode *hash)
290{
291 GNUNET_assert ((session) && (hash));
292
294 session->member->store);
296 store,
299 );
300
301 if (! contact)
302 return GNUNET_SYSERR;
303
304 if (contact == session->contact)
305 goto clear_messages;
306
307 session->contact = contact;
308 increase_contact_rc (session->contact);
309
310clear_messages:
311 clear_list_messages (&(session->messages));
312 add_to_list_messages (&(session->messages), hash);
313
314 session->next = NULL;
315 session->closed = GNUNET_NO;
316 session->completed = GNUNET_NO;
317
318 return GNUNET_OK;
319}
320
321
322void
324{
325 GNUNET_assert (session);
326
327 session->closed = GNUNET_YES;
329}
330
331
334{
335 GNUNET_assert (session);
336
337 return session->closed;
338}
339
340
344{
345 GNUNET_assert (session);
346
347 return session->completed;
348}
349
350
353{
354 GNUNET_assert (session);
355
356 if (session->prev)
357 return get_member_session_start (session->prev);
358
359 return session->start;
360}
361
362
363const struct GNUNET_HashCode*
365{
366 GNUNET_assert ((session) && (session->member));
367
368 return get_member_store_key (session->member->store);
369}
370
371
372const struct GNUNET_ShortHashCode*
374{
375 GNUNET_assert (session);
376
377 return get_member_id (session->member);
378}
379
380
381const struct GNUNET_CRYPTO_PublicKey*
384{
385 GNUNET_assert (session);
386
387 return &(session->public_key);
388}
389
390
391const struct GNUNET_HashCode*
394{
395 GNUNET_assert (session);
396
397 return &(session->context);
398}
399
400
403{
404 GNUNET_assert (session);
405
406 return session->contact;
407}
408
409
413 const struct GNUNET_MESSENGER_Message *message,
414 const struct GNUNET_HashCode *hash)
415{
416 GNUNET_assert ((session) && (message) && (hash));
417
419 {
420 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using history!\n",
421 GNUNET_h2s (hash));
422
423 if (GNUNET_YES == check_member_session_history (session, hash, GNUNET_YES))
424 return GNUNET_OK;
425 else
426 return GNUNET_SYSERR;
427 }
428
429 if (0 != GNUNET_memcmp (get_member_session_id (session),
430 &(message->header.sender_id)))
431 return GNUNET_SYSERR;
432
433 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using key: %s\n",
434 GNUNET_h2s (hash),
437
438 return verify_message (message, hash, get_member_session_public_key (
439 session));
440}
441
442
446 const struct GNUNET_HashCode *hash,
447 enum GNUNET_GenericReturnValue ownership)
448{
449 GNUNET_assert ((session) && (hash));
450
451 if (GNUNET_YES == ownership)
452 return (NULL != GNUNET_CONTAINER_multihashmap_get (session->history, hash)?
454 else
455 return GNUNET_CONTAINER_multihashmap_contains (session->history, hash);
456}
457
458
459static void
461 const struct GNUNET_HashCode *hash,
462 enum GNUNET_GenericReturnValue ownership)
463{
464 GNUNET_assert ((session) && (hash));
465
467 (GNUNET_YES == ownership?
468 session : NULL),
470 && (session->next))
471 update_member_chain_history (session->next, hash, ownership);
472}
473
474
475void
477 const struct GNUNET_MESSENGER_Message *message,
478 const struct GNUNET_HashCode *hash)
479{
480 GNUNET_assert ((session) && (message) && (hash));
481
483 return;
484
486 "Updating sessions history (%s) += (%s)\n",
487 GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (hash));
488
489 if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
490 {
491 if (GNUNET_YES == is_message_session_bound (message))
492 add_to_list_messages (&(session->messages), hash);
493
495 }
496 else
497 update_member_chain_history (session, hash, GNUNET_NO);
498
499 if (GNUNET_YES == session->closed)
501}
502
503
504static void
506 const struct GNUNET_HashCode *hash)
507{
508 GNUNET_assert ((session) && (hash));
509
510 if ((0 < GNUNET_CONTAINER_multihashmap_remove_all (session->history, hash)) &&
511 (session->next))
512 clear_member_session_history (session->next, hash);
513}
514
515
516void
518 const struct GNUNET_HashCode *hash)
519{
520 GNUNET_assert ((session) && (hash));
521
522 clear_member_chain_history (session, hash);
523}
524
525
527{
529 unsigned char ownership;
530};
531
532static void
534 const char *path)
535{
536 GNUNET_assert ((session) && (path));
537
538 if (GNUNET_YES != GNUNET_DISK_file_test (path))
539 return;
540
543 );
544
546 path, GNUNET_DISK_OPEN_READ, permission
547 );
548
549 if (! handle)
550 return;
551
553
555 ssize_t len;
556
558
559 do {
560 len = GNUNET_DISK_file_read (handle, &(entry.hash), sizeof(entry.hash));
561
562 if (len != sizeof(entry.hash))
563 break;
564
565 len = GNUNET_DISK_file_read (handle, &(entry.ownership),
566 sizeof(entry.ownership));
567
568 if (len != sizeof(entry.ownership))
569 break;
570
572 (entry.ownership? session :
573 NULL),
575 } while (status == GNUNET_OK);
576
578}
579
580
581void
583 const char *directory)
584{
585 GNUNET_assert ((member) && (directory));
586
587 char *config_file;
588 GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
589
590 struct GNUNET_MESSENGER_MemberSession *session = NULL;
591
593 goto free_config;
594
596 "Load session configuration of member: %s\n", config_file);
597
599
601 {
602 char *key_data;
603
605 "key", &key_data))
606 goto destroy_config;
607
609
610 enum GNUNET_GenericReturnValue key_return =
612
613 GNUNET_free (key_data);
614
615 if (GNUNET_OK != key_return)
616 goto destroy_config;
617
618 session = create_member_session (member, &key);
619
620 unsigned long long numeric_value;
621
623 "start",
624 &numeric_value))
625 session->start.abs_value_us = numeric_value;
626
628 "closed",
629 &numeric_value))
630 session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
631
633 "completed",
634 &numeric_value))
635 session->completed = (GNUNET_YES == numeric_value? GNUNET_YES :
636 GNUNET_NO);
637 }
638
639destroy_config:
641
642free_config:
644
645 if (! session)
646 return;
647
648 char *history_file;
649 GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
650
651 load_member_session_history (session, history_file);
652 GNUNET_free (history_file);
653
654 char *messages_file;
655 GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
656
657 load_list_messages (&(session->messages), messages_file);
658 GNUNET_free (messages_file);
659
660 add_member_session (member, session);
661}
662
663
667{
668 if (! next)
669 return NULL;
670
671 struct GNUNET_MESSENGER_MemberSession *check = next;
672
673 do {
674 if (check == session)
675 return NULL;
676
677 check = check->next;
678 } while (check);
679
680 return next;
681}
682
683
684void
686 const char *directory)
687{
688 GNUNET_assert ((session) && (directory));
689
690 char *config_file;
691 GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
692
694 goto free_config;
695
697 "Load next session configuration of member: %s\n", config_file);
698
700
702 {
703 char *key_data;
704
706 "next_key",
707 &key_data))
708 goto destroy_config;
709
710 struct GNUNET_CRYPTO_PublicKey next_key;
711
712 enum GNUNET_GenericReturnValue key_return =
713 GNUNET_CRYPTO_public_key_from_string (key_data, &next_key);
714
715 GNUNET_free (key_data);
716
717 if (GNUNET_OK != key_return)
718 goto destroy_config;
719
721
722 if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id",
723 &next_id, sizeof(next_id)))
724 goto destroy_config;
725
727 session->member->store, &next_id);
728
730 session, member? get_member_session (member, &next_key) : NULL
731 );
732
733 if (session->next)
734 session->next->prev = session;
735 }
736
737destroy_config:
739
740free_config:
742}
743
744
747 const struct GNUNET_HashCode *key,
748 void *value)
749{
750 struct GNUNET_DISK_FileHandle *handle = cls;
751 unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
752
754 GNUNET_DISK_file_write (handle, &ownership, sizeof(ownership));
755
756 return GNUNET_YES;
757}
758
759
760static void
762 const char *path)
763{
764 GNUNET_assert ((session) && (path));
765
768 );
769
772 );
773
774 if (! handle)
775 return;
776
778
780 session->history,
782 handle
783 );
784
787}
788
789
790void
792 const char *directory)
793{
794 GNUNET_assert ((session) && (directory));
795
796 char *config_file;
797 GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
798
800 "Save session configuration of member: %s\n", config_file);
801
803
804 char *key_data = GNUNET_CRYPTO_public_key_to_string (
806
807 if (key_data)
808 {
809 GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
810
811 GNUNET_free (key_data);
812 }
813
814 if (session->next)
815 {
817 session->next);
818
819 char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id,
820 sizeof(*next_id));
821
822 if (next_id_data)
823 {
824 GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id",
825 next_id_data);
826
827 GNUNET_free (next_id_data);
828 }
829
832
833 if (key_data)
834 {
835 GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key",
836 key_data);
837
838 GNUNET_free (key_data);
839 }
840 }
841
842 GNUNET_CONFIGURATION_set_value_number (cfg, "session", "start",
843 session->start.abs_value_us);
844
845 GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed",
846 session->closed);
847 GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed",
848 session->completed);
849
852
854
855 char *history_file;
856 GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
857
858 save_member_session_history (session, history_file);
859 GNUNET_free (history_file);
860
861 char *messages_file;
862 GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
863
864 save_list_messages (&(session->messages), messages_file);
865 GNUNET_free (messages_file);
866}
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
static char * value
Value of the record to add/remove.
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
void clear_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Clears the list of message hashes.
void load_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
Loads the list of message hashes from a file under a given path.
void init_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Initializes list of message hashes as empty list.
void copy_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_MESSENGER_ListMessages *origin)
Copies all message hashes from an origin to another list.
void save_list_messages(const struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
Saves the list of message hashes to a file under a given path.
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.
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.
void add_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Adds a given member session to its member.
void clear_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
Removes a message from the history of a session using the messages hash.
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.
static void clear_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
void load_member_session_next(struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
Loads the connection from one session to another through the next attribute.
void close_member_session(struct GNUNET_MESSENGER_MemberSession *session)
Closes a given member session which opens the request for completion of the 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.
static void update_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue ownership)
static void load_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
static enum GNUNET_GenericReturnValue iterate_save_member_session_history_hentries(void *cls, const struct GNUNET_HashCode *key, void *value)
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 reset_member_session(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
Resets a given member session which re-opens a member session for new usage.
static void check_member_session_completion(struct GNUNET_MESSENGER_MemberSession *session)
const struct GNUNET_HashCode * get_member_session_key(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the key of the room a given member session belongs to.
static enum GNUNET_GenericReturnValue iterate_copy_history(void *cls, const struct GNUNET_HashCode *key, void *value)
struct GNUNET_MESSENGER_Contact * get_member_session_contact(struct GNUNET_MESSENGER_MemberSession *session)
Returns the contact which is connected to a given member session.
struct GNUNET_MESSENGER_MemberSession * switch_member_session(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Creates and allocates a new member session closing and replacing a given other session of the same me...
void load_member_session(struct GNUNET_MESSENGER_Member *member, const char *directory)
Loads data from a directory into a new allocated and created member session of a member if the requir...
void save_member_session(struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
Saves data from a member session into a directory which can be load to restore the member session com...
struct GNUNET_MESSENGER_MemberSession * create_member_session(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *pubkey)
Creates and allocates a new member session of a member with a given public key.
enum GNUNET_GenericReturnValue verify_member_session_as_sender(const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Verifies a given member session as sender of a selected message and its hash.
static void save_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
enum GNUNET_GenericReturnValue is_member_session_completed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been completed.
enum GNUNET_GenericReturnValue is_member_session_closed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been closed.
static struct GNUNET_MESSENGER_MemberSession * get_cycle_safe_next_session(struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
const struct GNUNET_HashCode * get_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member context of a given member session.
struct GNUNET_MESSENGER_ContactStore * get_member_contact_store(struct GNUNET_MESSENGER_MemberStore *store)
Returns the used contact store of a given member store.
const struct GNUNET_HashCode * get_member_store_key(const struct GNUNET_MESSENGER_MemberStore *store)
Returns the shared secret you need to access a room of the 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.
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.
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.
struct GNUNET_MESSENGER_MessageStore * get_srv_room_message_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used message store of a given room.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_data(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, void *buf, size_t buf_size)
Get Crockford32-encoded fixed-size binary data from a configuration.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
void GNUNET_CONFIGURATION_set_value_number(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long number)
Set a configuration value that should be a number.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Parse a configuration file, add all of the options in the file to the configuration environment.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1237
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:686
off_t GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, enum GNUNET_DISK_Seek whence)
Move the read/write pointer in a file.
Definition: disk.c:205
GNUNET_DISK_AccessPermissions
File access permissions, UNIX-style.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
Write file changes to disk.
Definition: disk.c:1427
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1308
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:622
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_SEEK_SET
Seek an absolute position (from the start of the file).
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:221
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
int GNUNET_CONTAINER_multihashmap_remove_all(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Remove all entries for the given key from the map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair 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.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
#define GNUNET_log(kind,...)
char * GNUNET_CRYPTO_public_key_to_string(const struct GNUNET_CRYPTO_PublicKey *key)
Creates a (Base32) string representation of the public key.
Definition: crypto_pkey.c:568
#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.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_public_key_from_string(const char *str, struct GNUNET_CRYPTO_PublicKey *key)
Parses a (Base32) string representation of the public key.
Definition: crypto_pkey.c:588
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#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_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.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:764
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
enum GNUNET_GenericReturnValue decrease_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Decreases the reference counter if possible (can not underflow!) of a given contact and returns GNUNE...
void increase_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Increases the reference counter of a given contact which is zero as default.
void get_context_from_member(const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *id, struct GNUNET_HashCode *context)
Calculates the context hash of a member in a room and returns it.
void update_store_contact(struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact *contact, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *next_context, const struct GNUNET_CRYPTO_PublicKey *pubkey)
Moves a contact from the store to another location matching a given public key and member context.
struct GNUNET_MESSENGER_Contact * get_store_contact(struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context, const struct GNUNET_CRYPTO_PublicKey *pubkey)
Returns a contact using a specific public key.
void remove_store_contact(struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact *contact, const struct GNUNET_HashCode *context)
Removes a contact from the store which uses a given member context.
enum GNUNET_GenericReturnValue verify_message(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_PublicKey *key)
Verifies the signature of a given message and its hash with a specific public key.
enum GNUNET_GenericReturnValue is_message_session_bound(const struct GNUNET_MESSENGER_Message *message)
Returns if the message should be bound to a member session.
An identity key as per LSD0001.
Handle used to access files (and pipes).
A 512-bit hashcode.
struct GNUNET_MESSENGER_ListMessage * next
struct GNUNET_MESSENGER_ListMessage * head
struct GNUNET_MESSENGER_ListMessage * tail
struct GNUNET_CONTAINER_MultiHashMap * history
struct GNUNET_MESSENGER_MemberSession * prev
struct GNUNET_MESSENGER_MemberSession * next
struct GNUNET_MESSENGER_ListMessages messages
struct GNUNET_MESSENGER_MemberStore * store
struct GNUNET_MESSENGER_MessageId id
struct GNUNET_MESSENGER_MessageKey key
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_ShortHashCode id
The new id which will replace the senders id in a room.
struct GNUNET_CRYPTO_PublicKey key
The new public key which replaces the current senders public key.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.
A 256-bit hashcode.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.