#include "messenger_api_room.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "messenger_api.h"
#include "messenger_api_contact_store.h"
#include "messenger_api_handle.h"
#include "messenger_api_message.h"
#include "messenger_api_message_control.h"
#include "messenger_api_message_kind.h"
#include <string.h>

Include dependency graph for messenger_api_room.c:

Data Structures
struct	GNUNET_MESSENGER_MemberCall

struct	GNUNET_MESSENGER_MemberFind

struct	GNUNET_MESSENGER_RoomLinkDeletionInfo

Functions
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. 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_Handle *	get_room_handle (struct GNUNET_MESSENGER_Room *room)
	Returns the messenger handle of the room. More...

const struct GNUNET_ShortHashCode *	get_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_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. More...

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

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. 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]	handle	Handle
[in]	key	Key of room

Returns: New room

Definition at line 41 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((handle) && (key));
 
  room = GNUNET_new (struct GNUNET_MESSENGER_Room);
  room->handle = handle;
  
  GNUNET_memcpy (&(room->key), key, sizeof(*key));
 
  memset (&(room->last_message), 0, sizeof(room->last_message));
 
  room->opened = GNUNET_NO;
  room->use_handle_name = GNUNET_YES;
  room->wait_for_sync = GNUNET_NO;
 
  room->sender_id = NULL;
 
  init_list_tunnels (&(room->entries));
 
  room->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
  room->links = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  room->subscriptions = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
 
  init_queue_messages (&(room->queue));
  room->queue_task = NULL;
 
  room->control = create_message_control (room);
 
  return room;
}

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.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert (value);
 
  entry = value;
 
  destroy_message (entry->message);
  GNUNET_free (entry);
  return GNUNET_YES;
}

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.

{
  struct GNUNET_HashCode *hash;
 
  GNUNET_assert (value);
 
  hash = value;
 
  GNUNET_free (hash);
  return GNUNET_YES;
}

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.

{
  struct GNUNET_MESSENGER_RoomSubscription *subscription;
 
  GNUNET_assert (value);
  
  subscription = value;
 
  if (subscription->task)
    GNUNET_SCHEDULER_cancel (subscription->task);
 
  if (subscription->message)
    destroy_message (subscription->message);
 
  GNUNET_free (subscription);
  return GNUNET_YES;
}

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] room Room

Definition at line 134 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  destroy_message_control (room->control);
 
  if (room->queue_task)
    GNUNET_SCHEDULER_cancel (room->queue_task);
 
  clear_queue_messages (&(room->queue));
  clear_list_tunnels (&(room->entries));
 
  if (room->subscriptions)
  {
    GNUNET_CONTAINER_multishortmap_iterate (room->subscriptions,
                                            iterate_destroy_subscription,
                                            NULL);
    
    GNUNET_CONTAINER_multishortmap_destroy (room->subscriptions);
  }
 
  if (room->messages)
  {
    GNUNET_CONTAINER_multihashmap_iterate (room->messages,
                                           iterate_destroy_message, NULL);
 
    GNUNET_CONTAINER_multihashmap_destroy (room->messages);
  }
 
  if (room->members)
    GNUNET_CONTAINER_multishortmap_destroy (room->members);
 
  if (room->links)
  {
    GNUNET_CONTAINER_multihashmap_iterate (room->links,
                                           iterate_destroy_link, NULL);
 
    GNUNET_CONTAINER_multihashmap_destroy (room->links);
  }
 
  if (room->sender_id)
    GNUNET_free (room->sender_id);
 
  GNUNET_free (room);
}

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] room Room

Returns: GNUNET_YES if the room is available, otherwise GNUNET_NO

Definition at line 182 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  if (! get_room_sender_id (room))
    return GNUNET_NO;
 
  if ((GNUNET_YES == room->opened) || (room->entries.head))
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

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] room Room

Returns: Messenger handle or NULL

Definition at line 197 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  return room->handle;
}

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] room Room

Returns: Member id or NULL

Definition at line 206 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  return room->sender_id;
}

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]	room	Room
[in]	id	Member id or NULL

