GNUnet 0.22.1
messenger_api_room.c File Reference
Include dependency graph for messenger_api_room.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_MemberCall
 
struct  GNUNET_MESSENGER_MemberFind
 
struct  GNUNET_MESSENGER_RoomLinkDeletionInfo
 

Functions

struct GNUNET_MESSENGER_Roomcreate_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 Creates and allocates a new room for a handle with a given key for the client API. More...
 
static enum GNUNET_GenericReturnValue iterate_destroy_message (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static enum GNUNET_GenericReturnValue iterate_destroy_link (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static enum GNUNET_GenericReturnValue iterate_destroy_subscription (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
 
void destroy_room (struct GNUNET_MESSENGER_Room *room)
 Destroys a room and frees its memory fully from the client API. More...
 
enum GNUNET_GenericReturnValue is_room_available (const struct GNUNET_MESSENGER_Room *room)
 Checks whether a room is available to send messages. More...
 
struct GNUNET_MESSENGER_Handleget_room_handle (struct GNUNET_MESSENGER_Room *room)
 Returns the messenger handle of the room. More...
 
const struct GNUNET_ShortHashCodeget_room_sender_id (const struct GNUNET_MESSENGER_Room *room)
 Returns the member id of the room's sender. More...
 
void set_room_sender_id (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_ShortHashCode *id)
 Sets the member id of the room's sender to a specific id or NULL. More...
 
const struct GNUNET_MESSENGER_Messageget_room_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Returns a message locally stored from a map for a given hash in a room. More...
 
struct GNUNET_MESSENGER_Contactget_room_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Returns a messages sender locally stored from a map for a given hash in a room. More...
 
struct GNUNET_MESSENGER_Contactget_room_recipient (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Returns a messages recipient locally stored from a map for a given hash in a room. More...
 
void delete_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
 Deletes a message with a given hash inside a room under a specific delay. More...
 
void callback_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Executes the message callback for a given hash in a room. More...
 
static void handle_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_join_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_leave_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_name_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_key_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_id_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_miss_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_private_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_delete_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
static void handle_transcript_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
 
void handle_room_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_MessageFlags flags)
 Handles a message with a given hash in a room for the client API to update members and its information. More...
 
void update_room_last_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Updates the last message hash of a room for the client API so that new messages can point to the latest message hash while sending. More...
 
static enum GNUNET_GenericReturnValue iterate_local_members (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
 
int iterate_room_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback, void *cls)
 Iterates through all members of a given room to forward each of them to a selected callback with a custom closure. More...
 
static enum GNUNET_GenericReturnValue iterate_find_member (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
 
enum GNUNET_GenericReturnValue find_room_member (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
 Checks through all members of a given room if a specific contact is found and returns a result depending on that. More...
 
static enum GNUNET_GenericReturnValue find_linked_hash (void *cls, const struct GNUNET_HashCode *key, void *value)
 
void link_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_HashCode *other)
 Links a message identified by its hash inside a given room with another message identified by its other hash. More...
 
static enum GNUNET_GenericReturnValue clear_linked_hash (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static enum GNUNET_GenericReturnValue delete_linked_hash (void *cls, const struct GNUNET_HashCode *key, void *value)
 
void link_room_deletion (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay, GNUNET_MESSENGER_RoomLinkDeletion deletion)
 Delete all remaining links to a certain message identified by its hash inside a given room and cause a deletion process to all of the linked messages. More...
 

Function Documentation

◆ create_room()

struct GNUNET_MESSENGER_Room * create_room ( struct GNUNET_MESSENGER_Handle handle,
const struct GNUNET_HashCode key 
)

Creates and allocates a new room for a handle with a given key for the client API.

Parameters
[in,out]handleHandle
[in]keyKey of room
Returns
New room

Definition at line 41 of file messenger_api_room.c.

43{
44 struct GNUNET_MESSENGER_Room *room;
45
46 GNUNET_assert ((handle) && (key));
47
48 room = GNUNET_new (struct GNUNET_MESSENGER_Room);
49 room->handle = handle;
50
51 GNUNET_memcpy (&(room->key), key, sizeof(*key));
52
53 memset (&(room->last_message), 0, sizeof(room->last_message));
54
55 room->opened = GNUNET_NO;
58
59 room->sender_id = NULL;
60
61 init_list_tunnels (&(room->entries));
62
66
68
69 init_queue_messages (&(room->queue));
70 room->queue_task = NULL;
71
72 room->control = create_message_control (room);
73
74 return room;
75}
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_YES
@ 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.
void init_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Initializes list of tunnels peer identities as empty list.
struct GNUNET_MESSENGER_MessageControl * create_message_control(struct GNUNET_MESSENGER_Room *room)
Creates and allocates a new message control for a room of the client API.
void init_queue_messages(struct GNUNET_MESSENGER_QueueMessages *messages)
Initializes queue of messages as empty queue.
struct GNUNET_CONTAINER_MultiHashMap * links
struct GNUNET_CONTAINER_MultiShortmap * subscriptions
struct GNUNET_MESSENGER_Handle * handle
enum GNUNET_GenericReturnValue opened
enum GNUNET_GenericReturnValue wait_for_sync
struct GNUNET_CONTAINER_MultiShortmap * members
struct GNUNET_MESSENGER_MessageControl * control
struct GNUNET_SCHEDULER_Task * queue_task
struct GNUNET_CONTAINER_MultiHashMap * messages
enum GNUNET_GenericReturnValue use_handle_name
struct GNUNET_MESSENGER_QueueMessages queue
struct GNUNET_MESSENGER_ListTunnels entries
struct GNUNET_ShortHashCode * sender_id
struct GNUNET_HashCode key
struct GNUNET_HashCode last_message

References GNUNET_MESSENGER_Room::control, create_message_control(), GNUNET_MESSENGER_Room::entries, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_YES, handle, GNUNET_MESSENGER_Room::handle, init_list_tunnels(), init_queue_messages(), key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::last_message, GNUNET_MESSENGER_Room::links, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_Room::messages, GNUNET_MESSENGER_Room::opened, GNUNET_MESSENGER_Room::queue, GNUNET_MESSENGER_Room::queue_task, GNUNET_MESSENGER_Room::sender_id, GNUNET_MESSENGER_Room::subscriptions, GNUNET_MESSENGER_Room::use_handle_name, and GNUNET_MESSENGER_Room::wait_for_sync.

Referenced by GNUNET_MESSENGER_enter_room(), and GNUNET_MESSENGER_open_room().

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

◆ iterate_destroy_message()

static enum GNUNET_GenericReturnValue iterate_destroy_message ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 79 of file messenger_api_room.c.

82{
84
86
87 entry = value;
88
89 destroy_message (entry->message);
90 GNUNET_free (entry);
91 return GNUNET_YES;
92}
static char * value
Value of the record to add/remove.
#define GNUNET_free(ptr)
Wrapper around free.
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.
struct GNUNET_MESSENGER_Message * message

References destroy_message(), GNUNET_assert, GNUNET_free, GNUNET_YES, GNUNET_MESSENGER_RoomMessageEntry::message, and value.

Referenced by destroy_room().

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

◆ iterate_destroy_link()

static enum GNUNET_GenericReturnValue iterate_destroy_link ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 96 of file messenger_api_room.c.

99{
100 struct GNUNET_HashCode *hash;
101
103
104 hash = value;
105
106 GNUNET_free (hash);
107 return GNUNET_YES;
108}
A 512-bit hashcode.

References GNUNET_assert, GNUNET_free, GNUNET_YES, and value.

Referenced by destroy_room().

Here is the caller graph for this function:

◆ iterate_destroy_subscription()

static enum GNUNET_GenericReturnValue iterate_destroy_subscription ( void *  cls,
const struct GNUNET_ShortHashCode key,
void *  value 
)
static

Definition at line 112 of file messenger_api_room.c.

115{
116 struct GNUNET_MESSENGER_RoomSubscription *subscription;
117
119
120 subscription = value;
121
122 if (subscription->task)
123 GNUNET_SCHEDULER_cancel (subscription->task);
124
125 if (subscription->message)
126 destroy_message (subscription->message);
127
128 GNUNET_free (subscription);
129 return GNUNET_YES;
130}
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979
struct GNUNET_SCHEDULER_Task * task
struct GNUNET_MESSENGER_Message * message

References destroy_message(), GNUNET_assert, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_MESSENGER_RoomSubscription::message, GNUNET_MESSENGER_RoomSubscription::task, and value.

Referenced by destroy_room().

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

◆ destroy_room()

void destroy_room ( struct GNUNET_MESSENGER_Room room)

Destroys a room and frees its memory fully from the client API.

Parameters
[in,out]roomRoom

Definition at line 134 of file messenger_api_room.c.

135{
136 GNUNET_assert (room);
137
139
140 if (room->queue_task)
142
143 clear_queue_messages (&(room->queue));
144 clear_list_tunnels (&(room->entries));
145
146 if (room->subscriptions)
147 {
150 NULL);
151
153 }
154
155 if (room->messages)
156 {
159
161 }
162
163 if (room->members)
165
166 if (room->links)
167 {
170
172 }
173
174 if (room->sender_id)
175 GNUNET_free (room->sender_id);
176
177 GNUNET_free (room);
178}
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.
int GNUNET_CONTAINER_multishortmap_iterate(struct GNUNET_CONTAINER_MultiShortmap *map, GNUNET_CONTAINER_ShortmapIterator it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
void clear_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Clears the list of tunnels peer identities.
void destroy_message_control(struct GNUNET_MESSENGER_MessageControl *control)
Destroys a message control and frees its memory fully from the client API.
void clear_queue_messages(struct GNUNET_MESSENGER_QueueMessages *messages)
Clears the queue of messages.
static enum GNUNET_GenericReturnValue iterate_destroy_subscription(void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static enum GNUNET_GenericReturnValue iterate_destroy_link(void *cls, const struct GNUNET_HashCode *key, void *value)
static enum GNUNET_GenericReturnValue iterate_destroy_message(void *cls, const struct GNUNET_HashCode *key, void *value)

References clear_list_tunnels(), clear_queue_messages(), GNUNET_MESSENGER_Room::control, destroy_message_control(), GNUNET_MESSENGER_Room::entries, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), iterate_destroy_link(), iterate_destroy_message(), iterate_destroy_subscription(), GNUNET_MESSENGER_Room::links, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_Room::messages, GNUNET_MESSENGER_Room::queue, GNUNET_MESSENGER_Room::queue_task, GNUNET_MESSENGER_RoomSubscription::room, GNUNET_MESSENGER_Room::sender_id, and GNUNET_MESSENGER_Room::subscriptions.

Referenced by close_handle_room(), GNUNET_MESSENGER_enter_room(), GNUNET_MESSENGER_open_room(), and iterate_destroy_room().

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

◆ is_room_available()

enum GNUNET_GenericReturnValue is_room_available ( const struct GNUNET_MESSENGER_Room room)

Checks whether a room is available to send messages.

Parameters
[in]roomRoom
Returns
GNUNET_YES if the room is available, otherwise GNUNET_NO

Definition at line 182 of file messenger_api_room.c.

183{
184 GNUNET_assert (room);
185
186 if (! get_room_sender_id (room))
187 return GNUNET_NO;
188
189 if ((GNUNET_YES == room->opened) || (room->entries.head))
190 return GNUNET_YES;
191 else
192 return GNUNET_NO;
193}
const struct GNUNET_ShortHashCode * get_room_sender_id(const struct GNUNET_MESSENGER_Room *room)
Returns the member id of the room's sender.
struct GNUNET_MESSENGER_ListTunnel * head

References GNUNET_MESSENGER_Room::entries, get_room_sender_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_ListTunnels::head, GNUNET_MESSENGER_Room::opened, and GNUNET_MESSENGER_RoomSubscription::room.

Referenced by dequeue_message_from_room(), dequeue_messages_from_room(), and enqueue_message_to_room().

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

◆ get_room_handle()

struct GNUNET_MESSENGER_Handle * get_room_handle ( struct GNUNET_MESSENGER_Room room)

Returns the messenger handle of the room.

Parameters
[in,out]roomRoom
Returns
Messenger handle or NULL

Definition at line 197 of file messenger_api_room.c.

198{
199 GNUNET_assert (room);
200
201 return room->handle;
202}

References GNUNET_assert, and GNUNET_MESSENGER_Room::handle.

Referenced by process_message_control(), and task_message_control().

Here is the caller graph for this function:

◆ get_room_sender_id()

const struct GNUNET_ShortHashCode * get_room_sender_id ( const struct GNUNET_MESSENGER_Room room)

Returns the member id of the room's sender.

Parameters
[in]roomRoom
Returns
Member id or NULL

Definition at line 206 of file messenger_api_room.c.

207{
208 GNUNET_assert (room);
209
210 return room->sender_id;
211}

References GNUNET_assert, and GNUNET_MESSENGER_Room::sender_id.

Referenced by get_handle_contact(), handle_member_id(), handle_miss_message(), is_room_available(), and send_message_to_room().

Here is the caller graph for this function:

◆ set_room_sender_id()

void set_room_sender_id ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_ShortHashCode id 
)

Sets the member id of the room's sender to a specific id or NULL.

Parameters
[in,out]roomRoom
[in]idMember id or NULL

Definition at line 215 of file messenger_api_room.c.

217{
218 GNUNET_assert (room);
219
220 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set member id for room: %s\n",
221 GNUNET_h2s (&(room->key)));
222
223 if (! id)
224 {
225 if (room->sender_id)
226 GNUNET_free (room->sender_id);
227
228 room->sender_id = NULL;
229 return;
230 }
231
232 if (! room->sender_id)
234
235 GNUNET_memcpy (room->sender_id, id, sizeof(struct GNUNET_ShortHashCode));
236}
#define GNUNET_log(kind,...)
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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_MESSENGER_Room::key, and GNUNET_MESSENGER_Room::sender_id.

Referenced by handle_id_message(), and handle_member_id().

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

◆ get_room_message()

const struct GNUNET_MESSENGER_Message * get_room_message ( const struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash 
)

Returns a message locally stored from a map for a given hash in a room.

If no matching message is found, NULL gets returned.

Parameters
[in]roomRoom
[in]hashHash of message
Returns
Message or NULL

Definition at line 240 of file messenger_api_room.c.

242{
244
245 GNUNET_assert ((room) && (hash));
246
247 entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
248
249 if ((! entry) || (GNUNET_YES != entry->completed))
250 return NULL;
251
252 return entry->message;
253}
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 completed

References GNUNET_MESSENGER_RoomMessageEntry::completed, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_YES, GNUNET_MESSENGER_RoomMessageEntry::message, and GNUNET_MESSENGER_Room::messages.

Referenced by GNUNET_MESSENGER_get_message().

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

◆ get_room_sender()

struct GNUNET_MESSENGER_Contact * get_room_sender ( const struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash 
)

Returns a messages sender locally stored from a map for a given hash in a room.

If no matching message is found, NULL gets returned.

Parameters
[in]roomRoom
[in]hashHash of message
Returns
Contact of sender or NULL

Definition at line 257 of file messenger_api_room.c.

259{
261
262 GNUNET_assert ((room) && (hash));
263
264 entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
265
266 if ((! entry) || (GNUNET_YES != entry->completed))
267 return NULL;
268
269 return entry->sender;
270}
struct GNUNET_MESSENGER_Contact * sender

References GNUNET_MESSENGER_RoomMessageEntry::completed, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_YES, GNUNET_MESSENGER_Room::messages, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by GNUNET_MESSENGER_get_sender().

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

◆ get_room_recipient()

struct GNUNET_MESSENGER_Contact * get_room_recipient ( const struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash 
)

Returns a messages recipient locally stored from a map for a given hash in a room.

If no matching message is found or the message has not been privately received, NULL gets returned.

Parameters
[in]roomRoom
[in]hashHash of message
Returns
Contact of recipient or NULL

Definition at line 274 of file messenger_api_room.c.

276{
278
279 GNUNET_assert ((room) && (hash));
280
281 entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
282
283 if ((! entry) || (GNUNET_YES != entry->completed))
284 return NULL;
285
286 return entry->recipient;
287}
struct GNUNET_MESSENGER_Contact * recipient

References GNUNET_MESSENGER_RoomMessageEntry::completed, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_YES, GNUNET_MESSENGER_Room::messages, and GNUNET_MESSENGER_RoomMessageEntry::recipient.

Referenced by GNUNET_MESSENGER_get_recipient().

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

◆ delete_room_message()

void delete_room_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
const struct GNUNET_TIME_Relative  delay 
)

Deletes a message with a given hash inside a room under a specific delay.

Parameters
[in,out]roomRoom
[in]hashHash of message
[in]delayDelay of deletion

Definition at line 291 of file messenger_api_room.c.

294{
295 struct GNUNET_MESSENGER_Message *message;
296
297 GNUNET_assert ((room) && (hash));
298
299 message = create_message_delete (hash, delay);
300
301 if (! message)
302 {
304 "Sending deletion aborted: Message creation failed!\n");
305 return;
306 }
307
308 enqueue_message_to_room (room, message, NULL);
309}
@ GNUNET_ERROR_TYPE_WARNING
void enqueue_message_to_room(struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Message *message, struct GNUNET_MESSENGER_Message *transcript)
struct GNUNET_MESSENGER_Message * create_message_delete(const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
Creates and allocates a new delete message containing the hash of a message to delete after a specifi...

References create_message_delete(), enqueue_message_to_room(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by GNUNET_MESSENGER_delete_message(), and handle_delete_message().

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

◆ callback_room_message()

void callback_room_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash 
)

Executes the message callback for a given hash in a room.

Parameters
[in,out]roomRoom
[in]hashHash of message

Definition at line 313 of file messenger_api_room.c.

315{
318
319 GNUNET_assert ((room) && (hash));
320
321 handle = room->handle;
322 if (! handle)
323 return;
324
325 entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
326 if (! entry)
327 return;
328
329 if (handle->msg_callback)
330 handle->msg_callback (handle->msg_cls, room,
331 entry->sender,
332 entry->recipient,
333 entry->message,
334 hash,
335 entry->flags);
336
339}
@ GNUNET_MESSENGER_FLAG_UPDATE
The update flag.
enum GNUNET_MESSENGER_MessageFlags flags

References GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_MESSENGER_FLAG_UPDATE, handle, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, GNUNET_MESSENGER_RoomMessageEntry::recipient, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_delete_message(), handle_message(), and handle_message_control().

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

◆ handle_message()

static void handle_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 681 of file messenger_api_room.c.

684{
685 GNUNET_assert ((room) && (hash) && (entry));
686
687 switch (entry->message->header.kind)
688 {
690 handle_join_message (room, hash, entry);
691 break;
693 handle_leave_message (room, hash, entry);
694 break;
696 handle_name_message (room, hash, entry);
697 break;
699 handle_key_message (room, hash, entry);
700 break;
702 handle_id_message (room, hash, entry);
703 break;
705 handle_miss_message (room, hash, entry);
706 break;
708 handle_private_message (room, hash, entry);
709 break;
711 handle_delete_message (room, hash, entry);
712 break;
714 handle_transcript_message (room, hash, entry);
715 break;
716 default:
717 break;
718 }
719
721 callback_room_message (room, hash);
722}
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_PRIVATE
The private kind.
@ GNUNET_MESSENGER_KIND_NAME
The name kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
@ GNUNET_MESSENGER_KIND_TRANSCRIPT
The transcript kind.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
@ GNUNET_MESSENGER_KIND_DELETE
The delete kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
static void handle_name_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_id_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_private_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
void callback_room_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Executes the message callback for a given hash in a room.
static void handle_join_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_leave_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_miss_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_transcript_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_key_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
static void handle_delete_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_MESSENGER_MessageHeader header
Header.

References callback_room_message(), GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_MESSENGER_FLAG_UPDATE, GNUNET_MESSENGER_KIND_DELETE, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MESSENGER_KIND_TRANSCRIPT, handle_delete_message(), handle_id_message(), handle_join_message(), handle_key_message(), handle_leave_message(), handle_miss_message(), handle_name_message(), handle_private_message(), handle_transcript_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_RoomMessageEntry::message.

Referenced by handle_private_message(), handle_room_message(), and handle_transcript_message().

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

◆ handle_join_message()

static void handle_join_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 349 of file messenger_api_room.c.

352{
353 GNUNET_assert ((room) && (hash) && (entry));
354
355 if (! entry->sender)
356 {
357 struct GNUNET_MESSENGER_ContactStore *store;
359
360 store = get_handle_contact_store (room->handle);
361
362 get_context_from_member (&(room->key), &(entry->message->header.sender_id),
363 &context);
364
365 entry->sender = get_store_contact (store, &context,
366 &(entry->message->body.join.key));
367 }
368
370 room->members, &(entry->message->header.sender_id), entry->sender)) &&
372 &(entry->message->header
373 .sender_id),
374 entry->sender,
377}
static pa_context * context
Pulseaudio context.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int GNUNET_CONTAINER_multishortmap_contains_value(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Check if the map contains the given value under the given key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_OK
void increase_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Increases the reference counter of a given contact which is zero as default.
void get_context_from_member(const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *id, struct GNUNET_HashCode *context)
Calculates the context hash of a member in a room and returns it.
struct GNUNET_MESSENGER_Contact * get_store_contact(struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context, const struct GNUNET_CRYPTO_PublicKey *pubkey)
Returns a contact using a specific public key.
struct GNUNET_MESSENGER_ContactStore * get_handle_contact_store(struct GNUNET_MESSENGER_Handle *handle)
Returns the used contact store of a given handle.
struct GNUNET_MESSENGER_MessageJoin join
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_CRYPTO_PublicKey key
The senders public key to verify its signatures.
struct GNUNET_MESSENGER_MessageBody body
Body.

References GNUNET_MESSENGER_Message::body, context, get_context_from_member(), get_handle_contact_store(), get_store_contact(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_contains_value(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, increase_contact_rc(), GNUNET_MESSENGER_MessageBody::join, GNUNET_MESSENGER_MessageJoin::key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_RoomMessageEntry::sender, and GNUNET_MESSENGER_MessageHeader::sender_id.

Referenced by handle_message().

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

◆ handle_leave_message()

static void handle_leave_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 381 of file messenger_api_room.c.

384{
385 GNUNET_assert ((room) && (hash) && (entry));
386
387 if ((! entry->sender) ||
389 &(entry->message->
390 header.sender_id),
391 entry->sender)))
392 return;
393
394 if (GNUNET_YES == decrease_contact_rc (entry->sender))
396 "A contact does not share any room with you anymore!\n");
397}
int GNUNET_CONTAINER_multishortmap_remove(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Remove the given key-value pair from the map.
enum GNUNET_GenericReturnValue decrease_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Decreases the reference counter if possible (can not underflow!) of a given contact and returns GNUNE...

References decrease_contact_rc(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_RoomMessageEntry::message, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_message().

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

◆ handle_name_message()

static void handle_name_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 401 of file messenger_api_room.c.

404{
405 GNUNET_assert ((room) && (hash) && (entry));
406
408 {
409 const char *handle_name;
410
412 "Set rule for using handle name in room: %s\n",
413 GNUNET_h2s (&(room->key)));
414
415 handle_name = get_handle_name (room->handle);
416
417 if ((handle_name) && (0 == strcmp (handle_name,
418 entry->message->body.name.name)))
420 }
421
422 if (! entry->sender)
423 return;
424
425 set_contact_name (entry->sender, entry->message->body.name.name);
426}
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
void set_contact_name(struct GNUNET_MESSENGER_Contact *contact, const char *name)
Changes the current name of a given contact by copying it from the parameter name.
const char * get_handle_name(const struct GNUNET_MESSENGER_Handle *handle)
Returns the current name of a given handle or NULL if no valid name was assigned yet.
struct GNUNET_MESSENGER_MessageName name
char * name
The new name which replaces the current senders name.

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_RoomMessageEntry::flags, get_handle_name(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_FLAG_SENT, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_MessageName::name, GNUNET_MESSENGER_MessageBody::name, GNUNET_MESSENGER_RoomMessageEntry::sender, set_contact_name(), and GNUNET_MESSENGER_Room::use_handle_name.

Referenced by handle_message().

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

◆ handle_key_message()

static void handle_key_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 430 of file messenger_api_room.c.

433{
435 struct GNUNET_MESSENGER_ContactStore *store;
436
437 GNUNET_assert ((room) && (hash) && (entry));
438
439 if (! entry->sender)
440 return;
441
442 get_context_from_member (&(room->key), &(entry->message->header.sender_id),
443 &context);
444
445 store = get_handle_contact_store (room->handle);
446
447 update_store_contact (store, entry->sender, &context, &context,
448 &(entry->message->body.key.key));
449}
void update_store_contact(struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact *contact, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *next_context, const struct GNUNET_CRYPTO_PublicKey *pubkey)
Moves a contact from the store to another location matching a given public key and member context.
struct GNUNET_MESSENGER_MessageKey key
struct GNUNET_CRYPTO_PublicKey key
The new public key which replaces the current senders public key.

References GNUNET_MESSENGER_Message::body, context, get_context_from_member(), get_handle_contact_store(), GNUNET_assert, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageKey::key, GNUNET_MESSENGER_MessageBody::key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_RoomMessageEntry::sender, GNUNET_MESSENGER_MessageHeader::sender_id, and update_store_contact().

Referenced by handle_message().

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

◆ handle_id_message()

static void handle_id_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 453 of file messenger_api_room.c.

456{
457 struct GNUNET_HashCode context, next_context;
458 struct GNUNET_MESSENGER_ContactStore *store;
459
460 GNUNET_assert ((room) && (hash) && (entry));
461
463 set_room_sender_id (room, &(entry->message->body.id.id));
464
465 if ((! entry->sender) ||
467 &(entry->message->
468 header.sender_id),
469 entry->sender)) ||
471 &(entry->message->body.
472 id.id),
473 entry->sender,
475
476 return;
477
478 get_context_from_member (&(room->key), &(entry->message->header.sender_id),
479 &context);
480 get_context_from_member (&(room->key), &(entry->message->body.id.id),
481 &next_context);
482
483 store = get_handle_contact_store (room->handle);
484
485 update_store_contact (store, entry->sender, &context, &next_context,
486 get_contact_key (entry->sender));
487}
const struct GNUNET_CRYPTO_PublicKey * get_contact_key(const struct GNUNET_MESSENGER_Contact *contact)
Returns the public key of a given contact.
void set_room_sender_id(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_ShortHashCode *id)
Sets the member id of the room's sender to a specific id or NULL.
struct GNUNET_MESSENGER_MessageId id
struct GNUNET_ShortHashCode id
The new id which will replace the senders id in a room.

References GNUNET_MESSENGER_Message::body, context, GNUNET_MESSENGER_RoomMessageEntry::flags, get_contact_key(), get_context_from_member(), get_handle_contact_store(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_MESSENGER_FLAG_SENT, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageId::id, GNUNET_MESSENGER_MessageBody::id, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_RoomMessageEntry::sender, GNUNET_MESSENGER_MessageHeader::sender_id, set_room_sender_id(), and update_store_contact().

Referenced by handle_message().

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

◆ handle_miss_message()

static void handle_miss_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 491 of file messenger_api_room.c.

494{
495 struct GNUNET_MESSENGER_ListTunnel *match;
496
497 GNUNET_assert ((room) && (hash) && (entry));
498
499 if (0 == (GNUNET_MESSENGER_FLAG_SENT & entry->flags))
500 return;
501
502 match = find_list_tunnels (&(room->entries), &(entry->message->body.miss.peer), NULL);
503
504 if (match)
505 remove_from_list_tunnels (&(room->entries), match);
506}
struct GNUNET_MESSENGER_ListTunnel * find_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer, size_t *index)
Searches linearly through the list of tunnels peer identities for matching a specific peer identity a...
struct GNUNET_MESSENGER_ListTunnel * remove_from_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, struct GNUNET_MESSENGER_ListTunnel *element)
Removes a specific element from the list of tunnels peer identities and returns the next element in t...
struct GNUNET_MESSENGER_MessageMiss miss
struct GNUNET_PeerIdentity peer
The peer identity of a disconnected door to a room.

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_Room::entries, find_list_tunnels(), GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_ListTunnel::hash, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_MessageBody::miss, GNUNET_MESSENGER_MessageMiss::peer, and remove_from_list_tunnels().

