GNUnet debian-0.24.3-29-g453fda2cf
 
Loading...
Searching...
No Matches
gnunet-service-messenger_handle.h File Reference
Include dependency graph for gnunet-service-messenger_handle.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_SrvHandle
 

Functions

struct GNUNET_MESSENGER_SrvHandlecreate_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 destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 Destroys a handle and frees its memory fully.
 
void set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_CRYPTO_PublicKey *key)
 Sets the public key of a given handle.
 
const struct GNUNET_CRYPTO_PublicKeyget_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
 Returns the public key of a given handle.
 
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.
 
const struct GNUNET_ShortHashCodeget_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 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 on success.
 
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 service.
 
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 to a peer identified by a given door (peer identity).
 
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 service is still a member of it.
 
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 room.
 
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 latest known hash and epoch of a message.
 
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_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.
 
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.
 

Function Documentation

◆ create_srv_handle()

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).

Parameters
[in,out]serviceMESSENGER Service
[in,out]mqMessage queue
Returns
New handle

Definition at line 42 of file gnunet-service-messenger_handle.c.

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}
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition gnunet-vpn.c:35
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct GNUNET_MQ_Handle * mq
Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
struct GNUNET_MQ_Handle * mq
Connection to VPN service.
Definition vpn_api.c:44

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_new, GNUNET_NO, handle, mq, GNUNET_VPN_Handle::mq, and service.

Referenced by add_service_handle().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ destroy_srv_handle()

void destroy_srv_handle ( struct GNUNET_MESSENGER_SrvHandle handle)

Destroys a handle and frees its memory fully.

Parameters
[in,out]handleHandle

Definition at line 93 of file gnunet-service-messenger_handle.c.

94{
96
99
100 if (handle->notify)
102
104 iterate_free_values, NULL);
106 iterate_free_values, NULL);
107
111
113}
static enum GNUNET_GenericReturnValue iterate_free_values(void *cls, const struct GNUNET_HashCode *key, void *value)
static enum GNUNET_GenericReturnValue iterate_close_rooms(void *cls, const struct GNUNET_HashCode *key, void *value)
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_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition scheduler.c:980

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), handle, iterate_close_rooms(), and iterate_free_values().

Referenced by clear_list_handles(), and remove_service_handle().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ set_srv_handle_key()

void set_srv_handle_key ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_CRYPTO_PublicKey key 
)

Sets the public key of a given handle.

Parameters
[out]handleHandle
[in]keyPublic key

Definition at line 117 of file gnunet-service-messenger_handle.c.

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}
struct GNUNET_HashCode key
The key used in the DHT.
An identity key as per LSD0001.

References GNUNET_assert, GNUNET_free, GNUNET_new, handle, and key.

Referenced by initialize_handle_via_key(), send_message_join(), and send_message_key().

Here is the caller graph for this function:

◆ get_srv_handle_key()

const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key ( const struct GNUNET_MESSENGER_SrvHandle handle)

Returns the public key of a given handle.

Parameters
[in]handleHandle
Returns
Public key of handle

Definition at line 136 of file gnunet-service-messenger_handle.c.

137{
139
140 return handle->key;
141}

References GNUNET_assert, and handle.

Referenced by find_member_session_in_room(), get_handle_member_session(), handle_get_message(), initialize_service_handle(), and solve_srv_room_member_collisions().

Here is the caller graph for this function:

◆ get_srv_handle_data_subdir()

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.

This directory will be used to store data regarding the handle and its messages.

Parameters
[in]handleHandle
[in]namePotential name of the handle
[out]dirPath to store data

Definition at line 145 of file gnunet-service-messenger_handle.c.

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}
static char * dir
Set to the directory where runtime files are stored.
Definition gnunet-arm.c:88
static char * name
Name (label) of the records to list.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define DIR_SEPARATOR
Definition platform.h:166

References dir, DIR_SEPARATOR, GNUNET_asprintf(), GNUNET_assert, handle, and name.

Here is the call graph for this function:

◆ get_srv_handle_member_id()

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.

If the handle is not a member of the specific room, NULL gets returned.

Parameters
[in]handleHandle
[in]keyKey of a room
Returns
Member id or NULL

Definition at line 193 of file gnunet-service-messenger_handle.c.

195{
196 GNUNET_assert ((handle) && (key));
197
198 return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
199}
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.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), handle, and key.

Referenced by close_srv_handle_room(), entry_srv_handle_room(), find_list_handle_by_member(), get_handle_member_session(), handle_get_message(), handle_room_entry(), handle_room_open(), handle_service_message(), join_room_locally(), notify_srv_handle_message(), open_srv_handle_room(), open_srv_room(), send_srv_handle_message(), solve_srv_room_member_collisions(), and sync_srv_handle_messages().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ change_srv_handle_member_id()

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 on success.

The client connected to the handle will be informed afterwards automatically.

Parameters
[in,out]handleHandle
[in]keyKey of a room
[in]unique_idUnique member id
Returns
GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 203 of file gnunet-service-messenger_handle.c.

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}
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.
@ 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_OK
@ GNUNET_SYSERR
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_DEBUG
A 256-bit hashcode.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, handle, and key.

Referenced by find_member_session_in_room(), join_room(), and send_message_id().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ open_srv_handle_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 service.

Parameters
[in,out]handleHandle
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 244 of file gnunet-service-messenger_handle.c.

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}
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 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE
If a value with the given key exists, replace it.
@ GNUNET_YES