Definition at line 215 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set member id for room: %s\n",
              GNUNET_h2s (&(room->key)));
 
  if (! id)
  {
    if (room->sender_id)
      GNUNET_free (room->sender_id);
 
    room->sender_id = NULL;
    return;
  }
 
  if (! room->sender_id)
    room->sender_id = GNUNET_new (struct GNUNET_ShortHashCode);
 
  GNUNET_memcpy (room->sender_id, id, sizeof(struct GNUNET_ShortHashCode));
}

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]	room	Room
[in]	hash	Hash of message

Returns: Message or NULL

Definition at line 240 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (hash));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
 
  if ((! entry) || (GNUNET_YES != entry->completed))
    return NULL;
 
  return entry->message;
}

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]	room	Room
[in]	hash	Hash of message

Returns: Contact of sender or NULL

Definition at line 257 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (hash));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
 
  if ((! entry) || (GNUNET_YES != entry->completed))
    return NULL;
 
  return entry->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]	room	Room
[in]	hash	Hash of message

Returns: Contact of recipient or NULL

Definition at line 274 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (hash));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
 
  if ((! entry) || (GNUNET_YES != entry->completed))
    return NULL;
 
  return entry->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]	room	Room
[in]	hash	Hash of message
[in]	delay	Delay of deletion

Definition at line 291 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((room) && (hash));
  
  message = create_message_delete (hash, delay);
 
  if (! message)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sending deletion aborted: Message creation failed!\n");
    return;
  }
 
  enqueue_message_to_room (room, message, NULL);
}

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]	room	Room
[in]	hash	Hash of message

Definition at line 313 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Handle *handle;
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (hash));
 
  handle = room->handle;
  if (! handle)
    return;
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
  if (! entry)
    return;
 
  if (handle->msg_callback)
    handle->msg_callback (handle->msg_cls, room,
                          entry->sender,
                          entry->recipient,
                          entry->message,
                          hash,
                          entry->flags);
 
  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
    entry->flags ^= GNUNET_MESSENGER_FLAG_UPDATE;
}

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.

{
  GNUNET_assert ((room) && (hash) && (entry));
 
  switch (entry->message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    handle_join_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    handle_leave_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_NAME:
    handle_name_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    handle_key_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_ID:
    handle_id_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_MISS:
    handle_miss_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    handle_private_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_DELETE:
    handle_delete_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    handle_transcript_message (room, hash, entry);
    break;
  default:
    break;
  }
 
  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
    callback_room_message (room, hash);
}

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.