Referenced by handle_message().

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

◆ handle_private_message()

static void handle_private_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 510 of file messenger_api_room.c.

513{
514 struct GNUNET_MESSENGER_Message *private_message;
515
516 GNUNET_assert ((room) && (hash) && (entry));
517
518 private_message = copy_message (entry->message);
519
520 if (! private_message)
521 return;
522
523 if (GNUNET_YES != decrypt_message (private_message,
524 get_handle_key (room->handle)))
525 {
526 destroy_message (private_message);
527 private_message = NULL;
528 }
529
530 if (! private_message)
531 return;
532
533 destroy_message (entry->message);
534
535 entry->recipient = get_handle_contact (room->handle, &(room->key));
536
537 entry->message = private_message;
539
540 if ((entry->sender) && (entry->recipient))
541 handle_message (room, hash, entry);
542}
@ GNUNET_MESSENGER_FLAG_PRIVATE
The private flag.
struct GNUNET_MESSENGER_Contact * get_handle_contact(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Returns the contact of a given handle in a room identified by a given key.
const struct GNUNET_CRYPTO_PrivateKey * get_handle_key(const struct GNUNET_MESSENGER_Handle *handle)
Returns the private key of a given handle.
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
enum GNUNET_GenericReturnValue decrypt_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_PrivateKey *key)
Decrypts a private message using a given private key and replaces its body and kind with the inner en...
static void handle_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_RoomMessageEntry *entry)

