GNUnet 0.21.0
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
160 session->member->store);
161
162 if ((session->contact) && (GNUNET_YES == decrease_contact_rc (
163 session->contact)))
165 store,
166 session->contact,
168 );
169
170 session->contact = NULL;
171 }
172}
173
174
177 const struct GNUNET_HashCode *key,
178 void *value)
179{
181
184
185 return GNUNET_YES;
186}
187
188
191 const struct GNUNET_MESSENGER_Message *message,
192 const struct GNUNET_HashCode *hash)
193{
194 if ((! session) || (! message) || (! hash))
195 return NULL;
196
199
202
203 if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
205 &(message->body.id.id));
206 else
207 next->member = session->member;
208
209 if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
210 GNUNET_memcpy (&(next->public_key), &(message->body.key.key),
211 sizeof(next->public_key));
212 else
214 sizeof(next->public_key));
215
219 &(next->context)
220 );
221
228 );
229
231
232 if (! (next->contact))
233 {
235 return NULL;
236 }
237
239
242 );
243
245 next);
246
248 copy_list_messages (&(next->messages), &(session->messages));
249
250 session->next = next;
251 next->prev = session;
252 next->next = NULL;
253
255
256 session->closed = GNUNET_YES;
259
261
262 return next;
263}
264
265
266void
268{
269 GNUNET_assert (session);
270
272
273 clear_list_messages (&(session->messages));
274
276 session);
277
278 if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
281 contact,
283 );
284
285 GNUNET_free (session);
286}
287
288
291 const struct GNUNET_HashCode *hash)
292{
293 GNUNET_assert ((session) && (hash));
294
296 session->member->store);
298 store,
301 );
302
303 if (! contact)
304 return GNUNET_SYSERR;
305
306 if (contact == session->contact)
307 goto clear_messages;
308
309 session->contact = contact;
310 increase_contact_rc (session->contact);
311
312clear_messages:
313 clear_list_messages (&(session->messages));
314 add_to_list_messages (&(session->messages), hash);
315
316 session->next = NULL;
317 session->closed = GNUNET_NO;
318 session->completed = GNUNET_NO;
319
320 return GNUNET_OK;
321}
322
323
324void
326{
327 GNUNET_assert (session);
328
329 session->closed = GNUNET_YES;
331}
332
333
336{
337 GNUNET_assert (session);
338
339 return session->closed;
340}
341
342
346{
347 GNUNET_assert (session);
348
349 return session->completed;
350}
351
352
355{
356 GNUNET_assert (session);
357
358 if (session->prev)
359 return get_member_session_start (session->prev);
360
361 return session->start;
362}
363
364
365const struct GNUNET_HashCode*
367{
368 GNUNET_assert ((session) && (session->member));
369
370 return get_member_store_key (session->member->store);
371}
372
373
374const struct GNUNET_ShortHashCode*
376{
377 GNUNET_assert (session);
378
379 return get_member_id (session->member);
380}
381
382
383const struct GNUNET_CRYPTO_PublicKey*
386{
387 GNUNET_assert (session);
388
389 return &(session->public_key);
390}
391
392
393const struct GNUNET_HashCode*
396{
397 GNUNET_assert (session);
398
399 return &(session->context);
400}
401
402
405{
406 GNUNET_assert (session);
407
408 return session->contact;
409}
410
411
415 const struct GNUNET_MESSENGER_Message *message,
416 const struct GNUNET_HashCode *hash)
417{
418 GNUNET_assert ((session) && (message) && (hash));
419
421 return GNUNET_SYSERR;
422
423 if (0 != GNUNET_memcmp (get_member_session_id (session),
424 &(message->header.sender_id)))
425 return GNUNET_SYSERR;
426
427 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using key: %s\n",
428 GNUNET_h2s (hash),
431
432 return verify_message (message, hash, get_member_session_public_key (
433 session));
434}
435
436
440 const struct GNUNET_HashCode *hash,
441 enum GNUNET_GenericReturnValue ownership)
442{
443 GNUNET_assert ((session) && (hash));
444
445 if (GNUNET_YES == ownership)
446 return (NULL != GNUNET_CONTAINER_multihashmap_get (session->history, hash)?
448 else
449 return GNUNET_CONTAINER_multihashmap_contains (session->history, hash);
450}
451
452
453static void
455 const struct GNUNET_HashCode *hash,
456 enum GNUNET_GenericReturnValue ownership)
457{
458 GNUNET_assert ((session) && (hash));
459
461 (GNUNET_YES == ownership?
462 session : NULL),
464 && (session->next))
465 update_member_chain_history (session->next, hash, ownership);
466}
467
468
469void
471 const struct GNUNET_MESSENGER_Message *message,
472 const struct GNUNET_HashCode *hash)
473{
474 GNUNET_assert ((session) && (message) && (hash));
475
477 return;
478
480 "Updating sessions history (%s) += (%s)\n",
481 GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (hash));
482
483 if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
484 {
485 if (GNUNET_YES == is_message_session_bound (message))
486 add_to_list_messages (&(session->messages), hash);
487
489 }
490 else
491 update_member_chain_history (session, hash, GNUNET_NO);
492
493 if (GNUNET_YES == session->closed)
495}
496
497
498static void
500 const struct GNUNET_HashCode *hash)
501{
502 GNUNET_assert ((session) && (hash));
503
504 if ((0 < GNUNET_CONTAINER_multihashmap_remove_all (session->history, hash)) &&
505 (session->next))
506 clear_member_session_history (session->next, hash);
507}
508
509
510void
512 const struct GNUNET_HashCode *hash)
513{
514 GNUNET_assert ((session) && (hash));
515
516 clear_member_chain_history (session, hash);
517}
518
519
521{
523 unsigned char ownership;
524};
525
526static void
528 const char *path)
529{
530 GNUNET_assert ((session) && (path));
531
532 if (GNUNET_YES != GNUNET_DISK_file_test (path))
533 return;
534
537
539 path, GNUNET_DISK_OPEN_READ, permission
540 );
541
542 if (! handle)
543 return;
544
546
548 ssize_t len;
549
551
552 do {
553 len = GNUNET_DISK_file_read (handle, &(entry.hash), sizeof(entry.hash));
554
555 if (len != sizeof(entry.hash))
556 break;
557
558 len = GNUNET_DISK_file_read (handle, &(entry.ownership),
559 sizeof(entry.ownership));
560
561 if (len != sizeof(entry.ownership))
562 break;
563
565 (entry.ownership? session :
566 NULL),
568 } while (status == GNUNET_OK);
569
571}
572
573
574void
576 const char *directory)
577{
578 GNUNET_assert ((member) && (directory));
579
580 char *config_file;
581 GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
582
583 struct GNUNET_MESSENGER_MemberSession *session = NULL;
584
586 goto free_config;
587
589 "Load session configuration of member: %s\n", config_file);
590
592
594 {
595 char *key_data;
596
598 "key", &key_data))
599 goto destroy_config;
600
602
603 enum GNUNET_GenericReturnValue key_return =
605
606 GNUNET_free (key_data);
607
608 if (GNUNET_OK != key_return)
609 goto destroy_config;
610
611 session = create_member_session (member, &key);
612
613 unsigned long long numeric_value;
614
616 "start",
617 &numeric_value))
618 session->start.abs_value_us = numeric_value;
619
621 "closed",
622 &numeric_value))
623 session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
624
626 "completed",
627 &numeric_value))
628 session->completed = (GNUNET_YES == numeric_value? GNUNET_YES :
629 GNUNET_NO);
630 }
631
632destroy_config:
634
635free_config:
637
638 if (! session)
639 return;
640
641 char *history_file;
642 GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
643
644 load_member_session_history (session, history_file);
645 GNUNET_free (history_file);
646
647 char *messages_file;
648 GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
649
650 load_list_messages (&(session->messages), messages_file);
651 GNUNET_free (messages_file);
652
653 add_member_session (member, session);
654}
655
656
660{
661 if (! next)
662 return NULL;
663
664 struct GNUNET_MESSENGER_MemberSession *check = next;
665
666 do {
667 if (check == session)
668 return NULL;
669
670 check = check->next;
671 } while (check);
672
673 return next;
674}
675
676
677void
679 const char *directory)
680{
681 GNUNET_assert ((session) && (directory));
682
683 char *config_file;
684 GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
685
687 goto free_config;
688
690 "Load next session configuration of member: %s\n", config_file);
691
693
695 {
696 char *key_data;
697
699 "next_key",
700 &key_data))
701 goto destroy_config;
702
703 struct GNUNET_CRYPTO_PublicKey next_key;
704
705 enum GNUNET_GenericReturnValue key_return =
706 GNUNET_CRYPTO_public_key_from_string (key_data, &next_key);
707
708 GNUNET_free (key_data);
709
710 if (GNUNET_OK != key_return)
711 goto destroy_config;
712
714
715 if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id",
716 &next_id, sizeof(next_id)))
717 goto destroy_config;
718
720 session->member->store, &next_id);
721
723 session, member? get_member_session (member, &next_key) : NULL
724 );
725
726 if (session->next)
727 session->next->prev = session;
728 }
729
730destroy_config:
732
733free_config:
735}
736
737
740 const struct GNUNET_HashCode *key,
741 void *value)
742{
743 struct GNUNET_DISK_FileHandle *handle = cls;
744 unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
745
747 GNUNET_DISK_file_write (handle, &ownership, sizeof(ownership));
748
749 return GNUNET_YES;
750}
751
752
753static void
755 const char *path)
756{
757 GNUNET_assert ((session) && (path));
758
761
764 );
765
766 if (! handle)
767 return;
768
770
772 session->history,
774 handle
775 );
776
779}
780
781
782void
784 const char *directory)
785{
786 GNUNET_assert ((session) && (directory));
787
788 char *config_file;
789 GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
790
792 "Save session configuration of member: %s\n", config_file);
793
795
796 char *key_data = GNUNET_CRYPTO_public_key_to_string (
798
799 if (key_data)
800 {
801 GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
802
803 GNUNET_free (key_data);
804 }
805
806 if (session->next)
807 {
809 session->next);
810
811 char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id,
812 sizeof(*next_id));
813
814 if (next_id_data)
815 {
816 GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id",
817 next_id_data);
818
819 GNUNET_free (next_id_data);
820 }
821
824
825 if (key_data)
826 {
827 GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key",
828 key_data);
829
830 GNUNET_free (key_data);
831 }
832 }
833
834 GNUNET_CONFIGURATION_set_value_number (cfg, "session", "start",
835 session->start.abs_value_us);
836
837 GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed",
838 session->closed);
839 GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed",
840 session->completed);
841
844
846
847 char *history_file;
848 GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
849
850 save_member_session_history (session, history_file);
851 GNUNET_free (history_file);
852
853 char *messages_file;
854 GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
855
856 save_list_messages (&(session->messages), messages_file);
857 GNUNET_free (messages_file);
858}
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:38
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.
unsigned int GNUNET_CONTAINER_multihashmap_clear(struct GNUNET_CONTAINER_MultiHashMap *map)
Remove all entries from the 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:551
#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:571
@ 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.