{
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (! entry->sender)
  {
    struct GNUNET_MESSENGER_ContactStore *store;
    struct GNUNET_HashCode context;
 
    store = get_handle_contact_store (room->handle);
 
    get_context_from_member (&(room->key), &(entry->message->header.sender_id),
                             &context);
 
    entry->sender = get_store_contact (store, &context,
                                       &(entry->message->body.join.key));
  }
 
  if ((GNUNET_YES != GNUNET_CONTAINER_multishortmap_contains_value (
         room->members, &(entry->message->header.sender_id), entry->sender)) &&
      (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (room->members,
                                                        &(entry->message->header
                                                          .sender_id),
                                                        entry->sender,
                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
    increase_contact_rc (entry->sender);
}

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.

{
  GNUNET_assert ((room) && (hash) && (entry));
 
  if ((! entry->sender) ||
      (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->members,
                                                            &(entry->message->
                                                              header.sender_id),
                                                            entry->sender)))
    return;
 
  if (GNUNET_YES == decrease_contact_rc (entry->sender))
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "A contact does not share any room with you anymore!\n");
}

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.

{
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
  {
    const char *handle_name;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Set rule for using handle name in room: %s\n",
                GNUNET_h2s (&(room->key)));
 
    handle_name = get_handle_name (room->handle);
 
    if ((handle_name) && (0 == strcmp (handle_name,
                                       entry->message->body.name.name)))
      room->use_handle_name = GNUNET_YES;
  }
 
  if (! entry->sender)
    return;
 
  set_contact_name (entry->sender, entry->message->body.name.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.

{
  struct GNUNET_HashCode context;
  struct GNUNET_MESSENGER_ContactStore *store;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (! entry->sender)
    return;
 
  get_context_from_member (&(room->key), &(entry->message->header.sender_id),
                           &context);
 
  store = get_handle_contact_store (room->handle);
 
  update_store_contact (store, entry->sender, &context, &context,
                        &(entry->message->body.key.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.

{
  struct GNUNET_HashCode context, next_context;
  struct GNUNET_MESSENGER_ContactStore *store;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
    set_room_sender_id (room, &(entry->message->body.id.id));
 
  if ((! entry->sender) ||
      (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->members,
                                                            &(entry->message->
                                                              header.sender_id),
                                                            entry->sender)) ||
      (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (room->members,
                                                        &(entry->message->body.
                                                          id.id),
                                                        entry->sender,
                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
 
    return;
 
  get_context_from_member (&(room->key), &(entry->message->header.sender_id),
                           &context);
  get_context_from_member (&(room->key), &(entry->message->body.id.id),
                           &next_context);
 
  store = get_handle_contact_store (room->handle);
 
  update_store_contact (store, entry->sender, &context, &next_context,
                        get_contact_key (entry->sender));
}

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.

{
  struct GNUNET_MESSENGER_ListTunnel *match;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (0 == (GNUNET_MESSENGER_FLAG_SENT & entry->flags))
    return;
 
  match = find_list_tunnels (&(room->entries), &(entry->message->body.miss.peer), NULL);
 
  if (match)
    remove_from_list_tunnels (&(room->entries), match);
}

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.

{
  struct GNUNET_MESSENGER_Message *private_message;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  private_message = copy_message (entry->message);
 
  if (! private_message)
    return;
 
  if (GNUNET_YES != decrypt_message (private_message,
                                     get_handle_key (room->handle)))
  {
    destroy_message (private_message);
    private_message = NULL;
  }
 
  if (! private_message)
    return;
 
  destroy_message (entry->message);
 
  entry->recipient = get_handle_contact (room->handle, &(room->key));
 
  entry->message = private_message;
  entry->flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
 
  if ((entry->sender) && (entry->recipient))
    handle_message (room, hash, 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.

{
  const struct GNUNET_HashCode *target_hash;
  struct GNUNET_MESSENGER_RoomMessageEntry *target;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  target_hash = &(entry->message->body.deletion.hash);
 
  if (get_handle_contact (room->handle, &(room->key)) == entry->sender)
  {
    struct GNUNET_TIME_Relative delay;
    struct GNUNET_TIME_Absolute action;
 
    delay = GNUNET_TIME_relative_ntoh (entry->message->body.deletion.delay);
 
    action = GNUNET_TIME_absolute_ntoh (entry->message->header.timestamp);
    action = GNUNET_TIME_absolute_add (action, delay);
 
    delay = GNUNET_TIME_absolute_get_difference (GNUNET_TIME_absolute_get (),
                                                 action);
 
    link_room_deletion (room, target_hash, delay, delete_room_message);
  }
 
  target = GNUNET_CONTAINER_multihashmap_get (room->messages, target_hash);
  if (! target)
    return;
 
  if (((target->sender != entry->sender) &&
       (get_handle_contact (room->handle, &(room->key)) != entry->sender)))
    return;
 
  target->flags |= GNUNET_MESSENGER_FLAG_DELETE;
  callback_room_message (room, target_hash);
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->messages,
                                                          target_hash,
                                                          target))
  {
    destroy_message (target->message);
    GNUNET_free (target);
  }
}

References warningfilter::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.

{
  const struct GNUNET_HashCode *original_hash;
  struct GNUNET_MESSENGER_RoomMessageEntry *original;
  struct GNUNET_MESSENGER_Message *original_message;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (get_handle_contact (room->handle, &(room->key)) != entry->sender)
    return;
 
  original_hash = &(entry->message->body.transcript.hash);
 
  original = GNUNET_CONTAINER_multihashmap_get (room->messages, original_hash);
 
  if (original)
    goto read_transcript;
 
  original = GNUNET_new (struct GNUNET_MESSENGER_RoomMessageEntry);
 
  if (! original)
    return;
 
  original->sender = NULL;
  original->recipient = NULL;
 
  original->message = NULL;
  original->flags = GNUNET_MESSENGER_FLAG_NONE;
  original->completed = GNUNET_NO;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages,
                                                      original_hash,
                                                      original,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    GNUNET_free (original);
    return;
  }
 
read_transcript:
  original_message = copy_message (entry->message);
 
  if (! original_message)
    return;
 
  if (GNUNET_YES != read_transcript_message (original_message))
  {
    destroy_message (original_message);
    return;
  }
 
  {
    struct GNUNET_MESSENGER_ContactStore *store;
 
    store = get_handle_contact_store (room->handle);
    original->recipient = get_store_contact (store,
                                            NULL,
                                            &(entry->message->body.transcript.key
                                              ));
  }
 
  if (original->message)
  {
    if (GNUNET_MESSENGER_KIND_PRIVATE == original->message->header.kind)
      original->flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
 
    copy_message_header (original_message, &(original->message->header));
    destroy_message (original->message);
  }
 
  original->message = original_message;
 
  link_room_message (room, hash, original_hash);
  link_room_message (room, original_hash, hash);
 
  if ((original->sender) && (original->recipient))
  {
    original->flags |= GNUNET_MESSENGER_FLAG_UPDATE;
    handle_message (room, original_hash, original);
  }
}

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]	room	Room
[in,out]	sender	Contact of sender
[in]	message	Message
[in]	hash	Hash of message
[in]	flags	Flags of message

Definition at line 726 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (message) && (hash));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
 
  if (entry)
    goto update_entry;
 
  entry = GNUNET_new (struct GNUNET_MESSENGER_RoomMessageEntry);
 
  if (! entry)
    return;
 
  entry->sender = NULL;
  entry->recipient = NULL;
 
  entry->message = NULL;
  entry->flags = GNUNET_MESSENGER_FLAG_NONE;
  entry->completed = GNUNET_NO;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash,
                                                      entry,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    GNUNET_free (entry);
    return;
  }
 
update_entry:
  entry->sender = sender;
  entry->flags = flags;
 
  if (entry->message)
  {
    if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
      entry->flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
 
    copy_message_header (entry->message, &(message->header));
  }
  else
    entry->message = copy_message (message);
 
  entry->completed = GNUNET_YES;
 
  handle_message (room, hash, entry);
}

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]	room	Room
[in]	hash	Hash of message

Definition at line 782 of file messenger_api_room.c.

{
  GNUNET_assert ((room) && (hash));
 
  GNUNET_memcpy (&(room->last_message), hash, sizeof(room->last_message));
}

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.

{
  struct GNUNET_MESSENGER_MemberCall *call;
  struct GNUNET_MESSENGER_Contact *contact;
 
  GNUNET_assert ((cls) && (value));
 
  call = cls;
  contact = value;
 
  return call->callback (call->cls, call->room, contact);
}

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]	room	Room
[in]	callback	Function called for each member
[in,out]	cls	Closure

