#include "messenger_api_room.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_scheduler_lib.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "messenger_api.h"
#include "messenger_api_contact_store.h"
#include "messenger_api_epoch.h"
#include "messenger_api_epoch_announcement.h"
#include "messenger_api_epoch_group.h"
#include "messenger_api_handle.h"
#include "messenger_api_message.h"
#include "messenger_api_message_control.h"
#include "messenger_api_message_kind.h"
#include <stdint.h>
#include <string.h>

Include dependency graph for messenger_api_room.c:

Data Structures
struct	GNUNET_MESSENGER_RoomCancelAction

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 union GNUNET_MESSENGER_RoomKey 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_action (void cls, const struct GNUNET_HashCode key, void *value)

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

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)

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

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

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

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

static enum GNUNET_GenericReturnValue	is_message_entry_recent (const struct GNUNET_MESSENGER_RoomMessageEntry *entry)

static struct GNUNET_MESSENGER_Epoch *	get_room_availble_epoch_entry (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_RoomMessageEntry entry, const struct GNUNET_MESSENGER_Contact contact)

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

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

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

static void	handle_room_delayed_action (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)

static void	handle_room_action_task (void *cls)

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

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

static enum GNUNET_GenericReturnValue	iterate_cancel_action_by (void cls, const struct GNUNET_HashCode hash, void *value)

static enum GNUNET_GenericReturnValue	iterate_cancel_action (void cls, const struct GNUNET_HashCode hash, void *value)

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

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

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

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

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

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

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. 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 enum GNUNET_GenericReturnValue	is_epoch_identifier_upper (const union GNUNET_MESSENGER_EpochIdentifier identifier, const union GNUNET_MESSENGER_EpochIdentifier other)

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

static void	handle_room_request_task (void *cls)

void	require_message_from_room (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Requires a specific message in a given room which can be identified by its hash. 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 enum GNUNET_GenericReturnValue	iterate_room_epoch_member_invalidation (void cls, const struct GNUNET_HashCode key, void *value)

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

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

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

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

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

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

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

static void	handle_authorization_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, 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. More...

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

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

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

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. 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 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 48 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));
  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 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_action()

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

static

Definition at line 93 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomAction *action;
 
  GNUNET_assert (value);
 
  action = value;
 
  if (action->task)
    GNUNET_SCHEDULER_cancel (action->task);
 
  GNUNET_free (action);
  return GNUNET_YES;
}

References warningfilter::action, GNUNET_assert, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, and value.

Referenced by cancel_room_action(), and destroy_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 112 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 129 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 145 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:

◆ iterate_destroy_epoch()

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

static

Definition at line 167 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert (value);
 
  epoch = value;
 
  destroy_epoch (epoch);
  return GNUNET_YES;
}

References destroy_epoch(), GNUNET_assert, GNUNET_YES, 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 183 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);
 
  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:

◆ 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 254 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 cb_key_monitor(), get_room_availble_epoch_entry(), GNUNET_MESSENGER_room_get_key(), handle_appeal_message(), handle_epoch_announcement(), handle_id_message(), handle_join_message(), handle_key_message(), handle_name_message(), handle_private_message(), 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 263 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:

◆ is_message_entry_recent()

static enum GNUNET_GenericReturnValue is_message_entry_recent ( const struct GNUNET_MESSENGER_RoomMessageEntry * entry )

static

Definition at line 272 of file messenger_api_room.c.

{
  GNUNET_assert (entry);
 
  if (GNUNET_MESSENGER_FLAG_RECENT & entry->flags)
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_MESSENGER_FLAG_RECENT, GNUNET_NO, and GNUNET_YES.

Referenced by get_room_availble_epoch_entry(), and get_room_message_epoch().

Here is the caller graph for this function:

◆ get_room_availble_epoch_entry()

static struct GNUNET_MESSENGER_Epoch * get_room_availble_epoch_entry	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_MESSENGER_RoomMessageEntry *	entry,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 284 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *room_epoch;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  room_epoch = get_room_epoch (
    room, &(entry->epoch),
    is_message_entry_recent (entry));
 
  if (! room_epoch)
    return NULL;
 
  if (GNUNET_YES == delay_epoch_message_for_its_members (room_epoch, hash))
    return NULL;
 
  if (GNUNET_NO == is_epoch_member (
        room_epoch,
        get_handle_contact (room->handle, get_room_key (room))))
    return NULL;
 
  if (GNUNET_NO == is_epoch_member (
        room_epoch, contact? contact : entry->sender))
    return NULL;
 
  return room_epoch;
}

References delay_epoch_message_for_its_members(), GNUNET_MESSENGER_RoomMessageEntry::epoch, get_handle_contact(), get_room_epoch(), get_room_key(), GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Epoch::hash, is_epoch_member(), is_message_entry_recent(), GNUNET_MESSENGER_Epoch::room, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_access_message(), handle_announcement_message(), handle_appeal_message(), handle_authorization_message(), handle_group_message(), handle_revolution_message(), handle_room_delayed_announcement(), handle_room_delayed_appeal(), and handle_secret_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_delayed_deletion()

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

