#include "gnunet_common.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_messenger_service.h"

Include dependency graph for messenger_api_epoch_announcement.h:

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

Data Structures
struct	GNUNET_MESSENGER_EpochAnnouncement

Functions
struct GNUNET_MESSENGER_EpochAnnouncement *	create_epoch_announcement (struct GNUNET_MESSENGER_Epoch epoch, const union GNUNET_MESSENGER_EpochIdentifier identifier, enum GNUNET_GenericReturnValue valid)
	Creates and allocates a new epoch announcement for a given epoch using a specific announcement identifier or NULL.

void	destroy_epoch_announcement (struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Destroys a given epoch announcement and frees its resources.

uint32_t	get_epoch_announcement_size (const struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Returns the size of a given epoch announcement in terms of members.

uint32_t	get_epoch_announcement_members_count (const struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Returns the current amount of members of a given epoch announcement.

enum GNUNET_GenericReturnValue	is_epoch_announcement_completed (const struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Returns whether a given epoch announcement is complete in terms of confirmed announcements from its members.

enum GNUNET_GenericReturnValue	is_epoch_announcement_announced (const struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Returns whether the client has announced being part of a given epoch announcement owning its secret key.

void	set_epoch_announcement_appeal (struct GNUNET_MESSENGER_EpochAnnouncement *announcement, struct GNUNET_TIME_Relative timeout)
	Sets a specified timeout for a given epoch announcement of the client for its own appeal of the announced secret key.

enum GNUNET_GenericReturnValue	is_epoch_announcement_appealed (const struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Returns whether a given epoch announcement of the client is currently appealing for its secret key from other members.

void	set_epoch_announcement_key (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_CRYPTO_SymmetricSessionKey shared_key, enum GNUNET_GenericReturnValue write_record)
	Sets the secret key of a given epoch announcement to a shared key.

const struct GNUNET_CRYPTO_SymmetricSessionKey *	get_epoch_announcement_key (const struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Returns the secret key of a given epoch announcement or NULL.

void	handle_epoch_announcement_message (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)
	Handles an encrypted message with hash by a given epoch announcement using its secret key for decryption if available.

enum GNUNET_GenericReturnValue	confirm_epoch_announcement_member (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_Message message, struct GNUNET_MESSENGER_Contact contact, enum GNUNET_GenericReturnValue sent)
	Confirms an announcement message with its hash to a given epoch announcement as confirmation for a specific contact.

enum GNUNET_GenericReturnValue	revoke_epoch_announcement_member (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_Message message, struct GNUNET_MESSENGER_Contact contact)
	Revokes an announcement message with its hash from a given epoch announcement removing the caused confirmation for a specific contact to be its member.

enum GNUNET_GenericReturnValue	is_epoch_announcement_member (const struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_Contact contact)
	Returns whether a specific contact is confirmed member of a given epoch announcement.

enum GNUNET_GenericReturnValue	get_epoch_announcement_member_hash (const struct GNUNET_MESSENGER_EpochAnnouncement announcement, struct GNUNET_HashCode hash, enum GNUNET_GenericReturnValue other)
	Provides an announcement hash of a member from a given epoch announcement.

void	invalidate_epoch_announcement (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_Contact contact)
	Invalidates a given epoch announcement by a specific contact.

enum GNUNET_GenericReturnValue	send_epoch_announcement (struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Tries to send an announcement message by the client for a given epoch announcement using its secret key.

enum GNUNET_GenericReturnValue	send_epoch_announcement_appeal (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_HashCode event)
	Tries to send an appeal message by the client responding to a previous event in regards to a given epoch announcement requesting its secret key from other members.

enum GNUNET_GenericReturnValue	send_epoch_announcement_access (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_HashCode event)
	Tries to send an access message by the client responding to a previous event in regards to a given epoch announcement using its secret key.

enum GNUNET_GenericReturnValue	send_epoch_announcement_revolution (struct GNUNET_MESSENGER_EpochAnnouncement *announcement)
	Tries to send a revolution message by the client for a given epoch announcement using its secret key.

enum GNUNET_GenericReturnValue	send_epoch_announcement_authorization (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_HashCode *event)
	Tries to send an authorization message by the client responding to a previous event in regards to a given epoch announcement using the secret key from a permitted epoch group.

void	handle_epoch_announcement (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, struct GNUNET_MESSENGER_Contact sender, enum GNUNET_GenericReturnValue sent)
	Handles an announcement message with hash from its sender inside a given epoch announcement as first stage.

void	handle_epoch_announcement_delay (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, struct GNUNET_MESSENGER_Contact sender, enum GNUNET_GenericReturnValue sent)
	Handles an announcement message with hash from its sender inside a given epoch announcement as second stage after custom delay.

void	handle_epoch_announcement_access (struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)
	Handles an access message with hash from its sender inside a given epoch announcement.

void	write_epoch_announcement_record (struct GNUNET_MESSENGER_EpochAnnouncement *announcement, enum GNUNET_GenericReturnValue deleted)
	Writes/Deletes the GNS record of a given epoch announcement depending on a provided flag that states wether an existing record should be deleted.

Function Documentation

◆ create_epoch_announcement()

struct GNUNET_MESSENGER_EpochAnnouncement * create_epoch_announcement	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		enum GNUNET_GenericReturnValue	valid
	)

Creates and allocates a new epoch announcement for a given epoch using a specific announcement identifier or NULL.

Additionally a flag specifies whether that group needs to be valid to allow key derivation based on that property.

Parameters

[in,out]	epoch	Epoch
[in]	identifier	Announcement identifier
[in]	valid	Validity flag

Returns: New epoch announcement or NULL

Definition at line 82 of file messenger_api_epoch_announcement.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
  const struct GNUNET_MESSENGER_EpochAnnouncement *previous;
 
  GNUNET_assert (epoch);
 
  announcement = GNUNET_new (struct GNUNET_MESSENGER_EpochAnnouncement);
 
  if (! announcement)
    return NULL;
 
  previous = get_epoch_previous_announcement (epoch, identifier);
 
  if ((GNUNET_YES == valid) && (previous) &&
      (GNUNET_YES != previous->valid))
    previous = NULL;
 
  if (previous)
    identifier = &(previous->identifier);
 
  if (identifier)
    GNUNET_memcpy (&(announcement->identifier), identifier,
                   sizeof (announcement->identifier));
  else
    random_epoch_announcement_identifier (&(announcement->identifier));
 
  GNUNET_assert (! announcement->identifier.code.group_bit);
 
  announcement->announcement_expiration = GNUNET_TIME_absolute_get_zero_ ();
  announcement->appeal = NULL;
 
  announcement->appeal_task = NULL;
 
  announcement->epoch = epoch;
  announcement->membership = create_epoch_membership (
    get_epoch_announcement_size (announcement));
  announcement->shared_key = NULL;
  announcement->query = NULL;
 
  announcement->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  announcement->valid = GNUNET_YES;
  announcement->stored = GNUNET_NO;
 
  if (previous)
  {
    struct GNUNET_CRYPTO_SymmetricSessionKey key;
 
    if (GNUNET_OK == derive_epoch_announcement_key (announcement,
                                                    previous,
                                                    &key))
    {
      set_epoch_announcement_key (announcement, &key, GNUNET_YES);
 
      announcement->valid = previous->valid;
    }
  }
 
  return announcement;
}

Referenced by generate_room_epoch_announcement(), and get_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_epoch_announcement()

void destroy_epoch_announcement ( struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Destroys a given epoch announcement and frees its resources.

Parameters

[in,out] announcement Epoch announcement

Definition at line 149 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  if (announcement->messages)
    GNUNET_CONTAINER_multihashmap_destroy (announcement->messages);
 
  if (announcement->membership)
    destroy_epoch_membership (announcement->membership);
 
  if (announcement->shared_key)
    GNUNET_free (announcement->shared_key);
 
  if (announcement->query)
    GNUNET_NAMESTORE_cancel (announcement->query);
 
  if (announcement->appeal_task)
    GNUNET_SCHEDULER_cancel (announcement->appeal_task);
 
  if (announcement->appeal)
    GNUNET_free (announcement->appeal);
 
  GNUNET_free (announcement);
}

References GNUNET_MESSENGER_EpochAnnouncement::appeal, GNUNET_MESSENGER_EpochAnnouncement::appeal_task, destroy_epoch_membership(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_MESSENGER_EpochAnnouncement::membership, GNUNET_MESSENGER_EpochAnnouncement::messages, GNUNET_MESSENGER_EpochAnnouncement::query, and GNUNET_MESSENGER_EpochAnnouncement::shared_key.

Referenced by generate_room_epoch_announcement(), get_epoch_announcement(), and iterate_destroy_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_announcement_size()

uint32_t get_epoch_announcement_size ( const struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Returns the size of a given epoch announcement in terms of members.

Parameters

[in] announcement Epoch announcement

Returns: Maximum announcement size

Definition at line 177 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  return get_epoch_size (announcement->epoch);
}

References GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_size(), and GNUNET_assert.

Referenced by create_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_announcement_members_count()

uint32_t get_epoch_announcement_members_count ( const struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Returns the current amount of members of a given epoch announcement.

Parameters

[in] announcement Epoch announcement

Returns: Amount of confirmed members of announcement

Definition at line 187 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  return get_epoch_membership_count (announcement->membership);
}

References get_epoch_membership_count(), GNUNET_assert, and GNUNET_MESSENGER_EpochAnnouncement::membership.

Referenced by is_epoch_group_missing_announcement(), is_other_epoch_announcement_better(), and send_epoch_announcement_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_announcement_completed()

enum GNUNET_GenericReturnValue is_epoch_announcement_completed ( const struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Returns whether a given epoch announcement is complete in terms of confirmed announcements from its members.

Parameters

[in] announcement Epoch announcement

Returns: GNUNET_YES if complete, otherwise GNUNET_NO

Definition at line 198 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  return is_epoch_membership_completed (announcement->membership);
}

References GNUNET_assert, is_epoch_membership_completed(), and GNUNET_MESSENGER_EpochAnnouncement::membership.

Referenced by handle_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_announcement_announced()

enum GNUNET_GenericReturnValue is_epoch_announcement_announced ( const struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Returns whether the client has announced being part of a given epoch announcement owning its secret key.

Parameters

[in] announcement Epoch announcement

Returns: GNUNET_YES if client is active member of the group, otherwise GNUNET_NO

Definition at line 209 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  return is_epoch_membership_member (announcement->membership, NULL);
}

References GNUNET_assert, is_epoch_membership_member(), and GNUNET_MESSENGER_EpochAnnouncement::membership.

Referenced by handle_epoch_announcement(), and propose_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_epoch_announcement_appeal()

void set_epoch_announcement_appeal	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		struct GNUNET_TIME_Relative	timeout
	)

Sets a specified timeout for a given epoch announcement of the client for its own appeal of the announced secret key.

Parameters

[in,out]	announcement	Epoch announcement
[in]	timeout	Timeout of appeal

Definition at line 242 of file messenger_api_epoch_announcement.c.

{
  struct GNUNET_TIME_Absolute timepoint;
 
  GNUNET_assert (announcement);
 
  timepoint = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), timeout);
 
  if (! announcement->appeal)
    announcement->appeal = GNUNET_new (struct GNUNET_TIME_Absolute);
  else if (GNUNET_TIME_absolute_cmp (*(announcement->appeal), >, timepoint))
    return;
 
  GNUNET_memcpy (announcement->appeal, &timepoint, sizeof (timepoint));
 
  if (announcement->appeal_task)
    GNUNET_SCHEDULER_cancel (announcement->appeal_task);
 
  announcement->appeal_task = GNUNET_SCHEDULER_add_at_with_priority (
    *(announcement->appeal),
    GNUNET_SCHEDULER_PRIORITY_HIGH,
    task_epoch_announcement_appeal,
    announcement);
}

References GNUNET_MESSENGER_EpochAnnouncement::appeal, GNUNET_MESSENGER_EpochAnnouncement::appeal_task, GNUNET_assert, GNUNET_memcpy, GNUNET_new, GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get(), task_epoch_announcement_appeal(), and timeout.

Referenced by handle_appeal_message(), and send_epoch_announcement_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_announcement_appealed()

enum GNUNET_GenericReturnValue is_epoch_announcement_appealed ( const struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Returns whether a given epoch announcement of the client is currently appealing for its secret key from other members.

Parameters

[in] announcement Epoch announcement

Returns: GNUNET_YES if it is appealing, otherwise GNUNET_NO

Definition at line 271 of file messenger_api_epoch_announcement.c.

{
  struct GNUNET_TIME_Relative time;
 
  GNUNET_assert (announcement);
 
  if (! announcement->appeal)
    return GNUNET_NO;
 
  time = GNUNET_TIME_absolute_get_remaining (*(announcement->appeal));
 
  if (GNUNET_YES == GNUNET_TIME_relative_is_zero (time))
    return GNUNET_NO;
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_EpochAnnouncement::appeal, GNUNET_assert, GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_is_zero(), and GNUNET_YES.

Referenced by handle_epoch_announcement_delay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_epoch_announcement_key()

void set_epoch_announcement_key	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key,
		enum GNUNET_GenericReturnValue	write_record
	)

Sets the secret key of a given epoch announcement to a shared key.

An additional flag decides whether the shared key has been loaded from storage or whether it should write its record afterwards.

Parameters

[in,out]	announcement	Epoch announcement
[in]	shared_key	Shared key or NULL
[in]	write_record	GNUNET_YES if the record should be written, otherwise GNUNET_NO

Definition at line 296 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  if ((GNUNET_NO == write_record) && (shared_key))
    announcement->stored = GNUNET_YES;
 
  if (announcement->shared_key)
    return;
 
  announcement->shared_key = GNUNET_new (struct
                                         GNUNET_CRYPTO_SymmetricSessionKey);
 
  if (! announcement->shared_key)
    return;
 
  if (shared_key)
    GNUNET_memcpy (announcement->shared_key, shared_key,
                   sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey));
  else
    GNUNET_CRYPTO_symmetric_create_session_key (announcement->shared_key);
 
  update_epoch_announcement (announcement->epoch, announcement);
 
  if (GNUNET_YES != announcement->stored)
    write_epoch_announcement_record (announcement, GNUNET_NO);
 
  handle_secret_messages_with_key (announcement);
}

References GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_assert, GNUNET_CRYPTO_symmetric_create_session_key(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_YES, handle_secret_messages_with_key(), GNUNET_MESSENGER_EpochAnnouncement::shared_key, GNUNET_MESSENGER_EpochAnnouncement::stored, update_epoch_announcement(), and write_epoch_announcement_record().

Referenced by cb_key_monitor(), create_epoch_announcement(), generate_room_epoch_announcement(), handle_authorization_message(), and handle_epoch_announcement_access().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_announcement_key()

const struct GNUNET_CRYPTO_SymmetricSessionKey * get_epoch_announcement_key ( const struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Returns the secret key of a given epoch announcement or NULL.

Parameters

[in] announcement Epoch announcement

Returns: Secret key or NULL

Definition at line 332 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  return announcement->shared_key;
}

References GNUNET_assert, and GNUNET_MESSENGER_EpochAnnouncement::shared_key.

Here is the caller graph for this function:

◆ handle_epoch_announcement_message()

void handle_epoch_announcement_message	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Handles an encrypted message with hash by a given epoch announcement using its secret key for decryption if available.

Parameters

[in,out]	announcement	Epoch announcement
[in]	message	Message
[in]	hash	Hash of message

Definition at line 422 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert ((announcement) && (message) && (hash) &&
                 (GNUNET_MESSENGER_KIND_SECRET == message->header.kind));
 
  if (! get_epoch_announcement_key (announcement))
  {
    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (announcement->
                                                              messages, hash))
      return;
 
    GNUNET_CONTAINER_multihashmap_put (announcement->messages,
                                       hash, NULL,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
    return;
  }
 
  handle_secret_message_with_key (announcement, hash, GNUNET_NO);
}

References get_epoch_announcement_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_MESSENGER_KIND_SECRET, GNUNET_NO, GNUNET_YES, handle_secret_message_with_key(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_EpochAnnouncement::messages.

Referenced by handle_secret_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ confirm_epoch_announcement_member()

enum GNUNET_GenericReturnValue confirm_epoch_announcement_member	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MESSENGER_Contact *	contact,
		enum GNUNET_GenericReturnValue	sent
	)

Confirms an announcement message with its hash to a given epoch announcement as confirmation for a specific contact.

An additional flag specifies whether the message has been sent by the client or not.

Parameters

[in,out]	announcement	Epoch announcement
[in]	hash	Hash of message
[in]	message	Message
[in,out]	contact	Contact
[in]	sent	Sent flag

Returns: GNUNET_YES on success, GNUNET_SYSERR on internal failure, otherwise GNUNET_NO

Definition at line 448 of file messenger_api_epoch_announcement.c.

{
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((announcement) && (hash) && (message) && (contact));
 
  if (GNUNET_YES != is_epoch_member (announcement->epoch, contact))
    return GNUNET_SYSERR;
 
  result = confirm_epoch_membership_announcment (announcement->membership,
                                                 hash,
                                                 message,
                                                 contact,
                                                 sent);
 
  if (GNUNET_YES != result)
    return result;
 
  update_epoch_announcement (announcement->epoch, announcement);
  return GNUNET_YES;
}

References confirm_epoch_membership_announcment(), GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_assert, GNUNET_SYSERR, GNUNET_YES, is_epoch_member(), GNUNET_MESSENGER_EpochAnnouncement::membership, result, and update_epoch_announcement().

Referenced by handle_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ revoke_epoch_announcement_member()

enum GNUNET_GenericReturnValue revoke_epoch_announcement_member	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MESSENGER_Contact *	contact
	)

Revokes an announcement message with its hash from a given epoch announcement removing the caused confirmation for a specific contact to be its member.

This might be caused by deletion of the original announcement message by that member.

Parameters

[in,out]	announcement	Epoch announcement
[in]	hash	Hash of message
[in]	message	Message
[in,out]	contact	Contact

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 478 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert ((announcement) && (hash) && (message) && (contact));
 
  if (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != message->header.kind)
    return GNUNET_SYSERR;
 
  return revoke_epoch_membership_announcement (announcement->membership,
                                               hash, contact);
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_SYSERR, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_EpochAnnouncement::membership, and revoke_epoch_membership_announcement().

Referenced by handle_room_delayed_deletion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_announcement_member()

enum GNUNET_GenericReturnValue is_epoch_announcement_member	(	const struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Returns whether a specific contact is confirmed member of a given epoch announcement.

Parameters

[in]	announcement	Epoch announcement
[in]	contact	Contact

Returns: GNUNET_YES if the contact is a member, otherwise GNUNET_NO

Definition at line 496 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert (announcement);
 
  return is_epoch_membership_member (announcement->membership, contact);
}

References GNUNET_assert, is_epoch_membership_member(), and GNUNET_MESSENGER_EpochAnnouncement::membership.

Referenced by handle_appeal_message(), handle_epoch_announcement(), handle_room_delayed_appeal(), it_check_epoch_announcement_member(), and task_epoch_announcement_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_announcement_member_hash()

enum GNUNET_GenericReturnValue get_epoch_announcement_member_hash	(	const struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		struct GNUNET_HashCode *	hash,
		enum GNUNET_GenericReturnValue	other
	)

Provides an announcement hash of a member from a given epoch announcement.

Depending on a flag it provides some hash of another member or the clients own announcement.

Parameters

[in]	announcement	Epoch announcement
[out]	hash	Hash of announcement
[in]	other	Other flag

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 507 of file messenger_api_epoch_announcement.c.

{
  GNUNET_assert ((announcement) && (hash));
 
  return get_epoch_membership_member_hash (
    announcement->membership, hash, other);
}

References get_epoch_membership_member_hash(), GNUNET_assert, and GNUNET_MESSENGER_EpochAnnouncement::membership.

Referenced by handle_access_message(), propose_epoch_group(), and task_epoch_announcement_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invalidate_epoch_announcement()

void invalidate_epoch_announcement	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Invalidates a given epoch announcement by a specific contact.

Parameters

[in,out]	announcement	Epoch announcement
[in]	contact	Contact

Definition at line 521 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_MESSENGER_Message *message;
  struct GNUNET_MESSENGER_EpochAnnouncement *previous;
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert (announcement);
 
  if (GNUNET_NO == announcement->valid)
    return;
 
  if ((contact) && (GNUNET_YES != is_epoch_member (announcement->epoch,
                                                   contact)))
    return;
 
  announcement->valid = GNUNET_NO;
  write_epoch_announcement_record (announcement, GNUNET_NO);
 
  message = get_room_message (announcement->epoch->room,
                              &(announcement->epoch->hash));
 
  if (! message)
    goto skip_traversal;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    epoch = get_room_epoch (
      announcement->epoch->room, &(message->body.join.epoch), GNUNET_NO);
 
    if (epoch)
      previous = get_epoch_announcement (
        epoch, &(announcement->identifier), GNUNET_SYSERR);
    else
      previous = NULL;
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    epoch = get_room_epoch (
      announcement->epoch->room, &(message->body.leave.epoch), GNUNET_NO);
 
    if (epoch)
      previous = get_epoch_announcement (
        epoch, &(announcement->identifier), GNUNET_SYSERR);
    else
      previous = NULL;
    break;
  case GNUNET_MESSENGER_KIND_MERGE:
    epoch = get_room_epoch (
      announcement->epoch->room, &(message->body.merge.epochs[0]), GNUNET_NO);
 
    if (epoch)
    {
      previous = get_epoch_announcement (
        epoch, &(announcement->identifier), GNUNET_SYSERR);
 
      if ((previous) &&
          (GNUNET_YES != is_epoch_announcement_key_derived_from (previous,
                                                                 announcement)))
        previous = NULL;
    }
    else
      previous = NULL;
 
    if (! previous)
    {
      epoch = get_room_epoch (
        announcement->epoch->room, &(message->body.merge.epochs[1]), GNUNET_NO);
 
      if (epoch)
        previous = get_epoch_announcement (
          epoch, &(announcement->identifier), GNUNET_SYSERR);
    }
    break;
  default:
    previous = NULL;
    break;
  }
 
  if ((previous) &&
      (GNUNET_YES != is_epoch_announcement_key_derived_from (previous,
                                                             announcement)))
    previous = NULL;
 
  if (previous)
    invalidate_epoch_announcement (previous, contact);
 
skip_traversal:
  if (announcement->epoch->main_announcement != announcement)
    return;
 
  announcement->epoch->main_announcement = get_epoch_announcement (
    announcement->epoch, NULL, GNUNET_YES);
}