References copy_message(), decrypt_message(), destroy_message(), GNUNET_MESSENGER_RoomMessageEntry::flags, get_handle_contact(), get_handle_key(), GNUNET_assert, GNUNET_MESSENGER_FLAG_PRIVATE, GNUNET_YES, GNUNET_MESSENGER_Room::handle, handle_message(), GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_RoomMessageEntry::recipient, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_message().

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

◆ handle_delete_message()

static void handle_delete_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 546 of file messenger_api_room.c.

549{
550 const struct GNUNET_HashCode *target_hash;
552
553 GNUNET_assert ((room) && (hash) && (entry));
554
555 target_hash = &(entry->message->body.deletion.hash);
556
557 if (get_handle_contact (room->handle, &(room->key)) == entry->sender)
558 {
559 struct GNUNET_TIME_Relative delay;
561
563
566
568 action);
569
570 link_room_deletion (room, target_hash, delay, delete_room_message);
571 }
572
573 target = GNUNET_CONTAINER_multihashmap_get (room->messages, target_hash);
574 if (! target)
575 return;
576
577 if (((target->sender != entry->sender) &&
578 (get_handle_contact (room->handle, &(room->key)) != entry->sender)))
579 return;
580
582 callback_room_message (room, target_hash);
583
585 target_hash,
586 target))
587 {
588 destroy_message (target->message);
589 GNUNET_free (target);
590 }
591}
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_MESSENGER_FLAG_DELETE
The delete flag.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:630
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:739
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:452
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:423
void link_room_deletion(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay, GNUNET_MESSENGER_RoomLinkDeletion deletion)
Delete all remaining links to a certain message identified by its hash inside a given room and cause ...
void delete_room_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
Deletes a message with a given hash inside a room under a specific delay.
struct GNUNET_MESSENGER_MessageDelete deletion
struct GNUNET_HashCode hash
The hash of the message to delete.
struct GNUNET_TIME_RelativeNBO delay
The delay of the delete operation to get processed.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the message.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.