Returns: Amount of members iterated

Definition at line 816 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_MemberCall call;
 
  GNUNET_assert (room);
 
  if (! callback)
    return GNUNET_CONTAINER_multishortmap_iterate (room->members, NULL, NULL);
 
  call.room = room;
  call.callback = callback;
  call.cls = cls;
 
  GNUNET_assert (callback);
 
  return GNUNET_CONTAINER_multishortmap_iterate (room->members,
                                                 iterate_local_members,
                                                 &call);
}

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.

{
  struct GNUNET_MESSENGER_MemberFind *find;
  struct GNUNET_MESSENGER_Contact *contact;
 
  GNUNET_assert ((cls) && (value));
 
  find = cls;
  contact = value;
 
  if (contact == find->contact)
  {
    find->result = GNUNET_YES;
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

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]	room	Room
[in]	contact

Returns: GNUNET_YES if found, otherwise GNUNET_NO

Definition at line 869 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_MemberFind find;
 
  GNUNET_assert (room);
 
  find.contact = contact;
  find.result = GNUNET_NO;
 
  GNUNET_CONTAINER_multishortmap_iterate (room->members, iterate_find_member,
                                          &find);
 
  return find.result;
}

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.

{
  const struct GNUNET_HashCode **result;
  struct GNUNET_HashCode *hash;
 
  GNUNET_assert ((cls) && (value));
 
  result = cls;
  hash = value;
 
  if (0 == GNUNET_CRYPTO_hash_cmp (hash, *result))
  {
    *result = NULL;
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

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]	room	Room
[in]	hash	Hash of message
[in]	other	Hash of other message

Definition at line 910 of file messenger_api_room.c.

{
  const struct GNUNET_HashCode **result;
  struct GNUNET_HashCode *value;
 
  GNUNET_assert ((room) && (hash) && (other));
 
  result = &other;
  GNUNET_CONTAINER_multihashmap_get_multiple (room->links, hash,
                                              find_linked_hash, result);
 
  if (! *result)
    return;
 
  value = GNUNET_memdup (other, sizeof(struct GNUNET_HashCode));
  if (! value)
    return;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->links, hash, value,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
 
    GNUNET_free (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.

{
  struct GNUNET_HashCode **linked;
  struct GNUNET_HashCode *hash;
 
  GNUNET_assert ((cls) && (value));
 
  linked = cls;
  hash = value;
 
  if (0 != GNUNET_CRYPTO_hash_cmp (*linked, hash))
    return GNUNET_YES;
 
  *linked = hash;
  return GNUNET_NO;
}

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.

{
  struct GNUNET_MESSENGER_RoomLinkDeletionInfo *info;
  struct GNUNET_HashCode *hash;
  struct GNUNET_HashCode key_value;
  struct GNUNET_HashCode *linked;
 
  GNUNET_assert ((cls) && (key) && (value));
 
  info = cls;
  hash = value;
  
  GNUNET_memcpy (&key_value, key, sizeof (key_value));
 
  linked = &key_value;
  GNUNET_CONTAINER_multihashmap_get_multiple (info->room->links, hash,
                                              clear_linked_hash, &linked);
 
  if ((linked != &key_value) &&
      (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (info->room->links,
                                                           hash, linked)))
    GNUNET_free (linked);
 
  if (info->deletion)
    info->deletion (info->room, hash, info->delay);
 
  GNUNET_free (hash);
  return GNUNET_YES;
}

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]	room	Room
[in]	hash	Hash of message
[in]	delay	Delay for linked deletion
[in]	deletion	Function called for each linked deletion

Definition at line 1001 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomLinkDeletionInfo info;
 
  GNUNET_assert ((room) && (hash));
 
  info.room = room;
  info.delay = delay;
  info.deletion = deletion;
 
  GNUNET_CONTAINER_multihashmap_get_multiple (room->links, hash,
                                              delete_linked_hash, &info);
  GNUNET_CONTAINER_multihashmap_remove_all (room->links, hash);
}

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:

Data Structures

Functions

Function Documentation

◆ create_room()

◆ iterate_destroy_message()

◆ iterate_destroy_link()

◆ iterate_destroy_subscription()

◆ destroy_room()

◆ is_room_available()

◆ get_room_handle()

◆ get_room_sender_id()

◆ set_room_sender_id()

◆ get_room_message()

◆ get_room_sender()

◆ get_room_recipient()

◆ delete_room_message()

◆ callback_room_message()

◆ handle_message()

◆ handle_join_message()

◆ handle_leave_message()

◆ handle_name_message()

◆ handle_key_message()

◆ handle_id_message()

◆ handle_miss_message()

◆ handle_private_message()

◆ handle_delete_message()

◆ handle_transcript_message()

◆ handle_room_message()

◆ update_room_last_message()

◆ iterate_local_members()

◆ iterate_room_members()

◆ iterate_find_member()

◆ find_room_member()

◆ find_linked_hash()

◆ link_room_message()

◆ clear_linked_hash()

◆ delete_linked_hash()

◆ link_room_deletion()