Referenced by handle_revolution_message(), invalidate_epoch_announcement(), and iterate_epoch_announcement_invalidation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_announcement()

enum GNUNET_GenericReturnValue send_epoch_announcement ( struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Tries to send an announcement message by the client for a given epoch announcement using its secret key.

Parameters

[in,out] announcement Epoch announcement

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 620 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key;
  struct GNUNET_TIME_Relative timeout;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert (announcement);
 
  key = get_epoch_announcement_key (announcement);
 
  if (! key)
    return GNUNET_SYSERR;
 
  timeout = GNUNET_TIME_absolute_get_remaining (
    announcement->announcement_expiration);
 
  if (GNUNET_YES != GNUNET_TIME_relative_is_zero (timeout))
    return GNUNET_NO;
 
  timeout = GNUNET_TIME_relative_multiply (
    GNUNET_TIME_relative_get_hour_ (), 48);
 
  private_key = get_epoch_private_key (announcement->epoch,
                                       timeout);
 
  if (! private_key)
    return GNUNET_SYSERR;
 
  timeout = get_epoch_private_key_timeout (announcement->epoch);
 
  message = create_message_announcement (&(announcement->identifier),
                                         private_key,
                                         key,
                                         timeout);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (announcement->epoch, message);
 
  announcement->announcement_expiration = GNUNET_TIME_absolute_add (
    GNUNET_TIME_absolute_get (), timeout);
 
  return GNUNET_OK;
}

