#include "gnunet_common.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_messenger_service.h"
#include "messenger_api_handle.h"
#include "messenger_api_list_tunnels.h"
#include "messenger_api_contact.h"
#include "messenger_api_message_control.h"
#include "messenger_api_queue_messages.h"

Include dependency graph for messenger_api_room.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	GNUNET_MESSENGER_RoomEncryptionKey

struct	GNUNET_MESSENGER_RoomAction

struct	GNUNET_MESSENGER_RoomMessageEntry

struct	GNUNET_MESSENGER_RoomSubscription

struct	GNUNET_MESSENGER_Room

Typedefs
typedef void(*	GNUNET_MESSENGER_RoomLinkDeletion) (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_TIME_Relative delay)

Functions
struct GNUNET_MESSENGER_Room *	create_room (struct GNUNET_MESSENGER_Handle handle, const union GNUNET_MESSENGER_RoomKey key)
	Creates and allocates a new room for a handle with a given key for the client API.

void	destroy_room (struct GNUNET_MESSENGER_Room *room)
	Destroys a room and frees its memory fully from the client API.

const struct GNUNET_HashCode *	get_room_key (const struct GNUNET_MESSENGER_Room *room)
	Return a the hash representation of a given room.

enum GNUNET_GenericReturnValue	is_room_public (const struct GNUNET_MESSENGER_Room *room)
	Returns whether a given room is public or using epoch keys to encrypt private traffic and sync those keys automatically.

const struct GNUNET_CRYPTO_HpkePublicKey *	get_room_encryption_key (const struct GNUNET_MESSENGER_Room *room)
	Returns the latest encryption key stored in memory by the current user for a given room.

enum GNUNET_GenericReturnValue	add_room_encryption_key (struct GNUNET_MESSENGER_Room room, const struct GNUNET_CRYPTO_HpkePrivateKey key)
	Adds an encryption key by the current user to memory of a given room and will be placed to the second latest slot in the list if it's not empty.

void	delay_room_action (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_TIME_Relative delay)
	Enqueues delayed handling of a message in a room under a given hash once a specific delay has timed out.