References consensus-simulation::action, GNUNET_MESSENGER_Message::body, callback_room_message(), GNUNET_MESSENGER_MessageDelete::delay, delete_room_message(), GNUNET_MESSENGER_MessageBody::deletion, destroy_message(), GNUNET_MESSENGER_RoomMessageEntry::flags, get_handle_contact(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_MESSENGER_FLAG_DELETE, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_ntoh(), GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_MessageDelete::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_Room::key, link_room_deletion(), GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, GNUNET_MESSENGER_RoomMessageEntry::sender, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by handle_message().

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

◆ handle_transcript_message()

static void handle_transcript_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
struct GNUNET_MESSENGER_RoomMessageEntry entry 
)
static

Definition at line 595 of file messenger_api_room.c.

598{
599 const struct GNUNET_HashCode *original_hash;
600 struct GNUNET_MESSENGER_RoomMessageEntry *original;
601 struct GNUNET_MESSENGER_Message *original_message;
602
603 GNUNET_assert ((room) && (hash) && (entry));
604
605 if (get_handle_contact (room->handle, &(room->key)) != entry->sender)
606 return;
607
608 original_hash = &(entry->message->body.transcript.hash);
609
610 original = GNUNET_CONTAINER_multihashmap_get (room->messages, original_hash);
611
612 if (original)
613 goto read_transcript;
614
616
617 if (! original)
618 return;
619
620 original->sender = NULL;
621 original->recipient = NULL;
622
623 original->message = NULL;
625 original->completed = GNUNET_NO;
626
628 original_hash,
629 original,
631 {
632 GNUNET_free (original);
633 return;
634 }
635
636read_transcript:
637 original_message = copy_message (entry->message);
638
639 if (! original_message)
640 return;
641
642 if (GNUNET_YES != read_transcript_message (original_message))
643 {
644 destroy_message (original_message);
645 return;
646 }
647
648 {
649 struct GNUNET_MESSENGER_ContactStore *store;
650
651 store = get_handle_contact_store (room->handle);
652 original->recipient = get_store_contact (store,
653 NULL,
654 &(entry->message->body.transcript.key
655 ));
656 }
657
658 if (original->message)
659 {
662
663 copy_message_header (original_message, &(original->message->header));
664 destroy_message (original->message);
665 }
666
667 original->message = original_message;
668
669 link_room_message (room, hash, original_hash);
670 link_room_message (room, original_hash, hash);
671
672 if ((original->sender) && (original->recipient))
673 {
675 handle_message (room, original_hash, original);
676 }
677}
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...
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
void copy_message_header(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_MessageHeader *header)
Copy message header details from another message to a given message.
enum GNUNET_GenericReturnValue read_transcript_message(struct GNUNET_MESSENGER_Message *message)
Read the original message from a transcript message and replaces its body and kind with the inner enc...
void link_room_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_HashCode *other)
Links a message identified by its hash inside a given room with another message identified by its oth...
struct GNUNET_MESSENGER_MessageTranscript transcript
struct GNUNET_HashCode hash
The hash of the original message.
struct GNUNET_CRYPTO_PublicKey key
The key from the recipient of the original message.

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_RoomMessageEntry::completed, copy_message(), copy_message_header(), destroy_message(), GNUNET_MESSENGER_RoomMessageEntry::flags, get_handle_contact(), get_handle_contact_store(), get_store_contact(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_free, GNUNET_MESSENGER_FLAG_NONE, GNUNET_MESSENGER_FLAG_PRIVATE, GNUNET_MESSENGER_FLAG_UPDATE, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Room::handle, handle_message(), GNUNET_MESSENGER_MessageTranscript::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageTranscript::key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_MessageHeader::kind, link_room_message(), GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, read_transcript_message(), GNUNET_MESSENGER_RoomMessageEntry::recipient, GNUNET_MESSENGER_RoomMessageEntry::sender, and GNUNET_MESSENGER_MessageBody::transcript.

Referenced by handle_message().

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

◆ handle_room_message()

void handle_room_message ( struct GNUNET_MESSENGER_Room room,
struct GNUNET_MESSENGER_Contact sender,
const struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash,
enum GNUNET_MESSENGER_MessageFlags  flags 
)

Handles a message with a given hash in a room for the client API to update members and its information.

The function also stores the message in map locally for access afterwards.

The contact of the message's sender could be updated or even created. It may not be freed or destroyed though! (The contact may still be in use for old messages...)

Parameters
[in,out]roomRoom
[in,out]senderContact of sender
[in]messageMessage
[in]hashHash of message
[in]flagsFlags of message

Definition at line 726 of file messenger_api_room.c.

731{
733
734 GNUNET_assert ((room) && (message) && (hash));
735
736 entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
737
738 if (entry)
739 goto update_entry;
740
742
743 if (! entry)
744 return;
745
746 entry->sender = NULL;
747 entry->recipient = NULL;
748
749 entry->message = NULL;
751 entry->completed = GNUNET_NO;
752
754 entry,
756 {
757 GNUNET_free (entry);
758 return;
759 }
760
761update_entry:
762 entry->sender = sender;
763 entry->flags = flags;
764
765 if (entry->message)
766 {
769
771 }
772 else
773 entry->message = copy_message (message);
774
775 entry->completed = GNUNET_YES;
776
777 handle_message (room, hash, entry);
778}

References GNUNET_MESSENGER_RoomMessageEntry::completed, copy_message(), copy_message_header(), GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_free, GNUNET_MESSENGER_FLAG_NONE, GNUNET_MESSENGER_FLAG_PRIVATE, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_YES, handle_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, GNUNET_MESSENGER_RoomMessageEntry::recipient, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_message_control().

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

◆ update_room_last_message()

void update_room_last_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash 
)

