GNUnet 0.21.0
gnunet-service-messenger_handle.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
32
33#include "messenger_api_util.h"
34
36{
39};
40
43 struct GNUNET_MQ_Handle *mq)
44{
45 GNUNET_assert ((service) && (mq));
46
49
50 handle->service = service;
51 handle->mq = mq;
52
56
57 handle->notify = NULL;
58
59 return handle;
60}
61
62
65 const struct GNUNET_HashCode *key,
66 void *value)
67{
70 return GNUNET_YES;
71}
72
73
76 const struct GNUNET_HashCode *key,
77 void *value)
78{
80 return GNUNET_YES;
81}
82
83
84void
86{
88
91
92 if (handle->notify)
94
99
103
105}
106
107
108void
110 const struct GNUNET_CRYPTO_PublicKey *key)
111{
113
114 if ((handle->key) && (! key))
115 {
116 GNUNET_free (handle->key);
117 handle->key = NULL;
118 }
119 else if (! handle->key)
121
122 if (key)
123 memcpy (handle->key, key, sizeof(struct GNUNET_CRYPTO_PublicKey));
124}
125
126
127const struct GNUNET_CRYPTO_PublicKey*
129{
131
132 return handle->key;
133}
134
135
136void
138 const char *name,
139 char **dir)
140{
141 GNUNET_assert ((handle) && (dir));
142
143 if (name)
144 GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
146 else
147 GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
149}
150
151
154 const struct GNUNET_HashCode *key)
155{
156 GNUNET_assert ((handle) && (key));
157
158 struct GNUNET_ShortHashCode *random_id = GNUNET_new (struct
160
161 if (! random_id)
162 return GNUNET_NO;
163
164 generate_free_member_id (random_id, NULL);
165
167 random_id,
169 {
170 GNUNET_free (random_id);
171 return GNUNET_NO;
172 }
173
175 "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (
176 random_id),
177 GNUNET_h2s (key));
178
179 return GNUNET_YES;
180}
181
182
183const struct GNUNET_ShortHashCode*
185 const struct GNUNET_HashCode *key)
186{
187 GNUNET_assert ((handle) && (key));
188
189 return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
190}
191
192
195 const struct GNUNET_HashCode *key,
196 const struct GNUNET_ShortHashCode *unique_id)
197{
198 GNUNET_assert ((handle) && (key) && (unique_id));
199
201 handle->member_ids, key);
202
203 if (! member_id)
204 {
205 member_id = GNUNET_new (struct GNUNET_ShortHashCode);
206 GNUNET_memcpy (member_id, unique_id, sizeof(*member_id));
207
209 member_id,
211 {
212 GNUNET_free (member_id);
213 return GNUNET_SYSERR;
214 }
215 }
216
217 if (0 == GNUNET_memcmp (unique_id, member_id))
218 return GNUNET_OK;
219
221 "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (
222 member_id),
223 GNUNET_h2s (key));
224
225 GNUNET_memcpy (member_id, unique_id, sizeof(*unique_id));
226
227 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n",
228 GNUNET_sh2s (unique_id));
229 return GNUNET_OK;
230}
231
232
235 const struct GNUNET_HashCode *key)
236{
237 GNUNET_assert ((handle) && (key));
238
240 key,
241 NULL,
243 return GNUNET_NO;
244
247 key)))
248 return GNUNET_NO;
249
250 return open_service_room (handle->service, handle, key);
251}
252
253
256 const struct GNUNET_PeerIdentity *door,
257 const struct GNUNET_HashCode *key)
258{
259 GNUNET_assert ((handle) && (door) && (key));
260
263 handle, key)))
264 return GNUNET_NO;
265
266 return entry_service_room (handle->service, handle, door, key);
267}
268
269
272 const struct GNUNET_HashCode *key)
273{
274 GNUNET_assert ((handle) && (key));
275
277 iterate_free_values, NULL);
279
280 if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
281 handle->next_ids)))
282 {
284 handle->notify = NULL;
285 }
286
288 return GNUNET_NO;
289
292
293 if (GNUNET_YES != result)
294 return result;
295
297 return result;
298}
299
300
303 const struct GNUNET_HashCode *key)
304{
305 GNUNET_assert ((handle) && (key));
306
308}
309
310
311void
313 const struct GNUNET_HashCode *key,
314 const struct GNUNET_HashCode *prev,
315 struct GNUNET_HashCode *hash)
316{
317 GNUNET_assert ((handle) && (key) && (prev) && (hash));
318
319 struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
320 key);
321
322 if ((! room) || (! get_srv_handle_member_id (handle, key)))
323 {
324 GNUNET_memcpy (hash, prev, sizeof(*hash));
325 return;
326 }
327
329 get_message_state_chain_hash (&(room->state), hash);
330}
331
332
335 const struct GNUNET_HashCode *key,
336 const struct GNUNET_MESSENGER_Message *message)
337{
338 GNUNET_assert ((handle) && (key) && (message));
339
341 key);
342
343 if (! id)
344 {
346 "It is required to be a member of a room to send messages!\n");
347 return GNUNET_NO;
348 }
349
350 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
351 GNUNET_sh2s (id));
352
353 if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
354 {
356 "Member id does not match with handle!\n");
357 return GNUNET_NO;
358 }
359
360 struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
361 key);
362
363 if (! room)
364 {
365 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
366 GNUNET_h2s (key));
367 return GNUNET_NO;
368 }
369
370 struct GNUNET_MESSENGER_Message *msg = copy_message (message);
371 return send_srv_room_message (room, handle, msg);
372}
373
374
375static const struct GNUNET_HashCode*
378{
379 if (session->next)
380 return get_next_member_session_context (session->next);
381 else
382 return get_member_session_context (session);
383}
384
385
386static const struct GNUNET_MESSENGER_MemberSession*
388 struct GNUNET_MESSENGER_SrvRoom *room,
389 const struct GNUNET_HashCode *key)
390{
391 GNUNET_assert ((handle) && (room) && (key) && (handle->service));
392
394 key);
395
396 if (! id)
397 {
399 "Handle is missing a member id for its member session! (%s)\n",
400 GNUNET_h2s (key));
401 return NULL;
402 }
403
405 struct GNUNET_MESSENGER_Member *member = get_store_member (store, id);
406
408
409 if (! pubkey)
410 {
412 "Handle is missing a public key for its member session! (%s)\n",
413 GNUNET_h2s (key));
414 return NULL;
415 }
416
417 return get_member_session (member, pubkey);
418}
419
420
421void
423 struct GNUNET_MESSENGER_SrvRoom *room,
424 const struct GNUNET_MESSENGER_SenderSession *session,
425 const struct GNUNET_MESSENGER_Message *message,
426 const struct GNUNET_HashCode *hash,
427 enum GNUNET_GenericReturnValue recent)
428{
429 GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
430
431 const struct GNUNET_HashCode *key = get_srv_room_key (room);
432
433 if ((! handle->mq) || (! get_srv_handle_member_id (handle, key)))
434 {
436 "Notifying client about message requires membership!\n");
437 return;
438 }
439
440 struct GNUNET_HashCode sender;
441 const struct GNUNET_HashCode *context = NULL;
442
443 if (GNUNET_YES == is_peer_message (message))
444 {
445 const struct GNUNET_PeerIdentity *identity = session->peer;
446 GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
447
448 context = &sender;
449 }
450 else
451 {
453 session->member->contact);
454 GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
455
457 }
458
460 "Notifying client about message: %s (%s)\n",
462 message->header.kind));
463
465 struct GNUNET_MQ_Envelope *env;
466
467 uint16_t length = get_message_size (message, GNUNET_YES);
468
469 env = GNUNET_MQ_msg_extra (msg, length,
471
472 GNUNET_memcpy (&(msg->key), key, sizeof(msg->key));
473 GNUNET_memcpy (&(msg->sender), &sender, sizeof(msg->sender));
474 GNUNET_memcpy (&(msg->context), context, sizeof(msg->context));
475 GNUNET_memcpy (&(msg->hash), hash, sizeof(msg->hash));
476
477 msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
478
479 if (GNUNET_YES == is_peer_message (message))
480 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
481 else if (get_handle_member_session (handle, room, key) == session->member)
482 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
483
484 if (GNUNET_YES == recent)
485 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_RECENT;
486
487 char *buffer = ((char*) msg) + sizeof(*msg);
488 encode_message (message, length, buffer, GNUNET_YES);
489
491}
492
493
496 const struct GNUNET_HashCode *key,
497 void *value)
498{
501
503 struct GNUNET_MQ_Envelope *env;
504
506
507 GNUNET_memcpy (&(msg->key), key, sizeof(*key));
508 GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
509 msg->reset = (uint32_t) next->reset;
510
512
514 return GNUNET_YES;
515}
516
517
518static void
520{
522 handle->notify = NULL;
523
527}
528
529
530void
532 struct GNUNET_MESSENGER_SrvRoom *room,
533 const struct GNUNET_ShortHashCode *member_id,
535{
536 GNUNET_assert ((handle) && (room) && (member_id));
537
538 struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct
540 if (! next)
541 {
542 return;
543 }
544
545 GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
546 next->reset = reset;
547
548 const struct GNUNET_HashCode *key = get_srv_room_key (room);
549
550 struct GNUNET_MESSENGER_NextMemberId *prev =
553 next,
555 {
556 return;
557 }
558
559 if (prev)
560 GNUNET_free (prev);
561
562 if (! handle->notify)
564 handle);
565}
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:89
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 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.
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.
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...
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)
void sync_srv_handle_messages(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_HashCode *prev, struct GNUNET_HashCode *hash)
Returns the latest merged hash from a room of a given handle using a specific key and the handles own...
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.
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)
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.
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_DEBUG
@ GNUNET_ERROR_TYPE_INFO
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:42
@ 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:304
#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:63
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#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:975
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:1299
const struct GNUNET_CRYPTO_PublicKey * get_contact_key(const struct GNUNET_MESSENGER_Contact *contact)
Returns the public key of a given contact.
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:165
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
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_MESSENGER_MessageHeader header
Header.
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.
struct GNUNET_MQ_Handle * mq
Connection to VPN service.
Definition: vpn_api.c:44