void	cancel_room_action (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Cancels the delayed handling of a message in a room under a given hash in case it has been queued using the function `delay_room_action()` before and the action has not been fully processed yet.

void	cancel_room_actions_by (struct GNUNET_MESSENGER_Room room, enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_HashCode epoch_hash, const union GNUNET_MESSENGER_EpochIdentifier identifier, const struct GNUNET_MESSENGER_Contact contact)
	Searches queued actions to handle messages of a specific message kind in a room with any delay and cancels them using the function `cancel_room_action()`.

enum GNUNET_GenericReturnValue	is_room_available (const struct GNUNET_MESSENGER_Room *room)
	Checks whether a room is available to send messages.

struct GNUNET_MESSENGER_Handle *	get_room_handle (struct GNUNET_MESSENGER_Room *room)
	Returns the messenger handle of the room.

const struct GNUNET_ShortHashCode *	get_room_sender_id (const struct GNUNET_MESSENGER_Room *room)
	Returns the member id of the room's sender.

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_Epoch *	get_room_epoch (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, enum GNUNET_GenericReturnValue recent)
	Returns the epoch in a given room from a specific epoch hash that represents the exact message the epoch starts.

void	generate_room_epoch_announcement (struct GNUNET_MESSENGER_Room room, struct GNUNET_MESSENGER_Epoch epoch, struct GNUNET_MESSENGER_EpochAnnouncement **announcement)
	Generate a new announcement for a given epoch in a room under a random and unique announcement identifier.

struct GNUNET_MESSENGER_Epoch *	get_room_message_epoch (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Returns the epoch of a local message with a given hash in a room.

const union GNUNET_MESSENGER_EpochIdentifier *	get_room_message_epoch_identifier (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Returns the epoch identifier a local message with a given hash is targeting in a room with its specific operation.

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.

enum GNUNET_GenericReturnValue	is_room_message_sent (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Returns whether a message is sent by the handle of the given room itself or another client that is using the same unique key to sign its sent messages.

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.

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.

const struct GNUNET_HashCode *	get_room_epoch_hash (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Returns the messages epoch hash that is locally stored for a message of a given hash in a room.

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.

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.

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, const struct GNUNET_HashCode *epoch, 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.

enum GNUNET_GenericReturnValue	update_room_message (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Updates any message with a given hash in a room for the client API to force handling the message again after some changes that might affect it.

enum GNUNET_GenericReturnValue	update_room_secret_message (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_CRYPTO_SymmetricSessionKey *key, enum GNUNET_GenericReturnValue update)
	Updates a secret message with a given hash in a room for the client API trying to decrypt it with the given epoch key from an epoch announcement.

void	update_room_last_message (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_HashCode *epoch)
	Updates the last message hash and its epoch of a room for the client API so that new messages can point to the latest message hash while sending.

void	copy_room_last_message (const struct GNUNET_MESSENGER_Room room, struct GNUNET_HashCode hash)
	Copies the last message hash of a room into a given hash variable.

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.

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.

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.

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.

Typedef Documentation

◆ GNUNET_MESSENGER_RoomLinkDeletion

typedef void(* GNUNET_MESSENGER_RoomLinkDeletion) (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)

Definition at line 119 of file messenger_api_room.h.

Function Documentation

◆ create_room()

struct GNUNET_MESSENGER_Room * create_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		const union GNUNET_MESSENGER_RoomKey *	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 51 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));
 
  room->keys_head = NULL;
  room->keys_tail = NULL;
 
  memset (&(room->last_message), 0, sizeof(room->last_message));
  memset (&(room->last_epoch), 0, sizeof(room->last_epoch));
 
  room->joined = GNUNET_NO;
  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->actions = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  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);
  room->epochs = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  room->requests = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  init_queue_messages (&(room->queue));
  room->queue_task = NULL;
 
  room->request_task = NULL;
 
  room->control = create_message_control (room);
 
  return room;
}

Referenced by get_handle_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 213 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  destroy_message_control (room->control);
 
  if (room->actions)
  {
    GNUNET_CONTAINER_multihashmap_iterate (room->actions,
                                           iterate_destroy_action, NULL);
 
    GNUNET_CONTAINER_multihashmap_destroy (room->actions);
  }
 
  if (room->request_task)
    GNUNET_SCHEDULER_cancel (room->request_task);
 
  if (room->queue_task)
    GNUNET_SCHEDULER_cancel (room->queue_task);
 
  clear_queue_messages (&(room->queue));
  clear_list_tunnels (&(room->entries));
 
  if (room->requests)
    GNUNET_CONTAINER_multihashmap_destroy (room->requests);
 
  if (room->epochs)
  {
    GNUNET_CONTAINER_multihashmap_iterate (room->epochs,
                                           iterate_destroy_epoch,
                                           NULL);
 
    GNUNET_CONTAINER_multihashmap_destroy (room->epochs);
  }
 
  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);
 
  if (room->keys_head)
    clear_room_encryption_keys (room->keys_head, room->keys_tail);
 
  GNUNET_free (room);
}

Referenced by close_handle_room(), get_handle_room(), and iterate_destroy_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_room_key()

const struct GNUNET_HashCode * get_room_key ( const struct GNUNET_MESSENGER_Room * room )

Return a the hash representation of a given room.

Parameters

[in] room Room

Returns: Hash of room key

Definition at line 287 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  return &(room->key.hash);
}

References GNUNET_assert, GNUNET_MESSENGER_RoomKey::hash, and GNUNET_MESSENGER_Room::key.

Referenced by add_room_encryption_key(), get_room_availble_epoch_entry(), get_valid_encryption_key_for_room(), GNUNET_MESSENGER_room_get_key(), GNUNET_MESSENGER_send_message(), handle_appeal_message(), handle_epoch_announcement(), handle_id_message(), handle_join_message(), handle_key_message(), handle_name_message(), handle_private_message(), read_handle_encryption_key(), read_handle_epoch_key(), request_message_from_room(), send_close_room(), send_enter_room(), send_message_to_room(), send_message_to_room_with_key(), send_open_room(), send_sync_room(), set_room_sender_id(), write_epoch_announcement_record(), and write_epoch_group_record().

Here is the caller graph for this function:

◆ is_room_public()

enum GNUNET_GenericReturnValue is_room_public ( const struct GNUNET_MESSENGER_Room * room )

Returns whether a given room is public or using epoch keys to encrypt private traffic and sync those keys automatically.

Parameters

[in] room Room

Returns: GNUNET_YES if the room is public, otherwise GNUNET_NO

Definition at line 296 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  return room->key.code.public_bit? GNUNET_YES : GNUNET_NO;
}

References GNUNET_MESSENGER_RoomKey::code, GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Room::key, and GNUNET_MESSENGER_RoomKeyCode::public_bit.

Referenced by handle_epoch_announcement_delay(), handle_epoch_group_announcement_delay(), and send_message_to_room().

Here is the caller graph for this function:

◆ get_room_encryption_key()

const struct GNUNET_CRYPTO_HpkePublicKey * get_room_encryption_key ( const struct GNUNET_MESSENGER_Room * room )

Returns the latest encryption key stored in memory by the current user for a given room.

Parameters

[in] room Room

Returns: Public key for hybrid public key encryption

Definition at line 305 of file messenger_api_room.c.

{
  static struct GNUNET_CRYPTO_HpkePublicKey public_key;
 
  GNUNET_assert (room);
 
  if (! room->keys_tail)
    return NULL;
 
  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_hpke_sk_get_public (
                   &(room->keys_tail->key), &public_key));
 
  return &public_key;
}

References GNUNET_assert, GNUNET_CRYPTO_hpke_sk_get_public(), GNUNET_OK, GNUNET_MESSENGER_RoomEncryptionKey::key, and GNUNET_MESSENGER_Room::keys_tail.

Referenced by get_valid_encryption_key_for_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_room_encryption_key()

enum GNUNET_GenericReturnValue add_room_encryption_key	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_CRYPTO_HpkePrivateKey *	key
	)

Adds an encryption key by the current user to memory of a given room and will be placed to the second latest slot in the list if it's not empty.

If the provided key is NULL, a new key will be generated and placed as latest key to be used for encryption purposes in the active member session.

Parameters

[in]	room	Room
[in]	key	Private key for hybrid public key encryption or NULL

Returns: GNUNET_SYSERR on error, otherwise GNUNET_OK

Definition at line 340 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomEncryptionKey *encryption_key;
 
  GNUNET_assert (room);
 
  if (key)
  {
    encryption_key = room->keys_tail;
 
    while (encryption_key)
    {
      if (0 == GNUNET_memcmp_priv (key, &(encryption_key->key)))
        return GNUNET_SYSERR;
 
      encryption_key = encryption_key->prev;
    }
  }
 
  encryption_key = GNUNET_malloc (sizeof(struct
                                         GNUNET_MESSENGER_RoomEncryptionKey));
 
  if (! encryption_key)
    return GNUNET_SYSERR;
 
  if (key)
    GNUNET_memcpy (&(encryption_key->key), key, sizeof (struct
                                                        GNUNET_CRYPTO_HpkePrivateKey));
  else if (GNUNET_OK != GNUNET_CRYPTO_hpke_sk_create (
             GNUNET_CRYPTO_HPKE_KEY_TYPE_X25519, &(encryption_key->key)))
  {
    GNUNET_free (encryption_key);
    return GNUNET_SYSERR;
  }
 
  encryption_key->query = NULL;
 
  encryption_key->prev = NULL;
  encryption_key->next = NULL;
 
  if (key)
    GNUNET_CONTAINER_DLL_insert_before (room->keys_head, room->keys_tail, room->
                                        keys_tail, encryption_key);
  else
  {
    store_handle_encryption_key (
      get_room_handle (room),
      get_room_key (room),
      &(encryption_key->key),
      &cont_write_encryption_key_record,
      encryption_key,
      &(encryption_key->query));
 
    GNUNET_CONTAINER_DLL_insert_tail (room->keys_head, room->keys_tail,
                                      encryption_key);
  }
 
  return GNUNET_OK;
}