References create_handle_member_id(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_NO, GNUNET_OK, GNUNET_YES, handle, key, and open_service_room().

Referenced by handle_room_open().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ entry_srv_handle_room()

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 to a peer identified by a given door (peer identity).

Parameters
[in,out]handleHandle
[in]doorPeer identity
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 264 of file gnunet-service-messenger_handle.c.

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}
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.

References create_handle_member_id(), entry_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, handle, and key.

Referenced by handle_room_entry().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ close_srv_handle_room()

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 service is still a member of it.

Parameters
[in,out]handleHandle
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 280 of file gnunet-service-messenger_handle.c.

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}
static int result
Global testing status.
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.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in 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_GenericReturnValue
Named constants for return values.

References close_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, handle, iterate_free_values(), key, and result.

Referenced by handle_room_close().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_srv_handle_routing()

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 room.

Parameters
[in]handleHandle
[in]keyKey of a room
Returns
GNUNET_YES is routing is enabled, otherwise GNUNET_NO

Definition at line 313 of file gnunet-service-messenger_handle.c.

315{
316 GNUNET_assert ((handle) && (key));
317
319}
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).

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), handle, and key.

Referenced by find_list_handle_by_member(), and rebuild_srv_room_basement_structure().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ sync_srv_handle_messages()

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 latest known hash and epoch of a message.

If the room does not contain other messages being accessible to the handle and older than the provided hash, the function returns the originally provided hash as fallback.

Parameters
[in,out]handleHandle
[in]keyKey of a room
[in]prevKnown hash of a message
[out]hashHash of the latest merged message in a room available to the handle
[out]epochHash of the latest epoch in a room available to the handle

Definition at line 323 of file gnunet-service-messenger_handle.c.

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}
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...
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_MessageState state

References get_message_state_chain_hash(), get_service_room(), get_srv_handle_member_id(), get_srv_room_message_store(), get_store_message_epoch(), GNUNET_assert, GNUNET_memcpy, handle, key, merge_srv_room_last_messages(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by handle_room_entry(), handle_room_open(), and handle_room_sync().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_srv_handle_message()

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.

Parameters
[in,out]handleHandle
[in]keyKey of a room
[in]messageMessage
Returns
GNUNET_YES on success, GNUNET_NO or GNUNET_SYSERR otherwise.

Definition at line 363 of file gnunet-service-messenger_handle.c.

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}
struct GNUNET_MessageHeader * msg
Definition 005.c:2
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
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.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_MESSENGER_MessageHeader header
Header.

References copy_message(), get_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_sh2s(), handle, GNUNET_MESSENGER_Message::header, id, key, msg, send_srv_room_message(), and GNUNET_MESSENGER_MessageHeader::sender_id.

Referenced by handle_send_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_srv_handle_message()

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.

Parameters
[in,out]handleHandle
[in]roomRoom of the message
[in]sessionSender session
[in]messageMessage
[in]hashHash of message
[in]epochHash of epoch
[in]recentWhether the message was recently received

Definition at line 471 of file gnunet-service-messenger_handle.c.

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}
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
static uint64_t timestamp(void)
Get current timestamp.
static pa_context * context
Pulseaudio context.
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static const struct GNUNET_HashCode * get_next_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
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)
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.
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.
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 has_subscription_of_timestamp(const struct GNUNET_MESSENGER_Subscription *subscription, struct GNUNET_TIME_Absolute timestamp)
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
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
@ 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.
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
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.
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.
A 512-bit hashcode.
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 discourse
The hash of the discourse to talk.
struct GNUNET_MESSENGER_MessageBody body
Body.
Message to receive something from a room.
struct GNUNET_MESSENGER_MemberSession * member
The identity of the host (wraps the signing key of the peer).
Time for absolute times used by GNUnet, in microseconds.

References GNUNET_MESSENGER_Message::body, context, GNUNET_MESSENGER_MessageTalk::discourse, encode_message(), env, get_handle_member_session(), get_member_session_public_key(), get_member_subscription(), get_message_size(), get_next_member_session_context(), get_srv_handle_member_id(), get_srv_room_key(), get_srv_room_member_store(), get_store_member(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE, GNUNET_MESSENGER_FLAG_NONE, GNUNET_MESSENGER_FLAG_PEER, GNUNET_MESSENGER_FLAG_RECENT, GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_name_of_kind(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, handle, has_subscription_of_timestamp(), GNUNET_MESSENGER_Message::header, id, identity, is_peer_message(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SenderSession::member, GNUNET_VPN_Handle::mq, msg, GNUNET_MESSENGER_SenderSession::peer, pubkey, GNUNET_MESSENGER_MessageBody::talk, GNUNET_MESSENGER_MessageHeader::timestamp, and timestamp().

Referenced by callback_found_message(), handle_service_message(), notify_about_members(), and traverse_epoch_session_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_srv_handle_member_id()

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.

Parameters
[in,out]handleHandle
[in]roomRoom of the member
[in]member_idMember id
[in]resetReset member session with join message

Definition at line 650 of file gnunet-service-messenger_handle.c.

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}
static int reset
Reset argument.
static void task_notify_srv_handle_member_id(void *cls)
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

References get_srv_room_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_sh2s(), GNUNET_YES, handle, GNUNET_MESSENGER_NextMemberId::id, key, reset, GNUNET_MESSENGER_NextMemberId::reset, and task_notify_srv_handle_member_id().

Referenced by join_room(), and solve_srv_room_member_collisions().

Here is the call graph for this function:
Here is the caller graph for this function: