GNUnet 0.21.2
gnunet-service-messenger.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
31#include "gnunet_common.h"
33
35{
38};
39
41
42static void
43handle_create (void *cls,
45{
46 struct GNUNET_MESSENGER_Client *msg_client = cls;
47
48 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle created\n");
49
51}
52
53
54static void
55handle_destroy (void *cls,
57{
58 struct GNUNET_MESSENGER_Client *msg_client = cls;
59
60 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle destroyed\n");
61
63}
64
65
68{
69 const uint16_t full_length = ntohs (msg->header.size);
70
71 if (full_length < sizeof(*msg))
72 return GNUNET_NO;
73
74 const uint16_t msg_length = full_length - sizeof(*msg);
75 const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
76
77 if (0 == msg_length)
78 return GNUNET_OK;
79
81 size_t key_len;
82
84 msg_length,
85 &key, &key_len))
86 return GNUNET_NO;
87
88 return key_len == msg_length ? GNUNET_OK : GNUNET_NO;
89}
90
91
92static void
95{
97
98 const uint16_t full_length = ntohs (msg->header.size);
99 const uint16_t msg_length = full_length - sizeof(*msg);
100 const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
101
102 if (msg_length > 0)
103 {
105 size_t key_len;
106
108 msg_length,
109 &key,
110 &key_len))
112 else
114 "Initialization failed while reading invalid key!\n");
115 }
116 else
117 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Initialization is missing key!\n");
118}
119
120
123 const struct GNUNET_MESSENGER_RoomMessage *msg)
124{
126}
127
128
129static void
131 const struct GNUNET_MESSENGER_RoomMessage *msg)
132{
133 struct GNUNET_MESSENGER_Client *msg_client = cls;
134
135 initialize_handle_via_key (msg_client->handle, msg);
136
137 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening room: %s\n", GNUNET_h2s (
138 &(msg->key)));
139
140 if (GNUNET_YES == open_srv_handle_room (msg_client->handle, &(msg->key)))
141 {
142 struct GNUNET_HashCode prev;
143 sync_srv_handle_messages (msg_client->handle, &(msg->key), &(msg->previous),
144 &prev);
145
146 const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
147 msg_client->handle, &(msg->key));
148
149 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening room with member id: %s\n",
150 GNUNET_sh2s (member_id));
151
153 struct GNUNET_MQ_Envelope *env;
154
156 GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
157 GNUNET_memcpy (&(response->previous), &prev, sizeof(response->previous));
158 GNUNET_MQ_send (msg_client->handle->mq, env);
159 }
160 else
161 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Opening room failed: %s\n",
162 GNUNET_h2s (&(msg->key)));
163
165}
166
167
170 const struct GNUNET_MESSENGER_RoomMessage *msg)
171{
173}
174
175
176static void
178 const struct GNUNET_MESSENGER_RoomMessage *msg)
179{
180 struct GNUNET_MESSENGER_Client *msg_client = cls;
181
182 initialize_handle_via_key (msg_client->handle, msg);
183
184 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Entering room: %s, %s\n", GNUNET_h2s (
185 &(msg->key)), GNUNET_i2s (&(msg->door)));
186
187 if (GNUNET_YES == entry_srv_handle_room (msg_client->handle, &(msg->door),
188 &(msg->key)))
189 {
190 struct GNUNET_HashCode prev;
191 sync_srv_handle_messages (msg_client->handle, &(msg->key), &(msg->previous),
192 &prev);
193
194 const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
195 msg_client->handle, &(msg->key));
196
197 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Entering room with member id: %s\n",
198 GNUNET_sh2s (member_id));
199
201 struct GNUNET_MQ_Envelope *env;
202
204 GNUNET_memcpy (&(response->door), &(msg->door), sizeof(response->door));
205 GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
206 GNUNET_memcpy (&(response->previous), &prev, sizeof(response->previous));
207 GNUNET_MQ_send (msg_client->handle->mq, env);
208 }
209 else
210 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Entrance into room failed: %s, %s\n",
211 GNUNET_h2s (&(msg->key)),
212 GNUNET_i2s (&(msg->door)));
213
215}
216
217
218static void
220 const struct GNUNET_MESSENGER_RoomMessage *msg)
221{
222 struct GNUNET_MESSENGER_Client *msg_client = cls;
223
224 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closing room: %s\n", GNUNET_h2s (
225 &(msg->key)));
226
227 if (GNUNET_YES == close_srv_handle_room (msg_client->handle, &(msg->key)))
228 {
229 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closing room succeeded: %s\n",
230 GNUNET_h2s (&(msg->key)));
231
233 struct GNUNET_MQ_Envelope *env;
234
236 GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
237 GNUNET_memcpy (&(response->previous), &(msg->previous),
238 sizeof(response->previous));
239 GNUNET_MQ_send (msg_client->handle->mq, env);
240 }
241 else
242 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Closing room failed: %s\n",
243 GNUNET_h2s (&(msg->key)));
244
246}
247
248
249static void
251 const struct GNUNET_MESSENGER_RoomMessage *msg)
252{
253 struct GNUNET_MESSENGER_Client *msg_client = cls;
254
255 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Syncing room: %s\n", GNUNET_h2s (
256 &(msg->key)));
257
258 struct GNUNET_HashCode prev;
259 sync_srv_handle_messages (msg_client->handle, &(msg->key), &(msg->previous),
260 &prev);
261
263 struct GNUNET_MQ_Envelope *env;
264
266 GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
267 GNUNET_memcpy (&(response->previous), &prev, sizeof(response->previous));
268 GNUNET_MQ_send (msg_client->handle->mq, env);
269
271}
272
273
276 const struct GNUNET_MESSENGER_SendMessage *msg)
277{
278 const uint16_t full_length = ntohs (msg->header.size);
279
280 if (full_length < sizeof(*msg))
281 return GNUNET_NO;
282
283 const uint16_t msg_length = full_length - sizeof(*msg);
284 const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
285
286 struct GNUNET_MESSENGER_Message message;
287
289 GNUNET_YES))
290 {
291 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Too short message: %s\n", GNUNET_h2s (
292 &(msg->key)));
293 return GNUNET_NO;
294 }
295
296 if (GNUNET_YES != decode_message (&message, msg_length, msg_buffer,
298 NULL))
299 {
300 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Decoding message failed: %s\n",
301 GNUNET_h2s (
302 &(msg->key)));
303 return GNUNET_NO;
304 }
305
306 enum GNUNET_GenericReturnValue allowed;
307 allowed = filter_message_sending (&message);
308
309 if (GNUNET_SYSERR == allowed)
311 "Sending message not allowed: %s to %s\n",
313 GNUNET_h2s (&(msg->key)));
314
315 cleanup_message (&message);
316 return GNUNET_SYSERR != allowed? GNUNET_OK : GNUNET_NO;
317}
318
319
320static void
322 const struct GNUNET_MESSENGER_SendMessage *msg)
323{
324 struct GNUNET_MESSENGER_Client *msg_client = cls;
325
326 const struct GNUNET_HashCode *key = &(msg->key);
327 const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
328 const uint16_t msg_length = ntohs (msg->header.size) - sizeof(*msg);
329
330 struct GNUNET_MESSENGER_Message message;
331 decode_message (&message, msg_length, msg_buffer, GNUNET_YES, NULL);
332
333 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message: %s to %s (by %s)\n",
335 GNUNET_h2s (key),
336 GNUNET_sh2s (&(message.header.sender_id)));
337
338 if (GNUNET_YES != send_srv_handle_message (msg_client->handle, key, &message))
339 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sending message failed: %s to %s\n",
341 GNUNET_h2s (key));
342
343 cleanup_message (&message);
344
346}
347
348
349static void
351 struct GNUNET_MESSENGER_SrvRoom *room,
352 const struct GNUNET_MESSENGER_Message *message,
353 const struct GNUNET_HashCode *hash)
354{
355 struct GNUNET_MESSENGER_Client *msg_client = cls;
356
357 if (! message)
358 {
360 "Notifying client about missing message: %s\n",
361 GNUNET_h2s (hash));
362
364 struct GNUNET_MQ_Envelope *env;
365
368 GNUNET_memcpy (&(response->key), &(room->key), sizeof(room->key));
369 GNUNET_memcpy (&(response->hash), hash, sizeof(*hash));
370 GNUNET_MQ_send (msg_client->handle->mq, env);
371 return;
372 }
373
374 struct GNUNET_MESSENGER_SenderSession session;
375
376 if (GNUNET_YES == is_peer_message (message))
377 {
379
380 session.peer = get_store_peer_of (store, message, hash);
381
382 if (! session.peer)
383 {
385 "Peer session from sender of message (%s) unknown!\n",
386 GNUNET_h2s (hash));
387 return;
388 }
389 }
390 else
391 {
393 room);
395 message);
396
397 if (! member)
398 {
399 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sender of message (%s) unknown!\n",
400 GNUNET_h2s (hash));
401 return;
402 }
403
404 session.member = get_member_session_of (member, message, hash);
405
406 if (! session.member)
407 {
409 "Member session from sender of message (%s) unknown!\n",
410 GNUNET_h2s (hash));
411 return;
412 }
413 }
414
415 notify_srv_handle_message (msg_client->handle, room, &session, message,
416 hash, GNUNET_NO);
417}
418
419
420static void
422 const struct GNUNET_MESSENGER_GetMessage *msg)
423{
424 struct GNUNET_MESSENGER_Client *msg_client = cls;
425
426 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Requesting message from room: %s\n",
427 GNUNET_h2s (&(msg->key)));
428 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Requested message: %s\n",
429 GNUNET_h2s (&(msg->hash)));
430
432 &(msg->key));
433
434 if (! room)
435 {
436 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Room not found: %s\n", GNUNET_h2s (
437 &(msg->key)));
438 goto end_handling;
439 }
440
441 struct GNUNET_MESSENGER_MemberStore *member_store =
443
444 const struct GNUNET_ShortHashCode *member_id;
445 member_id = get_srv_handle_member_id (msg_client->handle,
446 &(msg->key));
447
448 struct GNUNET_MESSENGER_Member *member = get_store_member (member_store,
449 member_id);
450
451 if (! member)
452 {
454 "Member not valid to request a message! (%s)\n",
455 GNUNET_sh2s (member_id));
456 goto end_handling;
457 }
458
460 msg_client->handle);
461
462 if (! pubkey)
463 {
465 "Handle needs to have a public key to request a message! (%s)\n",
466 GNUNET_sh2s (member_id));
467 goto end_handling;
468 }
469
471 pubkey);
472
473 if (! session)
474 {
476 "Session not valid to request a message! (%s)\n",
477 GNUNET_sh2s (member_id));
478 goto end_handling;
479 }
480
481 request_srv_room_message (room, &(msg->hash), session, callback_found_message,
482 msg_client);
483
484end_handling:
486}
487
488
489static void*
491 struct GNUNET_SERVICE_Client *client,
492 struct GNUNET_MQ_Handle *mq)
493{
494 struct GNUNET_MESSENGER_Client *msg_client = GNUNET_new (struct
496
497 msg_client->client = client;
498 msg_client->handle = add_service_handle (messenger, mq);
499
500 return msg_client;
501}
502
503
504static void
507 void *internal_cls)
508{
509 struct GNUNET_MESSENGER_Client *msg_client = internal_cls;
510
512
513 GNUNET_free (msg_client);
514}
515
516
524static void
525run (void *cls,
528{
530
531 if (! messenger)
533}
534
535
542 &run,
545 NULL,
548 struct
552 struct
555 struct GNUNET_MESSENGER_RoomMessage, NULL),
557 struct GNUNET_MESSENGER_RoomMessage, NULL),
559 struct GNUNET_MESSENGER_RoomMessage, NULL),
563 GNUNET_MQ_hd_fixed_size (get_message,
565 struct
568 struct GNUNET_MESSENGER_RoomMessage, NULL),
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 struct MHD_Response * response
Our canonical response.
struct GNUNET_HashCode key
The key used in the DHT.
static int create
Create DID Document Flag.
Definition: gnunet-did.c:68
const struct GNUNET_CONFIGURATION_Handle * config
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void handle_create(void *cls, const struct GNUNET_MESSENGER_CreateMessage *msg)
static void handle_destroy(void *cls, const struct GNUNET_MESSENGER_DestroyMessage *msg)
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_SERVICE_Handle *service)
Setup MESSENGER internals.
static void handle_room_close(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static void handle_send_message(void *cls, const struct GNUNET_MESSENGER_SendMessage *msg)
static void handle_room_open(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static void handle_room_entry(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static void callback_client_disconnect(void *cls, struct GNUNET_SERVICE_Client *client, void *internal_cls)
static void initialize_handle_via_key(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_RoomMessage *msg)
static void handle_room_sync(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
struct GNUNET_MESSENGER_Service * messenger
static void handle_get_message(void *cls, const struct GNUNET_MESSENGER_GetMessage *msg)
static void callback_found_message(void *cls, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
static void * callback_client_connect(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
static enum GNUNET_GenericReturnValue check_room_open(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
GNUNET_SERVICE_MAIN(GNUNET_MESSENGER_SERVICE_NAME, GNUNET_SERVICE_OPTION_NONE, &run, &callback_client_connect, &callback_client_disconnect, NULL, GNUNET_MQ_hd_fixed_size(create, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE, struct GNUNET_MESSENGER_CreateMessage, NULL), GNUNET_MQ_hd_fixed_size(destroy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY, struct GNUNET_MESSENGER_DestroyMessage, NULL), GNUNET_MQ_hd_var_size(room_open, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, struct GNUNET_MESSENGER_RoomMessage, NULL), GNUNET_MQ_hd_var_size(room_entry, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, struct GNUNET_MESSENGER_RoomMessage, NULL), GNUNET_MQ_hd_fixed_size(room_close, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, struct GNUNET_MESSENGER_RoomMessage, NULL), GNUNET_MQ_hd_var_size(send_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE, struct GNUNET_MESSENGER_SendMessage, NULL), GNUNET_MQ_hd_fixed_size(get_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE, struct GNUNET_MESSENGER_GetMessage, NULL), GNUNET_MQ_hd_fixed_size(room_sync, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC, struct GNUNET_MESSENGER_RoomMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static enum GNUNET_GenericReturnValue check_send_message(void *cls, const struct GNUNET_MESSENGER_SendMessage *msg)
static enum GNUNET_GenericReturnValue check_room_entry(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static enum GNUNET_GenericReturnValue check_room_initial_key(const struct GNUNET_MESSENGER_RoomMessage *msg)
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 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.
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...
const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the public key of a given handle.
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.
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_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...
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_Member * get_store_member_of(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_MESSENGER_Message *message)
Returns the member of a store using a sender id of a given message.
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.
struct GNUNET_PeerIdentity * get_store_peer_of(struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Returns the peer identity inside the store which verifies the signature of a given message as valid.
struct GNUNET_MESSENGER_PeerStore * get_srv_room_peer_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used peer store of a given room.
enum GNUNET_GenericReturnValue request_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)
Requests a message from a room identified by a given hash.
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.
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.
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.
static void send_message(struct PeerContext *peer_ctx, struct GNUNET_MQ_Envelope *ev, const char *type)
Send a message to another peer.
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...
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_CRYPTO_PublicKey *key, size_t *read)
Reads a GNUNET_CRYPTO_PublicKey from a compact buffer.
Definition: crypto_pkey.c:120
GNUNET_GenericReturnValue
Named constants for return values.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#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
@ GNUNET_ERROR_TYPE_INFO
#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:43
#define GNUNET_MESSENGER_SERVICE_NAME
Identifier of GNUnet MESSENGER Service.
@ GNUNET_MESSENGER_KIND_UNKNOWN
The unknown kind.
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_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2484
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
enum GNUNET_GenericReturnValue filter_message_sending(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message should be sent by a client.
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_kind_size(enum GNUNET_MESSENGER_MessageKind kind, enum GNUNET_GenericReturnValue include_header)
Returns the minimal size in bytes to encode a message of a specific kind.
enum GNUNET_GenericReturnValue decode_message(struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, enum GNUNET_GenericReturnValue include_header, uint16_t *padding)
Decodes a message from a given buffer of a maximal length in bytes.
void cleanup_message(struct GNUNET_MESSENGER_Message *message)
Frees the messages body memory.
static void destroy(void *cls)
Function to destroy a microphone.
Definition: microphone.c:153
An identity key as per LSD0001.
A 512-bit hashcode.
struct GNUNET_SERVICE_Client * client
struct GNUNET_MESSENGER_SrvHandle * handle
Message to create a handle for a client.
Message to destroy the handle for a client.
Message to request something from a room.
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.
General message to confirm interaction with a room.
Message to send something into a room.
struct GNUNET_MESSENGER_MemberSession * member
struct GNUNET_MQ_Envelope * prev
Messages are stored in a linked list Each queue has its own list of envelopes.
Definition: mq.c:45
Handle to a message queue.
Definition: mq.c:87
Handle to a client that is connected to a service.
Definition: service.c:246
Handle to a service.
Definition: service.c:117
A 256-bit hashcode.