References cont_write_encryption_key_record(), get_room_handle(), get_room_key(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert_before, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_HPKE_KEY_TYPE_X25519, GNUNET_CRYPTO_hpke_sk_create(), GNUNET_free, GNUNET_malloc, GNUNET_memcmp_priv, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, key, GNUNET_MESSENGER_RoomEncryptionKey::key, GNUNET_MESSENGER_Room::keys_head, GNUNET_MESSENGER_Room::keys_tail, GNUNET_MESSENGER_RoomEncryptionKey::next, GNUNET_MESSENGER_RoomEncryptionKey::prev, GNUNET_MESSENGER_RoomEncryptionKey::query, and store_handle_encryption_key().

Referenced by get_valid_encryption_key_for_room(), iterate_send_key_to_room(), and read_handle_encryption_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delay_room_action()

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

Enqueues delayed handling of a message in a room under a given hash once a specific delay has timed out.

Parameters

[in,out]	room	Room
[in]	hash	Hash of message
[in]	delay	Delay of action

Definition at line 695 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomAction *action;
 
  GNUNET_assert ((room) && (hash));
 
  action = GNUNET_new (struct GNUNET_MESSENGER_RoomAction);
 
  if (! action)
    return;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        room->actions, hash, action,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
  {
    GNUNET_free (action);
    return;
  }
 
  GNUNET_memcpy (&(action->hash), hash, sizeof(action->hash));
 
  action->room = room;
  action->task = GNUNET_SCHEDULER_add_delayed_with_priority (
    delay,
    GNUNET_SCHEDULER_PRIORITY_HIGH,
    handle_room_action_task,
    action);
}

References GNUNET_MESSENGER_Room::actions, GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_HIGH, handle_room_action_task(), GNUNET_MESSENGER_RoomAction::hash, and GNUNET_MESSENGER_RoomAction::room.

Referenced by handle_appeal_message(), handle_delete_message(), handle_epoch_announcement(), handle_epoch_group_announcement(), and handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancel_room_action()

void cancel_room_action	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Cancels the delayed handling of a message in a room under a given hash in case it has been queued using the function delay_room_action() before and the action has not been fully processed yet.

Parameters

[in,out]	room	Room
[in]	hash	Hash of message

Definition at line 728 of file messenger_api_room.c.

{
  GNUNET_assert ((room) && (hash));
 
  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (room->actions, hash)
      )
    return;
 
  GNUNET_CONTAINER_multihashmap_get_multiple (room->actions, hash,
                                              iterate_destroy_action, NULL);
  GNUNET_CONTAINER_multihashmap_remove_all (room->actions, hash);
}

References GNUNET_MESSENGER_Room::actions, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_YES, GNUNET_MESSENGER_RoomAction::hash, iterate_destroy_action(), and GNUNET_MESSENGER_RoomAction::room.

Referenced by handle_access_message(), and iterate_cancel_action().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancel_room_actions_by()

void cancel_room_actions_by	(	struct GNUNET_MESSENGER_Room *	room,
		enum GNUNET_MESSENGER_MessageKind	kind,
		const struct GNUNET_HashCode *	epoch_hash,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Searches queued actions to handle messages of a specific message kind in a room with any delay and cancels them using the function cancel_room_action().

The actions that need to be cancelled can be filtered by providing the specific hash of the epoch, identifier of the epoch key or group or even the contact from the sender of the exact message. All these parameters are optional.

Parameters

[in,out]	room	Room
[in]	kind	Message kind
[in]	epoch_hash	Hash of epoch or NULL
[in]	identifier	Identifier of epoch key/group or NULL
[in]	contact	Contact of sender or NULL

Definition at line 821 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomCancelAction cancel;
 
  GNUNET_assert (room);
 
  cancel.kind = kind;
  cancel.epoch_hash = epoch_hash;
  cancel.identifier = identifier;
  cancel.contact = contact;
 
  cancel.map = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  if (! cancel.map)
    return;
 
  GNUNET_CONTAINER_multihashmap_iterate (room->actions,
                                         iterate_cancel_action_by,
                                         &cancel);
 
  GNUNET_CONTAINER_multihashmap_iterate (cancel.map,
                                         iterate_cancel_action,
                                         room);
 
  GNUNET_CONTAINER_multihashmap_destroy (cancel.map);
}

References GNUNET_MESSENGER_Room::actions, GNUNET_MESSENGER_RoomCancelAction::contact, GNUNET_MESSENGER_RoomCancelAction::epoch_hash, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_NO, GNUNET_MESSENGER_RoomCancelAction::identifier, iterate_cancel_action(), iterate_cancel_action_by(), GNUNET_MESSENGER_RoomCancelAction::kind, and GNUNET_MESSENGER_RoomCancelAction::map.

Referenced by handle_epoch_announcement().

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 855 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, and GNUNET_MESSENGER_Room::opened.

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 870 of file messenger_api_room.c.

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

References GNUNET_assert, and GNUNET_MESSENGER_Room::handle.

