GNUnet 0.21.1
gnunet-service-messenger_member.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
30
31#include "messenger_api_util.h"
32
35 const struct GNUNET_ShortHashCode *id)
36{
38
39 struct GNUNET_MESSENGER_Member *member = GNUNET_new (struct
41
42 member->store = store;
43
44 if (id)
45 GNUNET_memcpy (&(member->id), id, sizeof(member->id));
46 else if (GNUNET_YES != generate_free_member_id (&(member->id),
47 store->members))
48 {
49 GNUNET_free (member);
50 return NULL;
51 }
52
54
55 return member;
56}
57
58
61 const struct GNUNET_HashCode *key,
62 void *value)
63{
64 struct GNUNET_MESSENGER_MemberSession *session = value;
65 destroy_member_session (session);
66 return GNUNET_YES;
67}
68
69
70void
72{
74
78
80}
81
82
83const struct GNUNET_ShortHashCode*
85{
86 GNUNET_assert (member);
87
88 return &(member->id);
89}
90
91
94 const char *filename)
95{
96 struct GNUNET_MESSENGER_Member *member = cls;
97
99 {
100 char *directory;
101
102 GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR);
103
104 load_member_session (member, directory);
105 GNUNET_free (directory);
106 }
107
108 return GNUNET_OK;
109}
110
111
112void
114 const char *directory)
115{
116 GNUNET_assert ((store) && (directory));
117
118 char *config_file;
119 GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg");
120
121 struct GNUNET_MESSENGER_Member *member = NULL;
122
124 goto free_config;
125
126 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load member configuration: %s\n",
128
130
132 {
134
135 if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "member", "id", &id,
136 sizeof(id)))
137 goto destroy_config;
138
139 member = add_store_member (store, &id);
140 }
141
142destroy_config:
143
145
146free_config:
148
149 if (! member)
150 return;
151
152 char *scan_dir;
153 GNUNET_asprintf (&scan_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
154
157
159}
160
161
164 const struct GNUNET_HashCode *key,
165 void *value)
166{
167 const char *sessions_directory = cls;
168
169 char *load_dir;
170 GNUNET_asprintf (&load_dir, "%s%s%c", sessions_directory, GNUNET_h2s (key),
172
173 struct GNUNET_MESSENGER_MemberSession *session = value;
174
176 load_member_session_next (session, load_dir);
177
178 GNUNET_free (load_dir);
179 return GNUNET_YES;
180}
181
182
183void
185 const char *directory)
186{
187 GNUNET_assert ((member) && (directory));
188
189 char *load_dir;
190 GNUNET_asprintf (&load_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
191
193 iterate_load_next_session, load_dir);
194
195 GNUNET_free (load_dir);
196}
197
198
201 const struct GNUNET_HashCode *key,
202 void *value)
203{
204 const char *sessions_directory = cls;
205
206 char *save_dir;
207 GNUNET_asprintf (&save_dir, "%s%s%c", sessions_directory, GNUNET_h2s (key),
209
210 struct GNUNET_MESSENGER_MemberSession *session = value;
211
212 if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
214 save_member_session (session, save_dir);
215
216 GNUNET_free (save_dir);
217 return GNUNET_YES;
218}
219
220
221void
223 const char *directory)
224{
225 GNUNET_assert ((member) && (directory));
226
227 char *config_file;
228 GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg");
229
230 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save member configuration: %s\n",
232
234
235 char *id_data = GNUNET_STRINGS_data_to_string_alloc (&(member->id),
236 sizeof(member->id));
237
238 if (id_data)
239 {
240 GNUNET_CONFIGURATION_set_value_string (cfg, "member", "id", id_data);
241
242 GNUNET_free (id_data);
243 }
244
247
249
250 char *save_dir;
251 GNUNET_asprintf (&save_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
252
253 if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
256 iterate_save_session, save_dir);
257
258 GNUNET_free (save_dir);
259}
260
261
262static void
265{
266 GNUNET_assert ((session) && (next));
267
268 if (session == next)
269 return;
270
271 if (next->next)
272 sync_session_contact_from_next (session, next->next);
273 else
274 session->contact = next->contact;
275}
276
277
280 const struct GNUNET_HashCode *key,
281 void *value)
282{
283 struct GNUNET_MESSENGER_MemberSession *session = value;
284
285 if (session->next)
286 sync_session_contact_from_next (session, session->next);
287
288 return GNUNET_YES;
289}
290
291
292void
294{
296
299}
300
301
305{
307
308 struct GNUNET_HashCode hash;
309 GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
310
311 return GNUNET_CONTAINER_multihashmap_get (member->sessions, &hash);
312}
313
314
316{
318 const struct GNUNET_HashCode *hash;
319
321};
322
325 const struct GNUNET_HashCode *key,
326 void *value)
327{
328 struct GNUNET_MESSENGER_ClosureSearchSession *search = cls;
329 struct GNUNET_MESSENGER_MemberSession *session = value;
330
331 if (GNUNET_OK != verify_member_session_as_sender (session, search->message,
332 search->hash))
333 return GNUNET_YES;
334
335 search->match = session;
336 return GNUNET_NO;
337}
338
339
343{
345 public_key);
346
347 if (session)
348 return session;
349
351
352 if (session)
353 add_member_session (member, session);
354
355 return session;
356}
357
358
361 const struct GNUNET_MESSENGER_Message *message,
362 const struct GNUNET_HashCode *hash)
363{
364 GNUNET_assert ((member) && (message) && (hash) &&
365 (0 == GNUNET_memcmp (&(member->id),
366 &(message->header.sender_id))));
367
368 if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind)
369 return try_member_session (member, &(message->body.join.key));
370
372
373 search.message = message;
374 search.hash = hash;
375
376 search.match = NULL;
378 iterate_search_session, &search);
379
380 return search.match;
381}
382
383
384void
386 struct GNUNET_MESSENGER_MemberSession *session)
387{
388 if (! session)
389 return;
390
391 GNUNET_assert ((member) && (session->member == member));
392
393 const struct GNUNET_CRYPTO_PublicKey *public_key =
395
396 struct GNUNET_HashCode hash;
397 GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
398
400 member->sessions, &hash, session,
403 "Adding a member session failed: %s\n",
404 GNUNET_h2s (&hash));
405}
406
407
408void
410 struct GNUNET_MESSENGER_MemberSession *session)
411{
412 GNUNET_assert ((member) && (session) && (session->member == member));
413
414 const struct GNUNET_CRYPTO_PublicKey *public_key =
416
417 struct GNUNET_HashCode hash;
418 GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
419
421 &hash, session))
423 "Removing a member session failed: %s\n",
424 GNUNET_h2s (&hash));
425}
426
427
429{
431 void *cls;
432};
433
436 const struct GNUNET_HashCode *key,
437 void *value)
438{
440 struct GNUNET_MESSENGER_MemberSession *session = value;
441
442 return iterate->it (iterate->cls, get_member_session_public_key (session),
443 session);
444}
445
446
447int
450 void *cls)
451{
452 GNUNET_assert ((member) && (member->sessions) && (it));
453
455
456 iterate.it = it;
457 iterate.cls = cls;
458
461 &iterate);
462}
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
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 char * filename
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
static char * value
Value of the record to add/remove.
static enum GNUNET_GenericReturnValue iterate_member_sessions_it(void *cls, const struct GNUNET_HashCode *key, void *value)
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...
static void sync_session_contact_from_next(struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
static struct GNUNET_MESSENGER_MemberSession * try_member_session(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *public_key)
void save_member(struct GNUNET_MESSENGER_Member *member, const char *directory)
Saves data from a member into a directory which can be load to restore the member completely.
static enum GNUNET_GenericReturnValue iterate_sync_session_contact(void *cls, const struct GNUNET_HashCode *key, void *value)
void destroy_member(struct GNUNET_MESSENGER_Member *member)
Destroys a member and frees its memory fully.
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.
static enum GNUNET_GenericReturnValue iterate_destroy_session(void *cls, const struct GNUNET_HashCode *key, void *value)
struct GNUNET_MESSENGER_Member * create_member(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Creates and allocates a new member of a room with an optionally defined or random id.
void load_member_next_sessions(const struct GNUNET_MESSENGER_Member *member, const char *directory)
Loads data about next sessions from a directory into an empty loaded member which does not contain a ...
static enum GNUNET_GenericReturnValue iterate_load_next_session(void *cls, const struct GNUNET_HashCode *key, void *value)
void add_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Adds a given member session to its member.
void sync_member_contacts(struct GNUNET_MESSENGER_Member *member)
Synchronizes contacts between all sessions from a given member and other sessions which are linked to...
int iterate_member_sessions(struct GNUNET_MESSENGER_Member *member, GNUNET_MESSENGER_MemberIteratorCallback it, void *cls)
Iterate through all member sessions currently connected to a given member and call the provided itera...
void load_member(struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
Loads data from a directory into a new allocated and created member of a store if the required inform...
static enum GNUNET_GenericReturnValue callback_scan_for_sessions(void *cls, const char *filename)
static enum GNUNET_GenericReturnValue iterate_search_session(void *cls, const struct GNUNET_HashCode *key, void *value)
static enum GNUNET_GenericReturnValue iterate_save_session(void *cls, const struct GNUNET_HashCode *key, void *value)
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.
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 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.
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.
enum GNUNET_GenericReturnValue(* GNUNET_MESSENGER_MemberIteratorCallback)(void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
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.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
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.
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
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:403
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:496
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814
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
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_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
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.
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,...)
#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_OK
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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_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_JOIN
The join 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
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.
#define DIR_SEPARATOR
Definition: platform.h:165
An identity key as per LSD0001.
A 512-bit hashcode.
GNUNET_MESSENGER_MemberIteratorCallback it
const struct GNUNET_MESSENGER_Message * message
struct GNUNET_MESSENGER_MemberSession * match
struct GNUNET_MESSENGER_MemberSession * next
struct GNUNET_CONTAINER_MultiShortmap * members
struct GNUNET_CONTAINER_MultiHashMap * sessions
struct GNUNET_MESSENGER_MemberStore * store
struct GNUNET_ShortHashCode id
struct GNUNET_MESSENGER_MessageJoin join
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_CRYPTO_PublicKey key
The senders public key to verify its signatures.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.
A 256-bit hashcode.