GNUnet debian-0.24.3-23-g589b01d60
gnunet-service-messenger_handle.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2020--2025 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
32
33#include "messenger_api_util.h"
34
36{
39};
40
43 struct GNUNET_MQ_Handle *mq)
44{
46
47 GNUNET_assert ((service) && (mq));
48
50
51 handle->service = service;
52 handle->mq = mq;
53
57
58 handle->notify = NULL;
59
60 return handle;
61}
62
63
66 const struct GNUNET_HashCode *key,
67 void *value)
68{
70
71 GNUNET_assert ((cls) && (key));
72
73 handle = cls;
74
76 return GNUNET_YES;
77}
78
79
82 const struct GNUNET_HashCode *key,
83 void *value)
84{
86
88 return GNUNET_YES;
89}
90
91
92void
94{
96
99
100 if (handle->notify)
102
104 iterate_free_values, NULL);
106 iterate_free_values, NULL);
107
111
113}
114
115
116void
118 const struct GNUNET_CRYPTO_PublicKey *key)
119{
121
122 if ((handle->key) && (! key))
123 {
124 GNUNET_free (handle->key);
125 handle->key = NULL;
126 }
127 else if (! handle->key)
129
130 if (key)
131 memcpy (handle->key, key, sizeof(struct GNUNET_CRYPTO_PublicKey));
132}
133
134
135const struct GNUNET_CRYPTO_PublicKey*
137{
139
140 return handle->key;
141}
142
143
144void
146 const char *name,
147 char **dir)
148{
149 GNUNET_assert ((handle) && (dir));
150
151 if (name)
152 GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
154 else
155 GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
157}
158
159
162 const struct GNUNET_HashCode *key)
163{
164 struct GNUNET_ShortHashCode *random_id;
165
166 GNUNET_assert ((handle) && (key));
167
168 random_id = GNUNET_new (struct GNUNET_ShortHashCode);
169
170 if (! random_id)
171 return GNUNET_NO;
172
173 generate_free_member_id (random_id, NULL);
174
176 random_id,
178 {
179 GNUNET_free (random_id);
180 return GNUNET_NO;
181 }
182
184 "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (
185 random_id),
186 GNUNET_h2s (key));
187
188 return GNUNET_YES;
189}
190
191
192const struct GNUNET_ShortHashCode*
194 const struct GNUNET_HashCode *key)
195{
196 GNUNET_assert ((handle) && (key));
197
198 return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
199}
200
201
204 const struct GNUNET_HashCode *key,
205 const struct GNUNET_ShortHashCode *unique_id)
206{
207 struct GNUNET_ShortHashCode *member_id;
208
209 GNUNET_assert ((handle) && (key) && (unique_id));
210
211 member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
212
213 if (! member_id)
214 {
215 member_id = GNUNET_new (struct GNUNET_ShortHashCode);
216 GNUNET_memcpy (member_id, unique_id, sizeof(*member_id));
217
219 member_id,
221 {
222 GNUNET_free (member_id);
223 return GNUNET_SYSERR;
224 }
225 }
226
227 if (0 == GNUNET_memcmp (unique_id, member_id))
228 return GNUNET_OK;
229
231 "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (
232 member_id),
233 GNUNET_h2s (key));
234
235 GNUNET_memcpy (member_id, unique_id, sizeof(*unique_id));
236
237 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Member id changed to (%s).\n",
238 GNUNET_sh2s (unique_id));
239 return GNUNET_OK;
240}
241
242
245 const struct GNUNET_HashCode *key)
246{
247 GNUNET_assert ((handle) && (key));
248
250 handle->routing, key, NULL,
252 return GNUNET_NO;
253
256 key)))
257 return GNUNET_NO;
258
259 return open_service_room (handle->service, handle, key);
260}
261
262
265 const struct GNUNET_PeerIdentity *door,
266 const struct GNUNET_HashCode *key)
267{
268 GNUNET_assert ((handle) && (door) && (key));
269
272 handle, key)))
273 return GNUNET_NO;
274
275 return entry_service_room (handle->service, handle, door, key);
276}
277
278
281 const struct GNUNET_HashCode *key)
282{
283 GNUNET_assert ((handle) && (key));
284
286 iterate_free_values, NULL);
288
289 if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
290 handle->next_ids)))
291 {
293 handle->notify = NULL;
294 }
295
297 return GNUNET_NO;
298
299 {
302
303 if (GNUNET_YES != result)
304 return result;
305
307 return result;
308 }
309}
310
311
314 const struct GNUNET_HashCode *key)
315{
316 GNUNET_assert ((handle) && (key));
317
319}
320
321
322void
324 const struct GNUNET_HashCode *key,
325 const struct GNUNET_HashCode *prev,
326 struct GNUNET_HashCode *hash,
327 struct GNUNET_HashCode *epoch)
328{
329 struct GNUNET_MESSENGER_SrvRoom *room;
330 struct GNUNET_MESSENGER_MessageStore *store;
331
332 GNUNET_assert ((handle) && (key) && (prev) && (hash) && (epoch));
333
334 room = get_service_room (handle->service, key);
335
336 if ((! room) || (! get_srv_handle_member_id (handle, key)))
337 {
338 GNUNET_memcpy (hash, prev, sizeof(*hash));
339 goto sync_epoch;
340 }
341
343 get_message_state_chain_hash (&(room->state), hash);
344
345sync_epoch:
346 if (! room)
347 {
348 GNUNET_memcpy (epoch, hash, sizeof(*epoch));
349 return;
350 }
351
352 store = get_srv_room_message_store (room);
353
354 if (! store)
355 return;
356
357 GNUNET_memcpy (epoch, get_store_message_epoch (store, hash),
358 sizeof(*epoch));
359}
360
361
364 const struct GNUNET_HashCode *key,
365 const struct GNUNET_MESSENGER_Message *message)
366{
367 const struct GNUNET_ShortHashCode *id;
368 struct GNUNET_MESSENGER_SrvRoom *room;
369
370 GNUNET_assert ((handle) && (key) && (message));
371
373
374 if (! id)
375 {
377 "It is required to be a member of a room to send messages!\n");
378 return GNUNET_NO;
379 }
380
381 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
382 GNUNET_sh2s (id));
383
384 if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
385 {
387 "Member id does not match with handle!\n");
388 return GNUNET_NO;
389 }
390
391 room = get_service_room (handle->service, key);
392
393 if (! room)
394 {
395 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
396 GNUNET_h2s (key));
397 return GNUNET_NO;
398 }
399
400 {
402 msg = copy_message (message);
403
404 if (! msg)
405 {
406 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Copying message failed!\n");
407 return GNUNET_NO;
408 }
409
410 return send_srv_room_message (room, handle, msg);
411 }
412}
413
414
415static const struct GNUNET_HashCode*
418{
419 GNUNET_assert (session);
420
421 if (session->next)
422 return get_next_member_session_context (session->next);
423 else
424 return get_member_session_context (session);
425}
426
427
428static const struct GNUNET_MESSENGER_MemberSession*
430 struct GNUNET_MESSENGER_SrvRoom *room,
431 const struct GNUNET_HashCode *key)
432{
433 const struct GNUNET_ShortHashCode *id;
434 const struct GNUNET_CRYPTO_PublicKey *pubkey;
435
436 GNUNET_assert ((handle) && (room) && (key) && (handle->service));
437
439
440 if (! id)
441 {
443 "Handle is missing a member id for its member session! (%s)\n",
444 GNUNET_h2s (key));
445 return NULL;
446 }
447
449
450 if (! pubkey)
451 {
453 "Handle is missing a public key for its member session! (%s)\n",
454 GNUNET_h2s (key));
455 return NULL;
456 }
457
458 {
459 struct GNUNET_MESSENGER_MemberStore *store;
460 struct GNUNET_MESSENGER_Member *member;
461
463 member = get_store_member (store, id);
464
465 return get_member_session (member, pubkey);
466 }
467}
468
469
470void
472 struct GNUNET_MESSENGER_SrvRoom *room,
473 const struct GNUNET_MESSENGER_SenderSession *session,
474 const struct GNUNET_MESSENGER_Message *message,
475 const struct GNUNET_HashCode *hash,
476 const struct GNUNET_HashCode *epoch,
477 enum GNUNET_GenericReturnValue recent)
478{
479 const struct GNUNET_HashCode *key;
480 const struct GNUNET_ShortHashCode *id;
481 const struct GNUNET_HashCode *context;
483 const struct GNUNET_ShortHashCode *discourse;
484 struct GNUNET_MESSENGER_Subscription *subscription;
485 struct GNUNET_HashCode sender;
486
487 GNUNET_assert ((handle) && (room) && (session) && (message) && (hash) && (
488 epoch));
489
490 key = get_srv_room_key (room);
492
493 if (! handle->mq)
494 {
496 "Notifying client is missing a message queue!\n");
497 return;
498 }
499 else if (! id)
500 {
502 "Notifying client about message requires membership!\n");
503 return;
504 }
505
506 context = NULL;
507
508 if (GNUNET_MESSENGER_KIND_TALK != message->header.kind)
509 goto skip_message_filter;
510
512 discourse = &(message->body.talk.discourse);
513
514 {
515 struct GNUNET_MESSENGER_MemberStore *member_store;
516 struct GNUNET_MESSENGER_Member *member;
517
518 member_store = get_srv_room_member_store (room);
519
520 if (! member_store)
521 return;
522
523 member = get_store_member (member_store, id);
524
525 if (! member)
526 return;
527
528 subscription = get_member_subscription (member, discourse);
529 }
530
531 if ((! subscription) ||
533 {
535 "Dropping message for client outside of subscription: %s\n",
536 GNUNET_h2s (hash));
537 return;
538 }
539
540skip_message_filter:
541 if (GNUNET_YES == is_peer_message (message))
542 {
543 const struct GNUNET_PeerIdentity *identity = session->peer;
544 GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
545
546 context = &sender;
547 }
548 else
549 {
550 const struct GNUNET_CRYPTO_PublicKey *pubkey;
552 GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
553
555 }
556
558 "Notifying client about message: %s (%s)\n",
560 message->header.kind));
561
562 {
564 struct GNUNET_MQ_Envelope *env;
565 uint16_t length;
566 char *buffer;
567
568 length = get_message_size (message, GNUNET_YES);
569
570 env = GNUNET_MQ_msg_extra (msg, length,
572
573 GNUNET_memcpy (&(msg->key), key, sizeof(msg->key));
574 GNUNET_memcpy (&(msg->sender), &sender, sizeof(msg->sender));
575 GNUNET_memcpy (&(msg->context), context, sizeof(msg->context));
576 GNUNET_memcpy (&(msg->hash), hash, sizeof(msg->hash));
577 GNUNET_memcpy (&(msg->epoch), epoch, sizeof(msg->epoch));
578
579 msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
580
581 if (GNUNET_YES == is_peer_message (message))
582 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
583 else if (get_handle_member_session (handle, room, key) == session->member)
584 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
585
586 if (GNUNET_YES == recent)
587 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_RECENT;
588
589 buffer = ((char*) msg) + sizeof(*msg);
590 encode_message (message, length, buffer, GNUNET_YES);
591
593 }
594}
595
596
599 const struct GNUNET_HashCode *key,
600 void *value)
601{
604
605 GNUNET_assert ((cls) && (value));
606
607 handle = cls;
608 next = value;
609
611 "Notifying client about next member id: %s (%s)\n",
612 GNUNET_sh2s (&(next->id)), GNUNET_h2s (key));
613
614 {
616 struct GNUNET_MQ_Envelope *env;
617
620
621 GNUNET_memcpy (&(msg->key), key, sizeof(*key));
622 GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
623 msg->reset = (uint32_t) next->reset;
624
626 }
627
629 return GNUNET_YES;
630}
631
632
633static void
635{
637
638 GNUNET_assert (cls);
639
640 handle = cls;
641 handle->notify = NULL;
642
646}
647
648
649void
651 struct GNUNET_MESSENGER_SrvRoom *room,
652 const struct GNUNET_ShortHashCode *member_id,
654{
657 const struct GNUNET_HashCode *key;
658
659 GNUNET_assert ((handle) && (room) && (member_id));
660
662 key = get_srv_room_key (room);
663
664 if (! next)
665 {
667 "Allocation of next member id failed: %s (%s)\n",
668 GNUNET_sh2s (member_id), GNUNET_h2s (key));
669 return;
670 }
671
672 GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
673 next->reset = reset;
674
675 prev = GNUNET_CONTAINER_multihashmap_get (handle->next_ids, key);
676
678 next,
680 {
682 "Update of next member id failed: %s (%s)\n",
683 GNUNET_sh2s (member_id), GNUNET_h2s (key));
684 return;
685 }
686
687 if (prev)
688 GNUNET_free (prev);
689
690 if (! handle->notify)
692 handle);
693}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:88
static uint64_t timestamp(void)
Get current timestamp.
struct GNUNET_HashCode key
The key used in the DHT.
static pa_context * context
Pulseaudio context.
static char * name
Name (label) of the records to list.
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
static int reset
Reset argument.
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
static char * value
Value of the record to add/remove.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static int result
Global testing status.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
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, const struct GNUNET_HashCode *epoch, enum GNUNET_GenericReturnValue recent)
Notifies the handle that a new message was received or sent.
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).
static const struct GNUNET_HashCode * get_next_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
static enum GNUNET_GenericReturnValue iterate_free_values(void *cls, const struct GNUNET_HashCode *key, void *value)
void set_srv_handle_key(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_CRYPTO_PublicKey *key)
Sets the public key of a given handle.
enum GNUNET_GenericReturnValue change_srv_handle_member_id(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK...
void sync_srv_handle_messages(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_HashCode *prev, struct GNUNET_HashCode *hash, struct GNUNET_HashCode *epoch)
Returns the latest merged hash from a room of a given handle using a specific key and the handles own...
enum GNUNET_GenericReturnValue close_srv_handle_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Removes the membership of the room using a specific key and closes it if no other handle from this se...
enum GNUNET_GenericReturnValue send_srv_handle_message(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle to the room using a specific key.
void notify_srv_handle_member_id(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *member_id, enum GNUNET_GenericReturnValue reset)
Notifies the handle that a new member id needs to be used.
static void task_notify_srv_handle_member_id(void *cls)
static enum GNUNET_GenericReturnValue iterate_close_rooms(void *cls, const struct GNUNET_HashCode *key, void *value)
enum GNUNET_GenericReturnValue entry_srv_handle_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Makes a given handle a member of the room using a specific key and enters the room through a tunnel t...
static enum GNUNET_GenericReturnValue iterate_next_member_ids(void *cls, const struct GNUNET_HashCode *key, void *value)
const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the public key of a given handle.
static const struct GNUNET_MESSENGER_MemberSession * get_handle_member_session(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *key)
const struct GNUNET_ShortHashCode * get_srv_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns the member id of a given handle in a specific room.
static enum GNUNET_GenericReturnValue create_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
enum GNUNET_GenericReturnValue is_srv_handle_routing(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns whether a given handle has enabled routing for a room using a specific key by opening that ro...
void get_srv_handle_data_subdir(const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
Writes the path of the directory for a given handle using a specific name to the parameter dir.
void destroy_srv_handle(struct GNUNET_MESSENGER_SrvHandle *handle)
Destroys a handle and frees its memory fully.
enum GNUNET_GenericReturnValue open_srv_handle_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Makes a given handle a member of the room using a specific key and opens the room from the handles se...
struct GNUNET_MESSENGER_MemberSession * get_member_session(const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *public_key)
Returns the member session of a member identified by a given public key.
struct GNUNET_MESSENGER_Subscription * get_member_subscription(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_ShortHashCode *discourse)
Returns the active subscription of a given member to a selected discourse.
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.
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_Member * get_store_member(const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Returns the member in a store identified by a given id.
void get_message_state_chain_hash(const struct GNUNET_MESSENGER_MessageState *state, struct GNUNET_HashCode *hash)
const struct GNUNET_HashCode * get_store_message_epoch(const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
Returns the epoch hash of a message 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.
void merge_srv_room_last_messages(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
Reduces all current forks inside of the message history of a room to one remaining last message by me...
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.
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.
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.
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.
enum GNUNET_GenericReturnValue has_subscription_of_timestamp(const struct GNUNET_MESSENGER_Subscription *subscription, struct GNUNET_TIME_Absolute timestamp)
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
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
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.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE
If a value with the given key exists, replace it.
#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
@ 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_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:46
@ GNUNET_MESSENGER_KIND_TALK
The talk kind.
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
@ GNUNET_MESSENGER_FLAG_PEER
The peer flag.
@ GNUNET_MESSENGER_FLAG_RECENT
The recent flag.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:305
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:61
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:76
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1304
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:741
void encode_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, enum GNUNET_GenericReturnValue include_header)
Encodes a given message into a buffer of a maximal length in bytes.
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
enum GNUNET_GenericReturnValue is_peer_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message can be sent by the service without usage of a clients priv...
uint16_t get_message_size(const struct GNUNET_MESSENGER_Message *message, enum GNUNET_GenericReturnValue include_header)
Returns the exact size in bytes to encode a given message.
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:166
An identity key as per LSD0001.
A 512-bit hashcode.
Message to receive the current member id of a handle in room.
struct GNUNET_MESSENGER_MemberSession * next
struct GNUNET_MESSENGER_MemberStore * store
struct GNUNET_MESSENGER_MessageTalk talk
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_ShortHashCode discourse
The hash of the discourse to talk.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.
enum GNUNET_GenericReturnValue reset
Message to receive something from a room.
struct GNUNET_MESSENGER_MemberSession * member
struct GNUNET_MESSENGER_MessageState state
struct GNUNET_MQ_Envelope * next
Messages are stored in a linked list.
Definition: mq.c:39
Handle to a message queue.
Definition: mq.c:87
The identity of the host (wraps the signing key of the peer).
A 256-bit hashcode.
Time for absolute times used by GNUnet, in microseconds.
struct GNUNET_MQ_Handle * mq
Connection to VPN service.
Definition: vpn_api.c:44