Updates the last message hash of a room for the client API so that new messages can point to the latest message hash while sending.

Parameters
[in,out]roomRoom
[in]hashHash of message

Definition at line 782 of file messenger_api_room.c.

784{
785 GNUNET_assert ((room) && (hash));
786
787 GNUNET_memcpy (&(room->last_message), hash, sizeof(room->last_message));
788}

References GNUNET_assert, GNUNET_memcpy, and GNUNET_MESSENGER_Room::last_message.

Referenced by handle_message_control(), handle_room_close(), handle_room_entry(), handle_room_open(), handle_room_sync(), and send_message_to_room().

Here is the caller graph for this function:

◆ iterate_local_members()

static enum GNUNET_GenericReturnValue iterate_local_members ( void *  cls,
const struct GNUNET_ShortHashCode key,
void *  value 
)
static

Definition at line 799 of file messenger_api_room.c.

802{
804 struct GNUNET_MESSENGER_Contact *contact;
805
806 GNUNET_assert ((cls) && (value));
807
808 call = cls;
809 contact = value;
810
811 return call->callback (call->cls, call->room, contact);
812}
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).

References call, GNUNET_assert, and value.

Referenced by iterate_room_members().

Here is the caller graph for this function:

◆ iterate_room_members()

int iterate_room_members ( struct GNUNET_MESSENGER_Room room,
GNUNET_MESSENGER_MemberCallback  callback,
void *  cls 
)