References GNUNET_MESSENGER_EpochAnnouncement::announcement_expiration, create_message_announcement(), GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement_key(), get_epoch_private_key(), get_epoch_private_key_timeout(), GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_get_hour_(), GNUNET_TIME_relative_is_zero(), GNUNET_TIME_relative_multiply(), GNUNET_YES, GNUNET_MESSENGER_EpochAnnouncement::identifier, key, send_epoch_message(), and timeout.

Referenced by generate_room_epoch_announcement(), handle_authorization_message(), handle_epoch_announcement(), and handle_epoch_announcement_access().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_announcement_appeal()

enum GNUNET_GenericReturnValue send_epoch_announcement_appeal	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_HashCode *	event
	)

Tries to send an appeal message by the client responding to a previous event in regards to a given epoch announcement requesting its secret key from other members.

Parameters

[in,out]	announcement	Epoch announcement
[in]	event	Hash of event message

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 686 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key;
  struct GNUNET_TIME_Relative timeout;
  struct GNUNET_HashCode event_hash;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert (announcement);
 
  timeout = GNUNET_TIME_relative_get_hour_ ();
  private_key = get_epoch_private_key (announcement->epoch,
                                       timeout);
 
  if (! private_key)
    return GNUNET_SYSERR;
 
  timeout = get_epoch_private_key_timeout (announcement->epoch);
 
  if ((! event) ||
      (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (announcement->
                                                             membership->members
                                                             , event)))
  {
    if (get_epoch_announcement_members_count (announcement) <= 0)
      return GNUNET_SYSERR;
 
    GNUNET_CONTAINER_multihashmap_iterate (announcement->membership->members,
                                           it_store_any_event,
                                           &event_hash);
 
    event = &event_hash;
  }
 
  message = create_message_appeal (event,
                                   private_key,
                                   timeout);
 
  if (! message)
    return GNUNET_SYSERR;
 
  set_epoch_announcement_appeal (announcement, timeout);
  send_epoch_message (announcement->epoch, message);
  return GNUNET_OK;
}

References create_message_appeal(), GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement_members_count(), get_epoch_private_key(), get_epoch_private_key_timeout(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_relative_get_hour_(), GNUNET_YES, it_store_any_event(), GNUNET_MESSENGER_EpochMembership::members, GNUNET_MESSENGER_EpochAnnouncement::membership, send_epoch_message(), set_epoch_announcement_appeal(), and timeout.

Referenced by handle_epoch_announcement_delay(), and task_epoch_announcement_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_announcement_access()

enum GNUNET_GenericReturnValue send_epoch_announcement_access	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_HashCode *	event
	)

Tries to send an access message by the client responding to a previous event in regards to a given epoch announcement using its secret key.

Parameters

[in,out]	announcement	Epoch announcement
[in]	event	Hash of event message

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 735 of file messenger_api_epoch_announcement.c.

{
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  const struct GNUNET_MESSENGER_Message *appeal_message;
  const struct GNUNET_CRYPTO_EcdhePublicKey *public_key;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((announcement) && (event));
 
  room = announcement->epoch->room;
  key = get_epoch_announcement_key (announcement);
 
  if (! key)
    return GNUNET_SYSERR;
 
  appeal_message = get_room_message (room, event);
 
  if (! appeal_message)
    return GNUNET_SYSERR;
 
  if (GNUNET_MESSENGER_KIND_APPEAL != appeal_message->header.kind)
    return GNUNET_SYSERR;
 
  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (announcement->
                                                            membership->members,
                                                            &(appeal_message->
                                                              body.appeal.event)
                                                            ))
    return GNUNET_SYSERR;
 
  public_key = &(appeal_message->body.appeal.key);
  message = create_message_access (event,
                                   public_key,
                                   key);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (announcement->epoch, message);
  return GNUNET_OK;
}

