GNUnet 0.21.1
gnunet-service-messenger_service.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 */
27
30
31#include "gnunet_common.h"
32#include "messenger_api_util.h"
33
34static void
36{
38
39 if (service)
40 {
41 service->shutdown = NULL;
42
44 }
45}
46
47
50 struct GNUNET_SERVICE_Handle *service_handle)
51{
52 GNUNET_assert ((config) && (service_handle));
53
56
57 service->config = config;
58 service->service = service_handle;
59
61 service);
62
63 service->peer = NULL;
64 service->dir = NULL;
65
68 "MESSENGER_DIR",
69 &(service->dir)))
70 {
71 if (service->dir)
72 GNUNET_free (service->dir);
73
74 service->dir = NULL;
75 }
76 else
77 {
80 !=
82 {
83 GNUNET_free (service->dir);
84
85 service->dir = NULL;
86 }
87 }
88
90 service->config,
92 "MESSENGER_AUTO_CONNECTING");
93
96 "MESSENGER_AUTO_ROUTING");
97
100 "MESSENGER_MIN_ROUTERS",
101 &(service->min_routers)))
102 service->min_routers = 0;
103
104 service->cadet = GNUNET_CADET_connect (service->config);
105
106 init_list_handles (&(service->handles));
107
109
111
112 return service;
113}
114
115
118 const struct GNUNET_HashCode *key,
119 void *value)
120{
121 struct GNUNET_MESSENGER_SrvRoom *room = value;
123 return GNUNET_YES;
124}
125
126
127void
129{
131
132 if (service->shutdown)
133 {
135
136 service->shutdown = NULL;
137 }
138
139 clear_list_handles (&(service->handles));
140
142 NULL);
144
146
147 if (service->cadet)
148 {
150
151 service->cadet = NULL;
152 }
153
154 if (service->dir)
155 {
156 GNUNET_free (service->dir);
157
158 service->dir = NULL;
159 }
160
161 if (service->peer)
162 {
163 GNUNET_free (service->peer);
164
165 service->peer = NULL;
166 }
167
169
171}
172
173
176{
178
179 return &(service->contact_store);
180}
181
182
185 struct GNUNET_MQ_Handle *mq)
186{
187 GNUNET_assert ((service) && (mq));
188
190
191 if (handle)
192 {
193 add_list_handle (&(service->handles), handle);
194 }
195
196 return handle;
197}
198
199
200void
203{
205
206 if (! handle)
207 return;
208
209 if (GNUNET_YES == remove_list_handle (&(service->handles), handle))
211}
212
213
216 struct GNUNET_PeerIdentity *peer)
217{
218 GNUNET_assert ((service) && (peer));
219
220 if (service->peer)
221 {
222 GNUNET_memcpy (peer, service->peer, sizeof(struct GNUNET_PeerIdentity));
223 return GNUNET_OK;
224 }
225
228
229 if (GNUNET_OK != result)
230 return result;
231
232 if (! service->peer)
233 service->peer = GNUNET_new (struct GNUNET_PeerIdentity);
234
235 GNUNET_memcpy (service->peer, peer, sizeof(struct GNUNET_PeerIdentity));
236 return result;
237}
238
239
242 const struct GNUNET_HashCode *key)
243{
244 GNUNET_assert ((service) && (key));
245
247}
248
249
251{
255};
256
259 const struct GNUNET_CRYPTO_PublicKey *public_key,
260 struct GNUNET_MESSENGER_MemberSession *session)
261{
262 struct HandleInitializationClosure *init = cls;
263
264 if (! public_key)
265 return GNUNET_YES;
266
268 init->handle);
269
270 if (0 != GNUNET_memcmp (pubkey, public_key))
271 return GNUNET_YES;
272
273 const struct GNUNET_ShortHashCode *id = get_member_session_id (session);
274
275 if (! id)
276 {
277 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialitation: Missing member id!");
278 return GNUNET_NO;
279 }
280
282 "Initialitation: Matching member found (%s)!\n",
283 GNUNET_sh2s (id));
284
286 return GNUNET_NO;
287}
288
289
290static void
292 struct GNUNET_MESSENGER_SrvRoom *room)
293{
294 GNUNET_assert ((handle) && (room));
295
297 if (! store)
298 return;
299
301 if ((! pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key ())))
302 return;
303
305 "Initialize member id of handle via matching member in room!\n");
306
308 init.handle = handle;
309 init.room = room;
310 init.pubkey = pubkey;
311
313}
314
315
319 const struct GNUNET_HashCode *key)
320{
321 GNUNET_assert ((service) && (handle) && (key));
322
324
325 if (room)
326 {
328 return open_srv_room (room, handle);
329 }
330
331 room = create_srv_room (handle, key);
333
334 if ((GNUNET_YES == open_srv_room (room, handle)) &&
336 key, room,
338 return GNUNET_YES;
339
341 return GNUNET_NO;
342}
343
344
348 const struct GNUNET_PeerIdentity *door,
349 const struct GNUNET_HashCode *key)
350{
351 GNUNET_assert ((service) && (handle) && (door) && (key));
352
354
355 if (room)
356 {
358
359 if (GNUNET_YES == enter_srv_room_at (room, handle, door))
360 return GNUNET_YES;
361 else
362 return GNUNET_NO;
363 }
364
365 room = create_srv_room (handle, key);
367
368 if ((GNUNET_YES == enter_srv_room_at (room, handle, door)) &&
370 key, room,
372 {
373 return GNUNET_YES;
374 }
375 else
376 {
378 return GNUNET_NO;
379 }
380
381}
382
383
387 const struct GNUNET_HashCode *key,
388 enum GNUNET_GenericReturnValue deletion)
389{
390 GNUNET_assert ((service) && (handle) && (key));
391
393
394 if (! room)
395 return GNUNET_NO;
396
397 struct GNUNET_ShortHashCode *id = (struct GNUNET_ShortHashCode*) (
399
400 GNUNET_assert (id);
401
403 key, id))
404 return GNUNET_NO;
405
406 GNUNET_free (id);
407
408 struct GNUNET_MESSENGER_SrvHandle *member_handle = (struct
410 *)
412 &(service->handles), key);
413
414 if (! member_handle)
415 {
417 room))
418 {
419 destroy_srv_room (room, deletion);
420 return GNUNET_YES;
421 }
422 else
423 return GNUNET_NO;
424 }
425
426 if (room->host == handle)
427 {
428 room->host = member_handle;
429
430 if (room->peer_message)
432 room));
433 }
434
435 return GNUNET_YES;
436}
437
438
439void
441 struct GNUNET_MESSENGER_SrvRoom *room,
442 const struct GNUNET_MESSENGER_SenderSession *session,
443 const struct GNUNET_MESSENGER_Message *message,
444 const struct GNUNET_HashCode *hash)
445{
446 GNUNET_assert ((service) && (room) && (session) && (message) && (hash));
447
448 struct GNUNET_MESSENGER_ListHandle *element = service->handles.head;
449
450 while (element)
451 {
452 notify_srv_handle_message (element->handle, room, session, message, hash,
453 GNUNET_YES);
454 element = element->next;
455 }
456}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
struct GNUNET_HashCode key
The key used in the DHT.
const struct GNUNET_CONFIGURATION_Handle * config
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 result
Global testing status.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
struct GNUNET_MESSENGER_SrvHandle * create_srv_handle(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
Creates and allocates a new handle related to a service and using a given mq (message queue).
void notify_srv_handle_message(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue recent)
Notifies the handle that a new message was received or sent.
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...
const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the public key of a given handle.
void destroy_srv_handle(struct GNUNET_MESSENGER_SrvHandle *handle)
Destroys a handle and frees its memory fully.
struct GNUNET_MESSENGER_SrvHandle * find_list_handle_by_member(const struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key)
Searches linearly through the list of handles for members of a specific room which is identified by a...
void add_list_handle(struct GNUNET_MESSENGER_ListHandles *handles, struct GNUNET_MESSENGER_SrvHandle *handle)
Adds a specific handle to the end of the list.
void init_list_handles(struct GNUNET_MESSENGER_ListHandles *handles)
Initializes list of handles as empty list.
enum GNUNET_GenericReturnValue remove_list_handle(struct GNUNET_MESSENGER_ListHandles *handles, struct GNUNET_MESSENGER_SrvHandle *handle)
Removes the first entry matching with a specific handle from the list of handles and returns GNUNET_Y...
void clear_list_handles(struct GNUNET_MESSENGER_ListHandles *handles)
Destroys remaining handles and clears the list.
const struct GNUNET_ShortHashCode * get_member_session_id(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member id of a given member session.
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 ...
struct GNUNET_MESSENGER_Message * create_message_connection(const struct GNUNET_MESSENGER_SrvRoom *room)
Creates and allocates a new connection message containing the amount of the peer's connections in a g...
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.
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...
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.
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.
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
struct GNUNET_MESSENGER_MemberStore * get_srv_room_member_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used member store of a given room.
void remove_service_handle(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle)
Removes a handle from a service and destroys it.
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.
struct GNUNET_MESSENGER_ContactStore * get_service_contact_store(struct GNUNET_MESSENGER_Service *service)
Returns the used contact store of a given service.
void destroy_service(struct GNUNET_MESSENGER_Service *service)
Destroys a service and frees its memory fully.
static void initialize_service_handle(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room)
enum GNUNET_GenericReturnValue entry_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Tries to enter a room using a given key for a service by a specific handle.
enum GNUNET_GenericReturnValue close_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, enum GNUNET_GenericReturnValue deletion)
Tries to close a room using a given key for a service by a specific handle.
static void callback_shutdown_service(void *cls)
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...
static enum GNUNET_GenericReturnValue find_member_session_in_room(void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
struct GNUNET_MESSENGER_SrvHandle * add_service_handle(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
Creates and adds a new handle to a service using a given message queue.
struct GNUNET_MESSENGER_SrvRoom * get_service_room(const struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
Returns the room identified by a given key for a service.
static enum GNUNET_GenericReturnValue iterate_destroy_rooms(void *cls, const struct GNUNET_HashCode *key, void *value)
struct GNUNET_MESSENGER_Service * create_service(const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_SERVICE_Handle *service_handle)
Creates and allocates a new service using a given config and a GNUnet service handle.
enum GNUNET_GenericReturnValue open_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Tries to open a room using a given key for a service by a specific handle.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:894
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *dst)
Retrieve the identity of the host's peer.
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_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_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_MESSENGER_SERVICE_NAME
Identifier of GNUnet MESSENGER Service.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1340
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
void GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh)
Explicitly stops the service.
Definition: service.c:2548
void clear_contact_store(struct GNUNET_MESSENGER_ContactStore *store)
Clears a contact store, wipes its content and deallocates its memory.
void init_contact_store(struct GNUNET_MESSENGER_ContactStore *store)
Initializes a contact store as fully empty.
const struct GNUNET_CRYPTO_PublicKey * get_anonymous_public_key()
Returns the public identity key of GNUNET_IDENTITY_ego_get_anonymous() without recalculating it every...
An identity key as per LSD0001.
A 512-bit hashcode.
struct GNUNET_MESSENGER_ListHandle * next
struct GNUNET_MESSENGER_SrvHandle * handle
struct GNUNET_HashCode * peer_message
struct GNUNET_MESSENGER_SrvHandle * host
Handle to a message queue.
Definition: mq.c:87
The identity of the host (wraps the signing key of the peer).
Handle to a service.
Definition: service.c:118
A 256-bit hashcode.
struct GNUNET_MESSENGER_SrvHandle * handle
const struct GNUNET_CRYPTO_PublicKey * pubkey
struct GNUNET_MESSENGER_SrvRoom * room