Iterates through all members of a given room to forward each of them to a selected callback with a custom closure.

Parameters
[in,out]roomRoom
[in]callbackFunction called for each member
[in,out]clsClosure
Returns
Amount of members iterated

Definition at line 816 of file messenger_api_room.c.

819{
821
823
824 if (! callback)
826
827 call.room = room;
828 call.callback = callback;
829 call.cls = cls;
830
832
835 &call);
836}
static enum GNUNET_GenericReturnValue iterate_local_members(void *cls, const struct GNUNET_ShortHashCode *key, void *value)
GNUNET_MESSENGER_MemberCallback callback
struct GNUNET_MESSENGER_Room * room

References call, GNUNET_MESSENGER_MemberCall::callback, GNUNET_MESSENGER_MemberCall::cls, GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterate(), iterate_local_members(), GNUNET_MESSENGER_Room::members, and GNUNET_MESSENGER_MemberCall::room.

Referenced by GNUNET_MESSENGER_iterate_members().

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

◆ iterate_find_member()

static enum GNUNET_GenericReturnValue iterate_find_member ( void *  cls,
const struct GNUNET_ShortHashCode key,
void *  value 
)
static

Definition at line 846 of file messenger_api_room.c.

849{
850 struct GNUNET_MESSENGER_MemberFind *find;
851 struct GNUNET_MESSENGER_Contact *contact;
852
853 GNUNET_assert ((cls) && (value));
854
855 find = cls;
856 contact = value;
857
858 if (contact == find->contact)
859 {
860 find->result = GNUNET_YES;
861 return GNUNET_NO;
862 }
863
864 return GNUNET_YES;
865}
const struct GNUNET_MESSENGER_Contact * contact
enum GNUNET_GenericReturnValue result

References GNUNET_MESSENGER_MemberFind::contact, GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_MemberFind::result, and value.

Referenced by find_room_member().

Here is the caller graph for this function:

◆ find_room_member()

enum GNUNET_GenericReturnValue find_room_member ( const struct GNUNET_MESSENGER_Room room,
const struct GNUNET_MESSENGER_Contact contact 
)

Checks through all members of a given room if a specific contact is found and returns a result depending on that.

Parameters
[in]roomRoom
[in]contact
Returns
GNUNET_YES if found, otherwise GNUNET_NO

Definition at line 869 of file messenger_api_room.c.

871{
872 struct GNUNET_MESSENGER_MemberFind find;
873
874 GNUNET_assert (room);
875
876 find.contact = contact;
877 find.result = GNUNET_NO;
878
880 &find);
881
882 return find.result;
883}
static enum GNUNET_GenericReturnValue iterate_find_member(void *cls, const struct GNUNET_ShortHashCode *key, void *value)

References GNUNET_MESSENGER_MemberFind::contact, GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_NO, iterate_find_member(), GNUNET_MESSENGER_Room::members, and GNUNET_MESSENGER_MemberFind::result.

Referenced by iterate_find_room().

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

◆ find_linked_hash()

static enum GNUNET_GenericReturnValue find_linked_hash ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 887 of file messenger_api_room.c.