Referenced by add_room_encryption_key(), handle_epoch_announcement(), process_message_control(), task_message_control(), write_epoch_announcement_record(), and write_epoch_group_record().

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 879 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(), GNUNET_MESSENGER_get_message(), handle_join_message(), handle_member_id(), handle_miss_message(), handle_room_request_task(), 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 888 of file messenger_api_room.c.

{
  GNUNET_assert (room);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set member id for room: %s\n",
              GNUNET_h2s (get_room_key (room)));
 
  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 get_room_key(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, 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_epoch()

struct GNUNET_MESSENGER_Epoch * get_room_epoch	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash,
		enum GNUNET_GenericReturnValue	recent
	)

Returns the epoch in a given room from a specific epoch hash that represents the exact message the epoch starts.

Parameters

[in,out]	room	Room
[in]	hash	Hash of epoch
[in]	recent	Recent flag

Returns: Epoch or NULL

Definition at line 913 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert ((room) && (hash));
 
  if (GNUNET_is_zero (hash))
    return NULL;
 
  epoch = GNUNET_CONTAINER_multihashmap_get (room->epochs, hash);
 
  if (epoch)
    return epoch;
 
  if (GNUNET_YES == recent)
    epoch = create_new_epoch (room, hash);
  else
    epoch = create_epoch (room, hash);
 
  if (! epoch)
    return NULL;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->epochs,
                                                      hash,
                                                      epoch,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    destroy_epoch (epoch);
    return NULL;
  }
 
  return epoch;
}

References create_epoch(), create_new_epoch(), destroy_epoch(), GNUNET_MESSENGER_Room::epochs, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_is_zero, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, and GNUNET_MESSENGER_Epoch::room.

Referenced by get_members_of_epoch(), get_room_availble_epoch_entry(), get_room_message_epoch(), handle_message(), invalidate_epoch_announcement(), invalidate_epoch_group(), read_handle_epoch_key(), send_message_to_room(), and setup_following_epochs_of_previous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_room_epoch_announcement()

void generate_room_epoch_announcement	(	struct GNUNET_MESSENGER_Room *	room,
		struct GNUNET_MESSENGER_Epoch *	epoch,
		struct GNUNET_MESSENGER_EpochAnnouncement **	announcement
	)

Generate a new announcement for a given epoch in a room under a random and unique announcement identifier.

The function will automatically generate an announcement message and send it to others.

Parameters

[in,out]	room	Room
[in,out]	epoch	Epoch
[out]	announcement	Epoch announcement

Definition at line 951 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement *epoch_announcement;
 
  GNUNET_assert ((room) && (epoch) && (announcement) && (! (*announcement)));
 
  epoch_announcement = create_epoch_announcement (epoch, NULL, GNUNET_YES);
 
  if (! epoch_announcement)
    return;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (epoch->announcements,
                                                       &(epoch_announcement->
                                                         identifier.hash),
                                                       epoch_announcement,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    destroy_epoch_announcement (epoch_announcement);
    return;
  }
 
  if (! get_epoch_announcement_key (epoch_announcement))
    set_epoch_announcement_key (epoch_announcement, NULL, GNUNET_YES);
 
  *announcement = epoch_announcement;
 
  send_epoch_announcement (epoch_announcement);
}

References GNUNET_MESSENGER_Epoch::announcements, create_epoch_announcement(), destroy_epoch_announcement(), GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement_key(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multishortmap_put(), GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_EpochAnnouncement::identifier, send_epoch_announcement(), and set_epoch_announcement_key().

Referenced by send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_room_message_epoch()

struct GNUNET_MESSENGER_Epoch * get_room_message_epoch	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Returns the epoch of a local message with a given hash in a room.

If no matching message is found or no matching epoch for that message is available, NULL gets returned.

Parameters

[in,out]	room	Room
[in]	hash	Hash of message

Returns: Epoch or NULL

Definition at line 985 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)
    return NULL;
 
  return get_room_epoch (room, &(entry->epoch),
                         is_message_entry_recent (entry));
}

References GNUNET_MESSENGER_RoomMessageEntry::epoch, get_room_epoch(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), is_message_entry_recent(), and GNUNET_MESSENGER_Room::messages.

Referenced by get_epoch_previous_announcement(), get_epoch_previous_group(), handle_room_delayed_deletion(), and iterate_cancel_action_by().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_room_message_epoch_identifier()

const union GNUNET_MESSENGER_EpochIdentifier * get_room_message_epoch_identifier	(	const struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Returns the epoch identifier a local message with a given hash is targeting in a room with its specific operation.

The function is returning NULL if the given message does not provide any context which can be identified with an epoch identifier or if there's no message available under the given hash.

Parameters

[in]	room	Room
[in]	hash	Hash of message

Returns: Epoch identifier or NULL

Definition at line 1003 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) || (! entry->message))
    return NULL;
 
  switch (entry->message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    return &(entry->message->body.announcement.identifier);
  case GNUNET_MESSENGER_KIND_SECRET:
    return &(entry->message->body.secret.identifier);
  case GNUNET_MESSENGER_KIND_APPEAL:
    return get_room_message_epoch_identifier (room,
                                              &(entry->message->body.appeal.
                                                event));
  case GNUNET_MESSENGER_KIND_ACCESS:
    return get_room_message_epoch_identifier (room,
                                              &(entry->message->body.access.
                                                event));
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    return &(entry->message->body.revolution.identifier);
  case GNUNET_MESSENGER_KIND_GROUP:
    return &(entry->message->body.group.identifier);
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    return &(entry->message->body.authorization.identifier);
  default:
    return NULL;
  }
}

Referenced by get_room_message_epoch_identifier(), and iterate_cancel_action_by().

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 1042 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (hash));
 
  if (! (room->messages))
    return NULL;
 
  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 get_epoch_previous_announcement(), get_epoch_previous_group(), get_epoch_proposal_group(), get_members_of_epoch(), GNUNET_MESSENGER_delete_message(), GNUNET_MESSENGER_get_message(), handle_epoch_announcement_access(), invalidate_epoch_announcement(), invalidate_epoch_group(), is_epoch_member_in_room_graph(), is_epoch_previous_of_other(), iterate_cancel_action_by(), require_message_from_room(), send_epoch_announcement_access(), send_epoch_announcement_authorization(), send_epoch_group(), send_epoch_group_access(), send_epoch_group_authorization(), set_epoch_proposal_group(), and setup_following_epochs_of_previous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_room_message_sent()

enum GNUNET_GenericReturnValue is_room_message_sent	(	const struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Returns whether a message is sent by the handle of the given room itself or another client that is using the same unique key to sign its sent messages.

Parameters

[in]	room	Room
[in]	hash	Hash of message

Returns: GNUNET_YES if it has been sent, GNUNET_SYSERR on failure, otherwise GNUNET_NO

Definition at line 1062 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)
    return GNUNET_SYSERR;
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_MESSENGER_FLAG_SENT, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, and GNUNET_MESSENGER_Room::messages.

Referenced by send_epoch_group(), send_epoch_group_access(), and send_epoch_group_authorization().

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 1082 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 get_members_of_epoch(), GNUNET_MESSENGER_get_sender(), iterate_cancel_action_by(), and send_epoch_group().

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 1099 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:

◆ get_room_epoch_hash()

const struct GNUNET_HashCode * get_room_epoch_hash	(	const struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Returns the messages epoch hash that is locally stored for a message of 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: Hash of epoch or NULL

Definition at line 1116 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)
    return NULL;
 
  return &(entry->epoch);
}

References GNUNET_MESSENGER_RoomMessageEntry::epoch, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), and GNUNET_MESSENGER_Room::messages.

Here is the call 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 1133 of file messenger_api_room.c.

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

References create_message_deletion(), enqueue_message_to_room(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and GNUNET_NO.

Referenced by GNUNET_MESSENGER_delete_message(), and handle_room_delayed_deletion().

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 1155 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_message_control(), handle_room_delayed_action(), and handle_room_delayed_deletion().

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,
		const struct GNUNET_HashCode *	epoch,
		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]	epoch	Hash of epoch
[in]	flags	Flags of message

Definition at line 2338 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;
 
  GNUNET_memcpy (&(entry->epoch), epoch, sizeof (entry->epoch));
 
  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::epoch, GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_free, GNUNET_memcpy, 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_message()

enum GNUNET_GenericReturnValue update_room_message	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Updates any message with a given hash in a room for the client API to force handling the message again after some changes that might affect it.

Parameters

[in,out]	room	Room
[in]	hash	Hash of message

Returns: GNUNET_YES if successful, GNUNET_NO on failure and otherwise GNUNET_SYSERR