static

Definition at line 318 of file messenger_api_room.c.

{
  const struct GNUNET_HashCode *target_hash;
  struct GNUNET_MESSENGER_RoomMessageEntry *target;
 
  target_hash = &(entry->message->body.deletion.hash);
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
  {
    struct GNUNET_TIME_Relative delay;
 
    delay = get_message_timeout (entry->message);
 
    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) &&
      (! (GNUNET_MESSENGER_FLAG_SENT & entry->flags)))
    return;
 
  target->flags |= GNUNET_MESSENGER_FLAG_DELETE;
  callback_room_message (room, target_hash);
 
  switch (target->message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    {
      struct GNUNET_MESSENGER_Epoch *epoch;
      struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
      epoch = get_room_message_epoch (room, target_hash);
 
      if (! epoch)
        break;
 
      announcement = get_epoch_announcement (
        epoch,
        &(target->message->body.announcement.identifier),
        GNUNET_NO);
 
      if (! announcement)
        break;
 
      revoke_epoch_announcement_member (
        announcement,
        target_hash,
        target->message,
        target->sender);
      break;
    }
  default:
    break;
  }
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (
        room->messages, target_hash, target))
  {
    destroy_message (target->message);
    GNUNET_free (target);
  }
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_Message::body, callback_room_message(), delete_room_message(), GNUNET_MESSENGER_MessageBody::deletion, destroy_message(), GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_MESSENGER_RoomMessageEntry::flags, get_epoch_announcement(), get_message_timeout(), get_room_message_epoch(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_MESSENGER_FLAG_DELETE, GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_MessageDeletion::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageAnnouncement::identifier, GNUNET_MESSENGER_MessageHeader::kind, link_room_deletion(), GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, revoke_epoch_announcement_member(), and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_room_delayed_action().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_delayed_announcement()

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

static

Definition at line 389 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  enum GNUNET_GenericReturnValue sent;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  epoch = get_room_availble_epoch_entry (room, hash, entry, NULL);
 
  if (! epoch)
    return;
 
  identifier = &(entry->message->body.announcement.identifier);
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
    sent = GNUNET_YES;
  else
    sent = GNUNET_NO;
 
  if (identifier->code.group_bit)
  {
    struct GNUNET_MESSENGER_EpochGroup *group;
 
    group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
    if (! group)
      return;
 
    handle_epoch_group_announcement_delay (
      group,
      entry->message,
      hash,
      entry->sender,
      sent);
  }
  else
  {
    struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
    announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
    if (! announcement)
      return;
 
    handle_epoch_announcement_delay (
      announcement,
      entry->message,
      hash,
      entry->sender,
      sent);
  }
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_MESSENGER_RoomMessageEntry::flags, get_epoch_announcement(), get_epoch_group(), get_room_availble_epoch_entry(), GNUNET_assert, GNUNET_MESSENGER_FLAG_SENT, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, handle_epoch_announcement_delay(), handle_epoch_group_announcement_delay(), GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_MessageAnnouncement::identifier, GNUNET_MESSENGER_EpochAnnouncement::identifier, GNUNET_MESSENGER_EpochGroup::identifier, GNUNET_MESSENGER_RoomMessageEntry::message, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_room_delayed_action().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_delayed_appeal()

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

static

Definition at line 448 of file messenger_api_room.c.

{
  const struct GNUNET_MESSENGER_RoomMessageEntry *event_entry;
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  event_entry = GNUNET_CONTAINER_multihashmap_get (
    room->messages, &(entry->message->body.appeal.event));
 
  if (! event_entry)
    return;
 
  if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != event_entry->message->header.kind)
    return;
 
  epoch = get_room_availble_epoch_entry (
    room, hash, event_entry, entry->sender);
 
  if (! epoch)
    return;
 
  identifier = &(event_entry->message->body.announcement.identifier);
 
  if (identifier->code.group_bit)
    return;
 
  announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
  if (! announcement)
    return;
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
    return;
 
  if (GNUNET_YES != is_epoch_member (epoch, entry->sender))
    return;
 
  if (GNUNET_YES == is_epoch_announcement_member (announcement, entry->sender))
    return;
 
  key = get_epoch_announcement_key (announcement);
 
  if (! key)
    return;
 
  send_epoch_announcement_access (announcement, hash);
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_MessageBody::appeal, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_MESSENGER_MessageAppeal::event, GNUNET_MESSENGER_RoomMessageEntry::flags, get_epoch_announcement(), get_epoch_announcement_key(), get_room_availble_epoch_entry(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageAnnouncement::identifier, is_epoch_announcement_member(), is_epoch_member(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, send_epoch_announcement_access(), and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by handle_room_delayed_action().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_delayed_action()

static void handle_room_delayed_action	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

static

Definition at line 505 of file messenger_api_room.c.

{
  const struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (hash));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
 
  if ((! entry) || (! entry->message))
    return;
 
  if ((entry->flags & GNUNET_MESSENGER_FLAG_UPDATE) ||
      (entry->flags & GNUNET_MESSENGER_FLAG_DELETE))
    goto skip_delayed_handling;
 
  switch (entry->message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_DELETION:
    handle_room_delayed_deletion (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    handle_room_delayed_announcement (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_APPEAL:
    handle_room_delayed_appeal (room, hash, entry);
    break;
  default:
    break;
  }
 
skip_delayed_handling:
  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
    callback_room_message (room, hash);
}

References callback_room_message(), GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_MESSENGER_FLAG_DELETE, GNUNET_MESSENGER_FLAG_UPDATE, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_MESSENGER_KIND_APPEAL, GNUNET_MESSENGER_KIND_DELETION, handle_room_delayed_announcement(), handle_room_delayed_appeal(), handle_room_delayed_deletion(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_RoomMessageEntry::message, and GNUNET_MESSENGER_Room::messages.

Referenced by handle_room_action_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_action_task()

static void handle_room_action_task ( void * cls )

static

Definition at line 543 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomAction *action;
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert (cls);
 
  action = cls;
  action->task = NULL;
 
  room = action->room;
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (
        room->actions, &(action->hash), action))
    handle_room_delayed_action (room, &(action->hash));
 
  GNUNET_free (action);
}

References warningfilter::action, GNUNET_MESSENGER_Room::actions, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_YES, and handle_room_delayed_action().

Referenced by delay_room_action().

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 564 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 warningfilter::action, 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 597 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:

◆ iterate_cancel_action_by()

static enum GNUNET_GenericReturnValue iterate_cancel_action_by	(	void *	cls,
		const struct GNUNET_HashCode *	hash,
		void *	value
	)

static

Definition at line 623 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_RoomCancelAction *cancel;
  struct GNUNET_MESSENGER_RoomAction *action;
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((cls) && (hash) && (value));
 
  cancel = cls;
  action = value;
  room = action->room;
 
  message = get_room_message (room, hash);
 
  if ((! message) || (message->header.kind != cancel->kind))
    return GNUNET_YES;
 
  if (cancel->epoch_hash)
  {
    const struct GNUNET_MESSENGER_Epoch *epoch;
 
    epoch = get_room_message_epoch (room, hash);
 
    if ((! epoch) || (0 != GNUNET_CRYPTO_hash_cmp (&(epoch->hash), cancel->
                                                   epoch_hash)))
      return GNUNET_YES;
  }
 
  if (cancel->identifier)
  {
    const union GNUNET_MESSENGER_EpochIdentifier *identifier;
 
    identifier = get_room_message_epoch_identifier (room, hash);
 
    if ((! identifier) || (0 != GNUNET_memcmp (identifier, cancel->identifier)))
      return GNUNET_YES;
  }
 
  if ((cancel->contact) && (cancel->contact != get_room_sender (room, hash)))
    return GNUNET_YES;
 
  GNUNET_CONTAINER_multihashmap_put (cancel->map, hash, NULL,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
  return GNUNET_YES;
}

References warningfilter::action, GNUNET_MESSENGER_RoomCancelAction::contact, GNUNET_MESSENGER_RoomCancelAction::epoch_hash, get_room_message(), get_room_message_epoch(), get_room_message_epoch_identifier(), get_room_sender(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_CRYPTO_hash_cmp(), GNUNET_memcmp, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_RoomCancelAction::identifier, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_RoomCancelAction::kind, GNUNET_MESSENGER_RoomCancelAction::map, GNUNET_MESSENGER_Epoch::room, and value.

Referenced by cancel_room_actions_by().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_cancel_action()

static enum GNUNET_GenericReturnValue iterate_cancel_action	(	void *	cls,
		const struct GNUNET_HashCode *	hash,
		void *	value
	)

static

Definition at line 674 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((cls) && (hash));
 
  room = cls;
 
  cancel_room_action (room, hash);
  return GNUNET_YES;
}

References cancel_room_action(), GNUNET_assert, and GNUNET_YES.

Referenced by cancel_room_actions_by().

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 690 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 724 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 739 of file messenger_api_room.c.

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

References GNUNET_assert, and GNUNET_MESSENGER_Room::handle.

Referenced by 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 748 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 757 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 782 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 cb_key_monitor(), get_members_of_epoch(), get_room_availble_epoch_entry(), get_room_message_epoch(), handle_message(), invalidate_epoch_announcement(), invalidate_epoch_group(), 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 820 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 854 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 872 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 911 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 931 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 951 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 968 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 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 &(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 1002 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 1024 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:

◆ is_epoch_identifier_upper()

static enum GNUNET_GenericReturnValue is_epoch_identifier_upper	(	const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const union GNUNET_MESSENGER_EpochIdentifier *	other
	)

static

Definition at line 1054 of file messenger_api_room.c.

{
  uint32_t level, other_level;
 
  GNUNET_assert ((identifier) && (other));
 
  level = (uint32_t) identifier->code.level_bits;
  other_level = (uint32_t) other->code.level_bits;
 
  if (level > other_level)
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_assert, GNUNET_NO, GNUNET_YES, and GNUNET_MESSENGER_EpochIdentifierCode::level_bits.

Referenced by handle_access_message(), and handle_authorization_message().

Here is the caller graph for this function:

◆ iterate_room_request()

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

static

Definition at line 1073 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((cls) && (key));
 
  room = cls;
  request_message_from_room (room, key);
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, key, and request_message_from_room().

Referenced by handle_room_request_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_request_task()

static void handle_room_request_task ( void * cls )

static

Definition at line 1089 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert (cls);
 
  room = cls;
  room->request_task = NULL;
 
  if ((GNUNET_YES != room->joined) || (! get_room_sender_id (room)))
  {
    struct GNUNET_TIME_Relative delay;
    delay = GNUNET_TIME_relative_get_millisecond_ ();
    delay = GNUNET_TIME_relative_multiply (delay, 100);
 
    room->request_task = GNUNET_SCHEDULER_add_delayed_with_priority (
      delay,
      GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
      handle_room_request_task,
      room);
    return;
  }
 
  GNUNET_CONTAINER_multihashmap_iterate (
    room->requests,
    iterate_room_request,
    room);
 
  GNUNET_CONTAINER_multihashmap_clear (room->requests);
}

References get_room_sender_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_clear(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_BACKGROUND, GNUNET_TIME_relative_get_millisecond_(), GNUNET_TIME_relative_multiply(), GNUNET_YES, handle_room_request_task(), iterate_room_request(), GNUNET_MESSENGER_Room::joined, GNUNET_MESSENGER_Room::request_task, and GNUNET_MESSENGER_Room::requests.

Referenced by handle_room_request_task(), and require_message_from_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require_message_from_room()

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

Requires a specific message in a given room which can be identified by its hash.

The required message will be requested asynchronously.

Parameters

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

Definition at line 1122 of file messenger_api_room.c.

{
  GNUNET_assert ((room) && (hash));
 
  if (GNUNET_is_zero (hash))
    return;
 
  if (get_room_message (room, hash))
    return;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        room->requests,
        hash, NULL,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
    return;
 
  if (room->request_task)
    return;
 
  room->request_task = GNUNET_SCHEDULER_add_with_priority (
    GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
    handle_room_request_task,
    room);
}

References get_room_message(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_is_zero, GNUNET_OK, GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_BACKGROUND, handle_room_request_task(), GNUNET_MESSENGER_Room::request_task, and GNUNET_MESSENGER_Room::requests.

Referenced by create_epoch(), GNUNET_MESSENGER_get_message(), handle_join_message(), handle_leave_message(), and handle_merge_message().

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 2104 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_MERGE:
    handle_merge_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    handle_private_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_DELETION:
    handle_delete_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    handle_transcript_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    handle_announcement_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    handle_secret_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_APPEAL:
    handle_appeal_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    handle_access_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    handle_revolution_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_GROUP:
    handle_group_message (room, hash, entry);
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    handle_authorization_message (room, hash, entry);
    break;
  default:
    break;
  }
 
  if (GNUNET_YES == is_epoch_message (entry->message))
  {
    struct GNUNET_MESSENGER_Epoch *epoch;
 
    epoch = get_room_epoch (room, &(entry->epoch), GNUNET_NO);
 
    if ((! epoch) || (get_epoch_size (epoch)))
      return;
 
    reset_epoch_size (epoch);
  }
 
  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
    delay_room_action (room, hash, GNUNET_TIME_relative_get_zero_ ());
}

Referenced by handle_private_message(), handle_room_message(), handle_transcript_message(), update_room_message(), and update_room_secret_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 1156 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 (get_room_key (room),
                             &(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);
 
  if ((get_room_sender_id (room)) &&
      (0 == GNUNET_memcmp (&(entry->message->header.sender_id),
                           get_room_sender_id (room))) &&
      (0 == GNUNET_memcmp (&(entry->message->body.join.key), get_handle_pubkey (
                             room->handle))))
    room->joined = GNUNET_YES;
 
  require_message_from_room (room, &(entry->message->body.join.epoch));
}

References GNUNET_MESSENGER_Message::body, context, GNUNET_MESSENGER_MessageJoin::epoch, get_context_from_member(), get_handle_contact_store(), get_handle_pubkey(), get_room_key(), get_room_sender_id(), get_store_contact(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_contains_value(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_memcmp, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, increase_contact_rc(), GNUNET_MESSENGER_MessageBody::join, GNUNET_MESSENGER_Room::joined, GNUNET_MESSENGER_MessageJoin::key, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_RoomMessageEntry::message, require_message_from_room(), 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:

◆ iterate_room_epoch_member_invalidation()

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

static

Definition at line 1198 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Contact *contact;
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert ((cls) && (value));
 
  contact = cls;
  epoch = value;
 
  invalidate_epoch_keys_by_member (epoch, contact);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, invalidate_epoch_keys_by_member(), and value.

Referenced by handle_leave_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 1216 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_MESSENGER_FLAG_RECENT & entry->flags)
    GNUNET_CONTAINER_multihashmap_iterate (
      room->epochs, iterate_room_epoch_member_invalidation,
      entry->sender);
 
  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");
 
  require_message_from_room (room, &(entry->message->body.leave.epoch));
}

References GNUNET_MESSENGER_Message::body, decrease_contact_rc(), GNUNET_MESSENGER_MessageLeave::epoch, GNUNET_MESSENGER_Room::epochs, GNUNET_MESSENGER_RoomMessageEntry::flags, GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_FLAG_RECENT, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_Message::header, iterate_room_epoch_member_invalidation(), GNUNET_MESSENGER_MessageBody::leave, GNUNET_MESSENGER_Room::members, GNUNET_MESSENGER_RoomMessageEntry::message, require_message_from_room(), GNUNET_MESSENGER_Epoch::room, 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_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 1243 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 (get_room_key (room)));
 
    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(), get_room_key(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_FLAG_SENT, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_MessageName::name, GNUNET_MESSENGER_MessageBody::name, GNUNET_MESSENGER_Epoch::room, 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 1272 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 (
    get_room_key (room),
    &(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(), get_room_key(), GNUNET_assert, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageKey::key, GNUNET_MESSENGER_MessageBody::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 1297 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 (get_room_key (room), &(entry->message->header.
                                                  sender_id),
                           &context);
  get_context_from_member (get_room_key (room), &(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(), get_room_key(), 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::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 1333 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_merge_message()

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

static

Definition at line 1355 of file messenger_api_room.c.

{
  GNUNET_assert ((room) && (hash) && (entry));
 
  require_message_from_room (room, &(entry->message->body.merge.epochs[0]));
  require_message_from_room (room, &(entry->message->body.merge.epochs[1]));
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageMerge::epochs, GNUNET_assert, GNUNET_MESSENGER_ListTunnel::hash, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_RoomMessageEntry::message, and require_message_from_room().

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 1367 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, get_room_key (room));
 
  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(), get_room_key(), GNUNET_assert, GNUNET_MESSENGER_FLAG_PRIVATE, GNUNET_YES, GNUNET_MESSENGER_Room::handle, handle_message(), 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 1403 of file messenger_api_room.c.

{
  struct GNUNET_TIME_Relative delay;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  delay = get_message_timeout (entry->message);
 
  delay_room_action (room, hash, delay);
}

References delay_room_action(), get_message_timeout(), GNUNET_assert, and GNUNET_MESSENGER_RoomMessageEntry::message.

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 1418 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 (! (GNUNET_MESSENGER_FLAG_SENT & entry->flags))
    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_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_SENT, 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_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_announcement_message()

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

static

Definition at line 1502 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochNonce *nonce;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  enum GNUNET_GenericReturnValue sent;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  epoch = get_room_availble_epoch_entry (room, hash, entry, NULL);
 
  if (! epoch)
    return;
 
  nonce = &(entry->message->body.announcement.nonce);
 
  if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
        epoch->nonces, &(nonce->hash)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unsafe announcement: Nonce (%s) has already been used in this epoch! [%s]\n",
                GNUNET_sh2s (&(nonce->hash)), GNUNET_h2s (&(epoch->hash)));
    return;
  }
 
  GNUNET_CONTAINER_multishortmap_put (epoch->nonces, &(nonce->hash), NULL,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 
  identifier = &(entry->message->body.announcement.identifier);
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
    sent = GNUNET_YES;
  else
    sent = GNUNET_NO;
 
  if (identifier->code.group_bit)
  {
    struct GNUNET_MESSENGER_EpochGroup *group;
 
    group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
    if (! group)
      return;
 
    handle_epoch_group_announcement (
      group,
      entry->message,
      hash,
      entry->sender,
      sent);
  }
  else
  {
    struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
    announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
    if (! announcement)
      return;
 
    handle_epoch_announcement (
      announcement,
      entry->message,
      hash,
      entry->sender,
      sent);
  }
}

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_secret_message()

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

static

Definition at line 1575 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  epoch = get_room_availble_epoch_entry (room, hash, entry, NULL);
 
  if (! epoch)
    return;
 
  identifier = &(entry->message->body.secret.identifier);
 
  if (identifier->code.group_bit)
    return;
 
  announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
  if (! announcement)
    return;
 
  handle_epoch_announcement_message (
    announcement, entry->message, hash);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement(), get_room_availble_epoch_entry(), GNUNET_assert, GNUNET_NO, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, handle_epoch_announcement_message(), GNUNET_MESSENGER_MessageSecret::identifier, GNUNET_MESSENGER_EpochAnnouncement::identifier, GNUNET_MESSENGER_RoomMessageEntry::message, and GNUNET_MESSENGER_MessageBody::secret.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_appeal_message()

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

static

Definition at line 1606 of file messenger_api_room.c.

{
  const struct GNUNET_MESSENGER_RoomMessageEntry *event_entry;
  struct GNUNET_MESSENGER_Epoch *epoch;
  const struct GNUNET_MESSENGER_Contact *contact;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  event_entry = GNUNET_CONTAINER_multihashmap_get (
    room->messages, &(entry->message->body.appeal.event));
 
  if (! event_entry)
    return;
 
  if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != event_entry->message->header.kind)
    return;
 
  epoch = get_room_availble_epoch_entry (
    room, hash, event_entry, entry->sender);
 
  if (! epoch)
    return;
 
  contact = get_handle_contact (room->handle, get_room_key (room));
 
  if (! contact)
    return;
 
  if (GNUNET_YES != is_epoch_member (epoch, contact))
    return;
 
  identifier = &(event_entry->message->body.announcement.identifier);
 
  if (identifier->code.group_bit)
    return;
 
  announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
  if (! announcement)
    return;
 
  if (GNUNET_YES == is_epoch_announcement_member (announcement, entry->sender))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Appealing contact is already member of epoch announcement! [%s]\n",
                GNUNET_sh2s (&(identifier->hash)));
    return;
  }
 
  if (contact == event_entry->sender)
    timeout = GNUNET_TIME_relative_get_zero_ ();
  else
  {
    timeout = get_message_timeout (entry->message);
 
    if (GNUNET_TIME_relative_is_zero (timeout))
      return;
 
    timeout = GNUNET_TIME_relative_multiply_double (
      timeout, get_epoch_position_factor (epoch, contact, NULL));
  }
 
  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
    set_epoch_announcement_appeal (announcement,
                                   get_message_timeout (entry->message));
 
  delay_room_action (room, hash, timeout);
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_MessageBody::appeal, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, delay_room_action(), GNUNET_MESSENGER_MessageAppeal::event, GNUNET_MESSENGER_RoomMessageEntry::flags, get_epoch_announcement(), get_epoch_position_factor(), get_handle_contact(), get_message_timeout(), get_room_availble_epoch_entry(), get_room_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_NO, GNUNET_sh2s(), GNUNET_TIME_relative_get_zero_(), GNUNET_TIME_relative_is_zero(), GNUNET_TIME_relative_multiply_double(), GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageAnnouncement::identifier, is_epoch_announcement_member(), is_epoch_member(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_Room::messages, GNUNET_MESSENGER_RoomMessageEntry::sender, set_epoch_announcement_appeal(), and timeout.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_access_message()

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

static

Definition at line 1682 of file messenger_api_room.c.

{
  const struct GNUNET_MESSENGER_RoomMessageEntry *event_entry;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  if (! (GNUNET_MESSENGER_FLAG_RECENT & entry->flags))
    return;
 
  event_entry = GNUNET_CONTAINER_multihashmap_get (
    room->messages, &(entry->message->body.access.event));
 
  if (! event_entry)
    return;
 
  switch (event_entry->message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_APPEAL:
    {
      struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
      enum GNUNET_GenericReturnValue appealed;
 
      if (GNUNET_MESSENGER_FLAG_SENT & event_entry->flags)
        appealed = GNUNET_YES;
      else
        appealed = GNUNET_NO;
 
      event_entry = GNUNET_CONTAINER_multihashmap_get (room->messages,
                                                       &(event_entry->message->
                                                         body.appeal.event));
 
      if (! event_entry)
        return;
 
      if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != event_entry->message->header.
          kind)
        return;
 
      identifier = &(event_entry->message->body.announcement.identifier);
      epoch = get_room_availble_epoch_entry (room, hash, event_entry, entry->
                                             sender);
 
      if (! epoch)
        return;
 
      announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
      if (! announcement)
        return;
 
      if (GNUNET_YES != appealed)
      {
        const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key;
 
        shared_key = get_epoch_announcement_key (announcement);
 
        if ((shared_key) && (GNUNET_OK == verify_message_by_key (entry->message,
                                                                 shared_key)))
          cancel_room_action (room, &(entry->message->body.access.event));
 
        return;
      }
 
      handle_epoch_announcement_access (announcement, entry->message, hash);
      break;
    }
  case GNUNET_MESSENGER_KIND_GROUP:
    {
      struct GNUNET_MESSENGER_EpochGroup *group;
      const struct GNUNET_HashCode *partner_hash;
      const struct GNUNET_MESSENGER_RoomMessageEntry *init_entry;
 
      identifier = &(event_entry->message->body.group.identifier);
      epoch = get_room_availble_epoch_entry (room, hash, event_entry, entry->
                                             sender);
 
      if (! epoch)
        return;
 
      if ((epoch->main_announcement) &&
          (GNUNET_YES != is_epoch_identifier_upper (identifier, &(epoch->
                                                                  main_announcement
                                                                  ->identifier))
          ))
        return;
 
      if ((epoch->main_group) &&
          (GNUNET_YES != is_epoch_identifier_upper (identifier, &(epoch->
                                                                  main_group->
                                                                  identifier))))
        return;
 
      partner_hash = &(event_entry->message->body.group.partner);
      init_entry = GNUNET_CONTAINER_multihashmap_get (room->messages,
                                                      &(event_entry->message->
                                                        body.group.initiator));
 
      if ((! init_entry) || (event_entry->sender != init_entry->sender))
        return;
 
      if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != init_entry->message->header.kind
          )
        return;
 
      event_entry = GNUNET_CONTAINER_multihashmap_get (room->messages,
                                                       partner_hash);
 
      if (! event_entry)
        return;
 
      if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != event_entry->message->header.
          kind)
        return;
 
      if (! (GNUNET_MESSENGER_FLAG_SENT & event_entry->flags))
        return;
 
      {
        struct GNUNET_HashCode main_hash;
        enum GNUNET_GenericReturnValue has_hash;
 
        if (epoch->main_group)
          has_hash = get_epoch_group_member_hash (epoch->main_group, &main_hash,
                                                  GNUNET_NO);
        else if (epoch->main_announcement)
          has_hash = get_epoch_announcement_member_hash (epoch->
                                                         main_announcement, &
                                                         main_hash, GNUNET_NO);
        else
          return;
 
        if ((GNUNET_OK != has_hash) ||
            (0 != GNUNET_CRYPTO_hash_cmp (&main_hash, partner_hash)))
          return;
      }
 
      group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
      if (! group)
        return;
 
      handle_epoch_group_access (group, entry->message, hash);
      break;
    }
  default:
    return;
  }
}

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_revolution_message()

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

static

Definition at line 1837 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochNonce *nonce;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  epoch = get_room_availble_epoch_entry (room, hash, entry, entry->sender);
 
  if (! epoch)
    return;
 
  nonce = &(entry->message->body.announcement.nonce);
 
  if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (epoch->nonces, &(
                                                               nonce->hash)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unsafe revolution: Nonce (%s) has already been used in this epoch! [%s]\n",
                GNUNET_sh2s (&(nonce->hash)), GNUNET_h2s (&(epoch->hash)));
    return;
  }
 
  GNUNET_CONTAINER_multishortmap_put (epoch->nonces, &(nonce->hash), NULL,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 
  identifier = &(entry->message->body.revolution.identifier);
 
  if (identifier->code.group_bit)
  {
    struct GNUNET_MESSENGER_EpochGroup *group;
    const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
 
    group = get_epoch_group (epoch, identifier, GNUNET_YES);
 
    if (! group)
      return;
 
    key = get_epoch_group_key (group);
 
    if (! key)
      return;
 
    if (GNUNET_OK != verify_message_by_key (entry->message, key))
      return;
 
    invalidate_epoch_group (group, NULL);
  }
  else
  {
    struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
    const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
 
    announcement = get_epoch_announcement (epoch, identifier, GNUNET_YES);
 
    if (! announcement)
      return;
 
    key = get_epoch_announcement_key (announcement);
 
    if (! key)
      return;
 
    if (GNUNET_OK != verify_message_by_key (entry->message, key))
      return;
 
    invalidate_epoch_announcement (announcement, NULL);
  }
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, get_epoch_announcement(), get_epoch_announcement_key(), get_epoch_group(), get_epoch_group_key(), get_room_availble_epoch_entry(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multishortmap_contains(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_EpochNonce::hash, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_MessageRevolution::identifier, invalidate_epoch_announcement(), invalidate_epoch_group(), key, GNUNET_MESSENGER_RoomMessageEntry::message, GNUNET_MESSENGER_MessageAnnouncement::nonce, GNUNET_MESSENGER_Epoch::nonces, GNUNET_MESSENGER_MessageBody::revolution, GNUNET_MESSENGER_RoomMessageEntry::sender, and verify_message_by_key().

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_group_message()

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

static

Definition at line 1912 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  epoch = get_room_availble_epoch_entry (room, hash, entry, entry->sender);
 
  if (! epoch)
    return;
 
  identifier = &(entry->message->body.group.identifier);
  group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
  if (! (GNUNET_MESSENGER_FLAG_SENT & entry->flags))
    return;
 
  set_epoch_proposal_group (epoch, hash);
 
  set_epoch_group_key (group, NULL, GNUNET_YES);
  send_epoch_group_access (group, hash);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_MESSENGER_RoomMessageEntry::flags, get_epoch_group(), get_room_availble_epoch_entry(), GNUNET_assert, GNUNET_MESSENGER_FLAG_SENT, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_MessageBody::group, GNUNET_MESSENGER_MessageGroup::identifier, GNUNET_MESSENGER_EpochGroup::identifier, GNUNET_MESSENGER_RoomMessageEntry::message, send_epoch_group_access(), GNUNET_MESSENGER_RoomMessageEntry::sender, set_epoch_group_key(), and set_epoch_proposal_group().

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_authorization_message()

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

static

Definition at line 1941 of file messenger_api_room.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  struct GNUNET_MESSENGER_EpochGroup *auth_group;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *group_key;
  const struct GNUNET_MESSENGER_RoomMessageEntry *event_entry;
  struct GNUNET_CRYPTO_SymmetricSessionKey shared_key;
 
  GNUNET_assert ((room) && (hash) && (entry));
 
  epoch = get_room_availble_epoch_entry (room, hash, entry, entry->sender);
 
  if (! epoch)
    return;
 
  identifier = &(entry->message->body.authorization.identifier);
  auth_group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
  if (! auth_group)
    return;
 
  group_key = get_epoch_group_key (auth_group);
 
  if (! group_key)
    return;
 
  event_entry = GNUNET_CONTAINER_multihashmap_get (
    room->messages, &(entry->message->body.authorization.event));
 
  if (! event_entry)
    return;
 
  switch (event_entry->message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    {
      identifier = &(event_entry->message->body.announcement.identifier);
 
      if (0 == GNUNET_memcmp (identifier, &(auth_group->identifier)))
        return;
 
      if (identifier->code.group_bit)
      {
        struct GNUNET_MESSENGER_EpochGroup *group;
        uint32_t next_level;
 
        if (GNUNET_YES != is_epoch_identifier_upper (
              identifier, &(auth_group->identifier)))
          return;
 
        group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
        if (! group)
          return;
 
        next_level = get_epoch_group_level (auth_group) + 1;
 
        if (next_level != get_epoch_group_level (group))
          return;
 
        if (GNUNET_NO == extract_authorization_message_key (
              entry->message, group_key, &shared_key))
          return;
 
        if (get_epoch_group_key (group))
          return;
 
        set_epoch_group_key (group, &shared_key, GNUNET_YES);
        send_epoch_group_announcement (group);
      }
      else
      {
        struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
        announcement = get_epoch_announcement (epoch, identifier, GNUNET_NO);
 
        if (! announcement)
          return;
 
        if (GNUNET_NO == extract_authorization_message_key (
              entry->message, group_key, &shared_key))
          return;
 
        if (GNUNET_OK != verify_message_by_key (
              event_entry->message, &shared_key))
          return;
 
        if (get_epoch_announcement_key (announcement))
          return;
 
        set_epoch_announcement_key (announcement, &shared_key, GNUNET_YES);
        send_epoch_announcement (announcement);
      }
 
      break;
    }
  case GNUNET_MESSENGER_KIND_GROUP:
    {
      struct GNUNET_MESSENGER_EpochGroup *group;
      const struct GNUNET_HashCode *announcement_hash;
      uint32_t next_level;
 
      identifier = &(event_entry->message->body.group.identifier);
 
      if ((0 == GNUNET_memcmp (identifier, &(auth_group->identifier))) ||
          (GNUNET_YES != is_epoch_identifier_upper (identifier, &(auth_group->
                                                                  identifier))))
        return;
 
      if (! (identifier->code.group_bit))
        return;
 
      group = get_epoch_group (epoch, identifier, GNUNET_NO);
 
      if (! group)
        return;
 
      next_level = get_epoch_group_level (auth_group) + 1;
 
      if (next_level != get_epoch_group_level (group))
        return;
 
      if (event_entry->sender == entry->sender)
        announcement_hash = &(event_entry->message->body.group.initiator);
      else
        announcement_hash = &(event_entry->message->body.group.partner);
 
      event_entry = GNUNET_CONTAINER_multihashmap_get (room->messages,
                                                       announcement_hash);
 
      if (! event_entry)
        return;
 
      if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != event_entry->message->header.
          kind)
        return;
 
      identifier = &(event_entry->message->body.announcement.identifier);
 
      if (0 != GNUNET_memcmp (identifier, &(auth_group->identifier)))
        return;
 
      if (GNUNET_NO == extract_authorization_message_key (
            entry->message, group_key, &shared_key))
        return;
 
      if (get_epoch_group_key (group))
        return;
 
      set_epoch_group_key (group, &shared_key, GNUNET_YES);
      send_epoch_group_announcement (group);
      break;
    }
  default:
    break;
  }
}

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,
		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 2185 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 2244 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 2266 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 2312 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 2326 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_local_members()

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

static

Definition at line 2343 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 2360 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 2390 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 2413 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 2431 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 2454 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 2490 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 2511 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 2545 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

Functions

Function Documentation

◆ create_room()

◆ iterate_destroy_action()

◆ iterate_destroy_message()

◆ iterate_destroy_link()

◆ iterate_destroy_subscription()

◆ iterate_destroy_epoch()

◆ destroy_room()

◆ get_room_key()

◆ is_room_public()

◆ is_message_entry_recent()

◆ get_room_availble_epoch_entry()

◆ handle_room_delayed_deletion()

◆ handle_room_delayed_announcement()

◆ handle_room_delayed_appeal()

◆ handle_room_delayed_action()

◆ handle_room_action_task()

◆ delay_room_action()

◆ cancel_room_action()

◆ iterate_cancel_action_by()

◆ iterate_cancel_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()

◆ is_epoch_identifier_upper()

◆ iterate_room_request()

◆ handle_room_request_task()

◆ require_message_from_room()

◆ handle_message()

◆ handle_join_message()

◆ iterate_room_epoch_member_invalidation()

◆ handle_leave_message()

◆ handle_name_message()

◆ handle_key_message()

◆ handle_id_message()

◆ handle_miss_message()

◆ handle_merge_message()

◆ handle_private_message()

◆ handle_delete_message()

◆ handle_transcript_message()

◆ handle_announcement_message()

◆ handle_secret_message()

◆ handle_appeal_message()

◆ handle_access_message()

◆ handle_revolution_message()

◆ handle_group_message()

◆ handle_authorization_message()

◆ handle_room_message()

◆ update_room_message()

◆ update_room_secret_message()

◆ update_room_last_message()

◆ copy_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()