890{
891 const struct GNUNET_HashCode **result;
892 struct GNUNET_HashCode *hash;
893
894 GNUNET_assert ((cls) && (value));
895
896 result = cls;
897 hash = value;
898
899 if (0 == GNUNET_CRYPTO_hash_cmp (hash, *result))
900 {
901 *result = NULL;
902 return GNUNET_NO;
903 }
904
905 return GNUNET_YES;
906}
static int result
Global testing status.
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:221

References GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_NO, GNUNET_YES, result, and value.

Referenced by link_room_message().

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

◆ link_room_message()

void link_room_message ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
const struct GNUNET_HashCode other 
)

Links a message identified by its hash inside a given room with another message identified by its other hash.

Linked messages will be deleted automatically, if any linked message to it gets deleted.

Parameters
[in,out]roomRoom
[in]hashHash of message
[in]otherHash of other message

Definition at line 910 of file messenger_api_room.c.

913{
914 const struct GNUNET_HashCode **result;
915 struct GNUNET_HashCode *value;
916
917 GNUNET_assert ((room) && (hash) && (other));
918
919 result = &other;
922
923 if (! *result)
924 return;
925
926 value = GNUNET_memdup (other, sizeof(struct GNUNET_HashCode));
927 if (! value)
928 return;
929
932
934}
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.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
static enum GNUNET_GenericReturnValue find_linked_hash(void *cls, const struct GNUNET_HashCode *key, void *value)

References find_linked_hash(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_free, GNUNET_memdup, GNUNET_OK, GNUNET_MESSENGER_Room::links, result, and value.

Referenced by dequeue_message_from_room(), and handle_transcript_message().

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

◆ clear_linked_hash()

static enum GNUNET_GenericReturnValue clear_linked_hash ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 946 of file messenger_api_room.c.

949{
950 struct GNUNET_HashCode **linked;
951 struct GNUNET_HashCode *hash;
952
953 GNUNET_assert ((cls) && (value));
954
955 linked = cls;
956 hash = value;
957
958 if (0 != GNUNET_CRYPTO_hash_cmp (*linked, hash))
959 return GNUNET_YES;
960
961 *linked = hash;
962 return GNUNET_NO;
963}

References GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_NO, GNUNET_YES, and value.

Referenced by delete_linked_hash().

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

◆ delete_linked_hash()

static enum GNUNET_GenericReturnValue delete_linked_hash ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 967 of file messenger_api_room.c.

970{
972 struct GNUNET_HashCode *hash;
973 struct GNUNET_HashCode key_value;
974 struct GNUNET_HashCode *linked;
975
976 GNUNET_assert ((cls) && (key) && (value));
977
978 info = cls;
979 hash = value;
980
981 GNUNET_memcpy (&key_value, key, sizeof (key_value));
982
983 linked = &key_value;
985 clear_linked_hash, &linked);
986
987 if ((linked != &key_value) &&
989 hash, linked)))
990 GNUNET_free (linked);
991
992 if (info->deletion)
993 info->deletion (info->room, hash, info->delay);
994
995 GNUNET_free (hash);
996 return GNUNET_YES;
997}
#define info
static enum GNUNET_GenericReturnValue clear_linked_hash(void *cls, const struct GNUNET_HashCode *key, void *value)

References clear_linked_hash(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_memcpy, GNUNET_YES, info, key, and value.

Referenced by link_room_deletion().

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

◆ link_room_deletion()

void link_room_deletion ( struct GNUNET_MESSENGER_Room room,
const struct GNUNET_HashCode hash,
const struct GNUNET_TIME_Relative  delay,
GNUNET_MESSENGER_RoomLinkDeletion  deletion 
)

Delete all remaining links to a certain message identified by its hash inside a given room and cause a deletion process to all of the linked messages.

Parameters
[in,out]roomRoom
[in]hashHash of message
[in]delayDelay for linked deletion
[in]deletionFunction called for each linked deletion

Definition at line 1001 of file messenger_api_room.c.

1005{
1007
1008 GNUNET_assert ((room) && (hash));
1009
1010 info.room = room;
1011 info.delay = delay;
1012 info.deletion = deletion;
1013
1017}
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.
static enum GNUNET_GenericReturnValue delete_linked_hash(void *cls, const struct GNUNET_HashCode *key, void *value)
struct GNUNET_MESSENGER_Room * room
GNUNET_MESSENGER_RoomLinkDeletion deletion

References GNUNET_MESSENGER_RoomLinkDeletionInfo::delay, delete_linked_hash(), GNUNET_MESSENGER_RoomLinkDeletionInfo::deletion, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_remove_all(), info, GNUNET_MESSENGER_Room::links, and GNUNET_MESSENGER_RoomLinkDeletionInfo::room.

Referenced by handle_delete_message().

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