Definition at line 2397 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) || (! entry->message))
    return GNUNET_SYSERR;
 
  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
    return GNUNET_NO;
 
  entry->flags |= GNUNET_MESSENGER_FLAG_UPDATE;
  handle_message (room, hash, entry);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_MESSENGER_FLAG_UPDATE, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, handle_message(), GNUNET_MESSENGER_RoomMessageEntry::message, and GNUNET_MESSENGER_Room::messages.

Here is the call graph for this function:

◆ update_room_secret_message()

enum GNUNET_GenericReturnValue update_room_secret_message	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key,
		enum GNUNET_GenericReturnValue	update
	)

Updates a secret message with a given hash in a room for the client API trying to decrypt it with the given epoch key from an epoch announcement.

Parameters

[in,out]	room	Room
[in]	hash	Hash of message
[in]	key	Epoch key
[in]	update	Flag message as update on success

Returns: GNUNET_YES if successful, GNUNET_NO on failure and otherwise GNUNET_SYSERR

Definition at line 2419 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
  struct GNUNET_MESSENGER_Message *secret_message;
 
  GNUNET_assert ((room) && (hash) && (key));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
 
  if ((! entry) || (! entry->message) ||
      (GNUNET_MESSENGER_KIND_SECRET != entry->message->header.kind))
    return GNUNET_SYSERR;
 
  secret_message = copy_message (entry->message);
 
  if (! secret_message)
    return GNUNET_NO;
 
  if (GNUNET_YES != decrypt_secret_message (secret_message, key))
  {
    destroy_message (secret_message);
    secret_message = NULL;
  }
 
  if (! secret_message)
    return GNUNET_NO;
 
  destroy_message (entry->message);
 
  entry->message = secret_message;
  entry->flags |= GNUNET_MESSENGER_FLAG_SECRET;
 
  if (GNUNET_YES == update)
    entry->flags |= GNUNET_MESSENGER_FLAG_UPDATE;
 
  if (entry->sender)
    handle_message (room, hash, entry);
 
  return GNUNET_YES;
}

References copy_message(), decrypt_secret_message(), destroy_message(), GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_MESSENGER_FLAG_SECRET, GNUNET_MESSENGER_FLAG_UPDATE, GNUNET_MESSENGER_KIND_SECRET, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, handle_message(), GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_secret_message_with_key().

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,
		const struct GNUNET_HashCode *	epoch
	)

Updates the last message hash and its epoch 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
[in]	epoch	Hash of epoch

Definition at line 2465 of file messenger_api_room.c.

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

References GNUNET_assert, GNUNET_memcpy, GNUNET_MESSENGER_Room::last_epoch, 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:

◆ copy_room_last_message()

void copy_room_last_message	(	const struct GNUNET_MESSENGER_Room *	room,
		struct GNUNET_HashCode *	hash
	)

Copies the last message hash of a room into a given hash variable.

Parameters

[in]	room	Room
[out]	hash	Hash of message

Definition at line 2479 of file messenger_api_room.c.

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

References GNUNET_assert, GNUNET_memcpy, and GNUNET_MESSENGER_Room::last_message.

Referenced by send_close_room(), send_enter_room(), send_message_to_room(), send_open_room(), and send_sync_room().

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 2513 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:

◆ 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 2566 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:

◆ 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 2607 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:

◆ 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 2698 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_room_delayed_deletion().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Typedefs

Functions

Typedef Documentation

◆ GNUNET_MESSENGER_RoomLinkDeletion

Function Documentation

◆ create_room()

◆ destroy_room()

◆ get_room_key()

◆ is_room_public()

◆ get_room_encryption_key()

◆ add_room_encryption_key()

◆ delay_room_action()

◆ cancel_room_action()

◆ cancel_room_actions_by()

◆ is_room_available()

◆ get_room_handle()

◆ get_room_sender_id()

◆ set_room_sender_id()

◆ get_room_epoch()

◆ generate_room_epoch_announcement()

◆ get_room_message_epoch()

◆ get_room_message_epoch_identifier()

◆ get_room_message()

◆ is_room_message_sent()

◆ get_room_sender()

◆ get_room_recipient()

◆ get_room_epoch_hash()

◆ delete_room_message()

◆ callback_room_message()

◆ handle_room_message()

◆ update_room_message()

◆ update_room_secret_message()

◆ update_room_last_message()

◆ copy_room_last_message()

◆ iterate_room_members()

◆ find_room_member()

◆ link_room_message()

◆ link_room_deletion()