References GNUNET_MESSENGER_MessageBody::appeal, GNUNET_MESSENGER_Message::body, create_message_access(), GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_MESSENGER_MessageAppeal::event, get_epoch_announcement_key(), get_room_message(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_MESSENGER_KIND_APPEAL, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageAppeal::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Epoch::room, and send_epoch_message().

Referenced by handle_room_delayed_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_announcement_revolution()

enum GNUNET_GenericReturnValue send_epoch_announcement_revolution ( struct GNUNET_MESSENGER_EpochAnnouncement * announcement )

Tries to send a revolution message by the client for a given epoch announcement using its secret key.

Parameters

[in,out] announcement Epoch announcement

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 782 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert (announcement);
 
  key = get_epoch_announcement_key (announcement);
 
  if (! key)
    return GNUNET_SYSERR;
 
  message = create_message_revolution (&(announcement->identifier),
                                       key);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (announcement->epoch, message);
  return GNUNET_OK;
}

References create_message_revolution(), GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement_key(), GNUNET_assert, GNUNET_OK, GNUNET_SYSERR, GNUNET_MESSENGER_EpochAnnouncement::identifier, key, and send_epoch_message().

Referenced by handle_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_announcement_authorization()

enum GNUNET_GenericReturnValue send_epoch_announcement_authorization	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_HashCode *	event
	)

Tries to send an authorization message by the client responding to a previous event in regards to a given epoch announcement using the secret key from a permitted epoch group.

Parameters

[in,out]	announcement	Epoch announcement
[in]	group	Epoch group
[in]	event	Hash of event message

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 807 of file messenger_api_epoch_announcement.c.

{
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  const struct GNUNET_MESSENGER_Message *announcement_message;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *group_key;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((announcement) && (group) && (event));
 
  room = group->epoch->room;
  key = get_epoch_announcement_key (announcement);
 
  if (! key)
    return GNUNET_SYSERR;
 
  if (! group->identifier.code.group_bit)
    return GNUNET_SYSERR;
 
  announcement_message = get_room_message (room, event);
 
  if ((! announcement_message) ||
      (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != announcement_message->header.kind))
    return GNUNET_SYSERR;
 
  identifier = &(announcement_message->body.announcement.identifier);
 
  if (0 != GNUNET_memcmp (&(announcement->identifier), identifier))
    return GNUNET_SYSERR;
 
  if (GNUNET_YES != verify_message_by_key (announcement_message, key))
    return GNUNET_SYSERR;
 
  group_key = get_epoch_group_key (group);
 
  if (! group_key)
    return GNUNET_SYSERR;
 
  message = create_message_authorization (&(group->identifier),
                                          event,
                                          group_key,
                                          key);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (announcement->epoch, message);
  return GNUNET_OK;
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, create_message_authorization(), GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_announcement_key(), get_epoch_group_key(), get_room_message(), GNUNET_assert, GNUNET_memcmp, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageAnnouncement::identifier, GNUNET_MESSENGER_EpochAnnouncement::identifier, GNUNET_MESSENGER_EpochGroup::identifier, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Epoch::room, send_epoch_message(), and verify_message_by_key().

Referenced by handle_epoch_announcement_access().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_epoch_announcement()

void handle_epoch_announcement	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		struct GNUNET_MESSENGER_Contact *	sender,
		enum GNUNET_GenericReturnValue	sent
	)

Handles an announcement message with hash from its sender inside a given epoch announcement as first stage.

Parameters

[in,out]	announcement	Epoch announcement
[in]	message	Message
[in]	hash	Hash of message
[in]	sender	Sender of message
[in]	sent	Sent flag

Definition at line 865 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert ((announcement) && (message) && (hash) && (sender));
 
  key = get_epoch_announcement_key (announcement);
 
  if (key)
  {
    if (GNUNET_OK != verify_message_by_key (message, key))
      return;
 
    cancel_room_actions_by (announcement->epoch->room,
                            GNUNET_MESSENGER_KIND_APPEAL,
                            &(announcement->epoch->hash),
                            &(announcement->identifier),
                            sender);
 
    if ((GNUNET_YES == is_epoch_announcement_completed (announcement)) &&
        (GNUNET_YES != is_epoch_announcement_member (announcement, sender)))
    {
      send_epoch_announcement_revolution (announcement);
      return;
    }
  }
 
  if (GNUNET_YES != confirm_epoch_announcement_member (announcement,
                                                       hash,
                                                       message,
                                                       sender,
                                                       sent))
    return;
 
  if ((GNUNET_YES != sent) &&
      (GNUNET_YES != is_epoch_announcement_announced (announcement)))
  {
    const struct GNUNET_MESSENGER_Contact *contact;
 
    contact = get_handle_contact (
      get_room_handle (announcement->epoch->room),
      get_room_key (announcement->epoch->room));
 
    send_epoch_announcement (announcement);
 
    timeout = GNUNET_TIME_relative_multiply_double (
      get_message_timeout (message),
      get_epoch_position_factor (announcement->epoch, contact,
                                 announcement->membership));
  }
  else if (announcement->epoch->main_group)
    timeout = GNUNET_TIME_relative_multiply_double (
      get_message_timeout (message),
      get_epoch_group_position_factor (announcement->epoch->main_group));
  else
    timeout = GNUNET_TIME_relative_get_zero_ ();
 
  delay_room_action (announcement->epoch->room, hash, timeout);
}

References cancel_room_actions_by(), confirm_epoch_announcement_member(), delay_room_action(), GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement_key(), get_epoch_group_position_factor(), get_epoch_position_factor(), get_handle_contact(), get_message_timeout(), get_room_handle(), get_room_key(), GNUNET_assert, GNUNET_MESSENGER_KIND_APPEAL, GNUNET_OK, GNUNET_TIME_relative_get_zero_(), GNUNET_TIME_relative_multiply_double(), GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_EpochAnnouncement::identifier, is_epoch_announcement_announced(), is_epoch_announcement_completed(), is_epoch_announcement_member(), key, GNUNET_MESSENGER_Epoch::main_group, GNUNET_MESSENGER_EpochAnnouncement::membership, GNUNET_MESSENGER_Epoch::room, send_epoch_announcement(), send_epoch_announcement_revolution(), timeout, and verify_message_by_key().

Referenced by handle_announcement_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_epoch_announcement_delay()

void handle_epoch_announcement_delay	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		struct GNUNET_MESSENGER_Contact *	sender,
		enum GNUNET_GenericReturnValue	sent
	)

Handles an announcement message with hash from its sender inside a given epoch announcement as second stage after custom delay.

Parameters

[in,out]	announcement	Epoch announcement
[in]	message	Message
[in]	hash	Hash of message
[in]	sender	Sender of message
[in]	sent	Sent flag

Definition at line 933 of file messenger_api_epoch_announcement.c.

{
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert ((announcement) && (message) && (hash) && (sender));
 
  if (GNUNET_YES == is_room_public (announcement->epoch->room))
    return;
 
  if ((GNUNET_YES == sent) && (GNUNET_YES == announcement->valid))
    propose_epoch_group (
      announcement->epoch,
      GNUNET_TIME_relative_get_hour_ ());
 
  if ((get_epoch_announcement_key (announcement)) ||
      (GNUNET_YES == is_epoch_announcement_appealed (announcement)))
    return;
 
  timeout = get_message_timeout (message);
 
  if (GNUNET_TIME_relative_is_zero (timeout))
    return;
 
  send_epoch_announcement_appeal (announcement, hash);
}

References GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement_key(), get_message_timeout(), GNUNET_assert, GNUNET_TIME_relative_get_hour_(), GNUNET_TIME_relative_is_zero(), GNUNET_YES, is_epoch_announcement_appealed(), is_room_public(), propose_epoch_group(), GNUNET_MESSENGER_Epoch::room, send_epoch_announcement_appeal(), timeout, and GNUNET_MESSENGER_EpochAnnouncement::valid.

Referenced by handle_room_delayed_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_epoch_announcement_access()

void handle_epoch_announcement_access	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Handles an access message with hash from its sender inside a given epoch announcement.

Parameters

[in,out]	announcement	Epoch announcement
[in]	message	Message
[in]	hash	Hash of message
[in]	sender	Sender of message
[in]	sent	Sent flag

Definition at line 967 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key;
  struct GNUNET_CRYPTO_SymmetricSessionKey shared_key;
  const struct GNUNET_MESSENGER_Message *appeal_message;
 
  GNUNET_assert ((announcement) && (message) && (hash));
 
  private_key = get_epoch_private_key (announcement->epoch,
                                       GNUNET_TIME_relative_get_hour_ ());
 
  if (! private_key)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Private key for decrypting shared key is missing!\n");
    return;
  }
 
  if (GNUNET_NO == extract_access_message_key (
        message, private_key, &shared_key))
    return;
 
  if (get_epoch_announcement_key (announcement))
    return;
 
  set_epoch_announcement_key (announcement, &shared_key, GNUNET_YES);
 
  appeal_message = get_room_message (
    announcement->epoch->room,
    &(message->body.access.event));
 
  if ((announcement->epoch->main_group) &&
      (appeal_message) &&
      (GNUNET_MESSENGER_KIND_APPEAL == appeal_message->header.kind) &&
      (GNUNET_YES == is_epoch_group_compatible (announcement->epoch->main_group,
                                                announcement->epoch)) &&
      (GNUNET_YES == is_epoch_group_missing_announcement (
         announcement->epoch->main_group, announcement)))
    send_epoch_announcement_authorization (
      announcement, announcement->epoch->main_group,
      &(appeal_message->body.appeal.event));
 
  send_epoch_announcement (announcement);
}

References GNUNET_MESSENGER_MessageBody::access, GNUNET_MESSENGER_MessageBody::appeal, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_MESSENGER_MessageAppeal::event, GNUNET_MESSENGER_MessageAccess::event, extract_access_message_key(), get_epoch_announcement_key(), get_epoch_private_key(), get_room_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_KIND_APPEAL, GNUNET_NO, GNUNET_TIME_relative_get_hour_(), GNUNET_YES, GNUNET_MESSENGER_Message::header, is_epoch_group_compatible(), is_epoch_group_missing_announcement(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Epoch::main_group, GNUNET_MESSENGER_Epoch::room, send_epoch_announcement(), send_epoch_announcement_authorization(), and set_epoch_announcement_key().

Referenced by handle_access_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_epoch_announcement_record()

void write_epoch_announcement_record	(	struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		enum GNUNET_GenericReturnValue	deleted
	)

Writes/Deletes the GNS record of a given epoch announcement depending on a provided flag that states wether an existing record should be deleted.

Parameters

[in,out]	announcement	Epoch announcement
[in]	deleted	Deleted flag

Definition at line 1036 of file messenger_api_epoch_announcement.c.

{
  const struct GNUNET_MESSENGER_Handle *handle;
  const struct GNUNET_HashCode *key;
  const struct GNUNET_HashCode *hash;
  const struct GNUNET_ShortHashCode *identifier;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key;
 
  GNUNET_assert ((announcement) && (announcement->epoch));
 
  handle = get_room_handle (announcement->epoch->room);
 
  if (! handle)
    return;
 
  key = get_room_key (announcement->epoch->room);
  hash = &(announcement->epoch->hash);
  identifier = &(announcement->identifier.hash);
 
  if (GNUNET_YES == deleted)
  {
    shared_key = NULL;
  }
  else
  {
    shared_key = announcement->shared_key;
 
    if (! shared_key)
      return;
  }
 
  store_handle_epoch_key (
    handle, key, hash, identifier, shared_key,
    GNUNET_YES == announcement->valid?
    GNUNET_MESSENGER_FLAG_EPOCH_VALID :
    GNUNET_MESSENGER_FLAG_EPOCH_NONE,
    &cont_write_epoch_announcement_record,
    announcement,
    &(announcement->query));
}

Referenced by invalidate_epoch_announcement(), it_announcement_store_key(), and set_epoch_announcement_key().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ create_epoch_announcement()

◆ destroy_epoch_announcement()

◆ get_epoch_announcement_size()

◆ get_epoch_announcement_members_count()

◆ is_epoch_announcement_completed()

◆ is_epoch_announcement_announced()

◆ set_epoch_announcement_appeal()

◆ is_epoch_announcement_appealed()

◆ set_epoch_announcement_key()

◆ get_epoch_announcement_key()

◆ handle_epoch_announcement_message()

◆ confirm_epoch_announcement_member()

◆ revoke_epoch_announcement_member()

◆ is_epoch_announcement_member()

◆ get_epoch_announcement_member_hash()

◆ invalidate_epoch_announcement()

◆ send_epoch_announcement()

◆ send_epoch_announcement_appeal()

◆ send_epoch_announcement_access()

◆ send_epoch_announcement_revolution()

◆ send_epoch_announcement_authorization()

◆ handle_epoch_announcement()

◆ handle_epoch_announcement_delay()

◆ handle_epoch_announcement_access()

◆ write_epoch_announcement_record()